mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-08 21:46:06 +00:00
Add ru version (#1865)
* Add Russian docs site baseline * Add Russian localized codebase * Polish Russian code wording * Update ru code translation. * Update code translation and chapter covers. * Fix pythontutor extraction. * Add README and landing page. * placeholder of profiles * Use figures of English version * Remove chapter paperbook
This commit is contained in:
Yudong Jin
@@ -0,0 +1,140 @@
|
||||
// File: array_queue.zig
|
||||
// Created Time: 2023-01-15
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Очередь на основе кольцевого массива
|
||||
pub fn ArrayQueue(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
nums: []T = undefined, // Массив для хранения элементов очереди
|
||||
cap: usize = 0, // Вместимость очереди
|
||||
front: usize = 0, // Указатель head, указывающий на первый элемент очереди
|
||||
queSize: usize = 0, // Указатель хвоста, указывающий на позицию после хвоста
|
||||
mem_arena: ?std.heap.ArenaAllocator = null,
|
||||
mem_allocator: std.mem.Allocator = undefined, // Аллокатор памяти
|
||||
|
||||
// Конструктор (выделение памяти + инициализация массива)
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {
|
||||
if (self.mem_arena == null) {
|
||||
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
|
||||
self.mem_allocator = self.mem_arena.?.allocator();
|
||||
}
|
||||
self.cap = cap;
|
||||
self.nums = try self.mem_allocator.alloc(T, self.cap);
|
||||
@memset(self.nums, @as(T, 0));
|
||||
}
|
||||
|
||||
// Деструктор (освобождение памяти)
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.mem_arena == null) return;
|
||||
self.mem_arena.?.deinit();
|
||||
}
|
||||
|
||||
// Получить вместимость очереди
|
||||
pub fn capacity(self: *Self) usize {
|
||||
return self.cap;
|
||||
}
|
||||
|
||||
// Получение длины очереди
|
||||
pub fn size(self: *Self) usize {
|
||||
return self.queSize;
|
||||
}
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
pub fn isEmpty(self: *Self) bool {
|
||||
return self.queSize == 0;
|
||||
}
|
||||
|
||||
// Поместить в очередь
|
||||
pub fn push(self: *Self, num: T) !void {
|
||||
if (self.size() == self.capacity()) {
|
||||
std.debug.print("Очередь заполнена\n", .{});
|
||||
return;
|
||||
}
|
||||
// Вычислить указатель хвоста, указывающий на индекс хвоста + 1
|
||||
// С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
|
||||
var rear = (self.front + self.queSize) % self.capacity();
|
||||
// Добавить num после хвостового узла
|
||||
self.nums[rear] = num;
|
||||
self.queSize += 1;
|
||||
}
|
||||
|
||||
// Извлечь из очереди
|
||||
pub fn pop(self: *Self) T {
|
||||
var num = self.peek();
|
||||
// Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
|
||||
self.front = (self.front + 1) % self.capacity();
|
||||
self.queSize -= 1;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
pub fn peek(self: *Self) T {
|
||||
if (self.isEmpty()) @panic("очередь пуста");
|
||||
return self.nums[self.front];
|
||||
}
|
||||
|
||||
// Вернуть массив
|
||||
pub fn toArray(self: *Self) ![]T {
|
||||
// Преобразовывать только элементы списка в пределах фактической длины
|
||||
var res = try self.mem_allocator.alloc(T, self.size());
|
||||
@memset(res, @as(T, 0));
|
||||
var i: usize = 0;
|
||||
var j: usize = self.front;
|
||||
while (i < self.size()) : ({ i += 1; j += 1; }) {
|
||||
res[i] = self.nums[j % self.capacity()];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация очереди
|
||||
var capacity: usize = 10;
|
||||
var queue = ArrayQueue(i32){};
|
||||
try queue.init(std.heap.page_allocator, capacity);
|
||||
defer queue.deinit();
|
||||
|
||||
// Добавление элемента в очередь
|
||||
try queue.push(1);
|
||||
try queue.push(3);
|
||||
try queue.push(2);
|
||||
try queue.push(5);
|
||||
try queue.push(4);
|
||||
std.debug.print("Очередь queue = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try queue.toArray());
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
var peek = queue.peek();
|
||||
std.debug.print("\nЭлемент в начале очереди peek = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
var pop = queue.pop();
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, очередь после извлечения queue = ", .{pop});
|
||||
inc.PrintUtil.printArray(i32, try queue.toArray());
|
||||
|
||||
// Получение длины очереди
|
||||
var size = queue.size();
|
||||
std.debug.print("\nДлина очереди size = {}", .{size});
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
var is_empty = queue.isEmpty();
|
||||
std.debug.print("\nПуста ли очередь = {}", .{is_empty});
|
||||
|
||||
// Проверка кольцевого массива
|
||||
var i: i32 = 0;
|
||||
while (i < 10) : (i += 1) {
|
||||
try queue.push(i);
|
||||
_ = queue.pop();
|
||||
std.debug.print("\nПосле {}-го добавления и извлечения queue = ", .{i});
|
||||
inc.PrintUtil.printArray(i32, try queue.toArray());
|
||||
}
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
// File: array_stack.zig
|
||||
// Created Time: 2023-01-08
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Стек на основе массива
|
||||
pub fn ArrayStack(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
stack: ?std.ArrayList(T) = null,
|
||||
|
||||
// Конструктор (выделение памяти + инициализация стека)
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator) void {
|
||||
if (self.stack == null) {
|
||||
self.stack = std.ArrayList(T).init(allocator);
|
||||
}
|
||||
}
|
||||
|
||||
// Деструктор (освобождение памяти)
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.stack == null) return;
|
||||
self.stack.?.deinit();
|
||||
}
|
||||
|
||||
// Получение длины стека
|
||||
pub fn size(self: *Self) usize {
|
||||
return self.stack.?.items.len;
|
||||
}
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
pub fn isEmpty(self: *Self) bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
pub fn peek(self: *Self) T {
|
||||
if (self.isEmpty()) @panic("стек пуст");
|
||||
return self.stack.?.items[self.size() - 1];
|
||||
}
|
||||
|
||||
// Поместить в стек
|
||||
pub fn push(self: *Self, num: T) !void {
|
||||
try self.stack.?.append(num);
|
||||
}
|
||||
|
||||
// Извлечь из стека
|
||||
pub fn pop(self: *Self) T {
|
||||
var num = self.stack.?.pop();
|
||||
return num;
|
||||
}
|
||||
|
||||
// Вернуть ArrayList
|
||||
pub fn toList(self: *Self) std.ArrayList(T) {
|
||||
return self.stack.?;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация стека
|
||||
var stack = ArrayStack(i32){};
|
||||
stack.init(std.heap.page_allocator);
|
||||
// Отложенное освобождение памяти
|
||||
defer stack.deinit();
|
||||
|
||||
// Помещение элемента в стек
|
||||
try stack.push(1);
|
||||
try stack.push(3);
|
||||
try stack.push(2);
|
||||
try stack.push(5);
|
||||
try stack.push(4);
|
||||
std.debug.print("Стек stack = ", .{});
|
||||
inc.PrintUtil.printList(i32, stack.toList());
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
var peek = stack.peek();
|
||||
std.debug.print("\nВерхний элемент стека peek = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из стека
|
||||
var top = stack.pop();
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, стек после извлечения stack = ", .{top});
|
||||
inc.PrintUtil.printList(i32, stack.toList());
|
||||
|
||||
// Получение длины стека
|
||||
var size = stack.size();
|
||||
std.debug.print("\nДлина стека size = {}", .{size});
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
var is_empty = stack.isEmpty();
|
||||
std.debug.print("\nПуст ли стек = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// File: deque.zig
|
||||
// Created Time: 2023-01-15
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация двусторонней очереди
|
||||
const L = std.TailQueue(i32);
|
||||
var deque = L{};
|
||||
|
||||
// Добавление элемента в очередь
|
||||
var node1 = L.Node{ .data = 2 };
|
||||
var node2 = L.Node{ .data = 5 };
|
||||
var node3 = L.Node{ .data = 4 };
|
||||
var node4 = L.Node{ .data = 3 };
|
||||
var node5 = L.Node{ .data = 1 };
|
||||
deque.append(&node1); // Добавить в хвост очереди
|
||||
deque.append(&node2);
|
||||
deque.append(&node3);
|
||||
deque.prepend(&node4); // Добавить в голову очереди
|
||||
deque.prepend(&node5);
|
||||
std.debug.print("Двусторонняя очередь deque = ", .{});
|
||||
inc.PrintUtil.printQueue(i32, deque);
|
||||
|
||||
// Доступ к элементу
|
||||
var peek_first = deque.first.?.data; // Элемент в голове очереди
|
||||
std.debug.print("\nЭлемент в начале очереди peek_first = {}", .{peek_first});
|
||||
var peek_last = deque.last.?.data; // Элемент в хвосте очереди
|
||||
std.debug.print("\nЭлемент в конце очереди peek_last = {}", .{peek_last});
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
var pop_first = deque.popFirst().?.data; // Извлечь элемент из головы очереди
|
||||
std.debug.print("\nИзвлечен элемент из головы pop_first = {}, deque после извлечения из головы = ", .{pop_first});
|
||||
inc.PrintUtil.printQueue(i32, deque);
|
||||
var pop_last = deque.pop().?.data; // Извлечь элемент из хвоста очереди
|
||||
std.debug.print("\nИзвлечен элемент из хвоста pop_last = {}, deque после извлечения из хвоста = ", .{pop_last});
|
||||
inc.PrintUtil.printQueue(i32, deque);
|
||||
|
||||
// Получение длины двусторонней очереди
|
||||
var size = deque.len;
|
||||
std.debug.print("\nДлина двусторонней очереди size = {}", .{size});
|
||||
|
||||
// Проверка, пуста ли двусторонняя очередь
|
||||
var is_empty = if (deque.len == 0) true else false;
|
||||
std.debug.print("\nПуста ли двусторонняя очередь = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
// File: linkedlist_deque.zig
|
||||
// Created Time: 2023-01-15
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Узел двусвязного списка
|
||||
pub fn ListNode(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
val: T = undefined, // Значение узла
|
||||
next: ?*Self = null, // Указатель на узел-преемник
|
||||
prev: ?*Self = null, // Указатель на узел-предшественник
|
||||
|
||||
// Initialize a list node with specific value
|
||||
pub fn init(self: *Self, x: i32) void {
|
||||
self.val = x;
|
||||
self.next = null;
|
||||
self.prev = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Двусторонняя очередь на основе двусвязного списка
|
||||
pub fn LinkedListDeque(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
front: ?*ListNode(T) = null, // Головной узел front
|
||||
rear: ?*ListNode(T) = null, // Хвостовой узел rear
|
||||
que_size: usize = 0, // Длина двусторонней очереди
|
||||
mem_arena: ?std.heap.ArenaAllocator = null,
|
||||
mem_allocator: std.mem.Allocator = undefined, // Аллокатор памяти
|
||||
|
||||
// Конструктор (выделение памяти + инициализация очереди)
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
|
||||
if (self.mem_arena == null) {
|
||||
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
|
||||
self.mem_allocator = self.mem_arena.?.allocator();
|
||||
}
|
||||
self.front = null;
|
||||
self.rear = null;
|
||||
self.que_size = 0;
|
||||
}
|
||||
|
||||
// Деструктор (освобождение памяти)
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.mem_arena == null) return;
|
||||
self.mem_arena.?.deinit();
|
||||
}
|
||||
|
||||
// Получение длины двусторонней очереди
|
||||
pub fn size(self: *Self) usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
// Проверка, пуста ли двусторонняя очередь
|
||||
pub fn isEmpty(self: *Self) bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
// Операция добавления в очередь
|
||||
pub fn push(self: *Self, num: T, is_front: bool) !void {
|
||||
var node = try self.mem_allocator.create(ListNode(T));
|
||||
node.init(num);
|
||||
// Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
|
||||
if (self.isEmpty()) {
|
||||
self.front = node;
|
||||
self.rear = node;
|
||||
// Операция добавления в голову очереди
|
||||
} else if (is_front) {
|
||||
// Добавить node в голову списка
|
||||
self.front.?.prev = node;
|
||||
node.next = self.front;
|
||||
self.front = node; // Обновить головной узел
|
||||
// Операция добавления в хвост очереди
|
||||
} else {
|
||||
// Добавить node в хвост списка
|
||||
self.rear.?.next = node;
|
||||
node.prev = self.rear;
|
||||
self.rear = node; // Обновить хвостовой узел
|
||||
}
|
||||
self.que_size += 1; // Обновить длину очереди
|
||||
}
|
||||
|
||||
// Добавление в голову очереди
|
||||
pub fn pushFirst(self: *Self, num: T) !void {
|
||||
try self.push(num, true);
|
||||
}
|
||||
|
||||
// Добавление в хвост очереди
|
||||
pub fn pushLast(self: *Self, num: T) !void {
|
||||
try self.push(num, false);
|
||||
}
|
||||
|
||||
// Операция извлечения из очереди
|
||||
pub fn pop(self: *Self, is_front: bool) T {
|
||||
if (self.isEmpty()) @panic("двусторонняя очередь пуста");
|
||||
var val: T = undefined;
|
||||
// Операция извлечения из головы очереди
|
||||
if (is_front) {
|
||||
val = self.front.?.val; // Временно сохранить значение головного узла
|
||||
// Удалить головной узел
|
||||
var fNext = self.front.?.next;
|
||||
if (fNext != null) {
|
||||
fNext.?.prev = null;
|
||||
self.front.?.next = null;
|
||||
}
|
||||
self.front = fNext; // Обновить головной узел
|
||||
// Операция извлечения из хвоста очереди
|
||||
} else {
|
||||
val = self.rear.?.val; // Временно сохранить значение хвостового узла
|
||||
// Удалить хвостовой узел
|
||||
var rPrev = self.rear.?.prev;
|
||||
if (rPrev != null) {
|
||||
rPrev.?.next = null;
|
||||
self.rear.?.prev = null;
|
||||
}
|
||||
self.rear = rPrev; // Обновить хвостовой узел
|
||||
}
|
||||
self.que_size -= 1; // Обновить длину очереди
|
||||
return val;
|
||||
}
|
||||
|
||||
// Извлечение из головы очереди
|
||||
pub fn popFirst(self: *Self) T {
|
||||
return self.pop(true);
|
||||
}
|
||||
|
||||
// Извлечение из хвоста очереди
|
||||
pub fn popLast(self: *Self) T {
|
||||
return self.pop(false);
|
||||
}
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
pub fn peekFirst(self: *Self) T {
|
||||
if (self.isEmpty()) @panic("двусторонняя очередь пуста");
|
||||
return self.front.?.val;
|
||||
}
|
||||
|
||||
// Доступ к элементу в конце очереди
|
||||
pub fn peekLast(self: *Self) T {
|
||||
if (self.isEmpty()) @panic("двусторонняя очередь пуста");
|
||||
return self.rear.?.val;
|
||||
}
|
||||
|
||||
// Вернуть массив для вывода
|
||||
pub fn toArray(self: *Self) ![]T {
|
||||
var node = self.front;
|
||||
var res = try self.mem_allocator.alloc(T, self.size());
|
||||
@memset(res, @as(T, 0));
|
||||
var i: usize = 0;
|
||||
while (i < res.len) : (i += 1) {
|
||||
res[i] = node.?.val;
|
||||
node = node.?.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация двусторонней очереди
|
||||
var deque = LinkedListDeque(i32){};
|
||||
try deque.init(std.heap.page_allocator);
|
||||
defer deque.deinit();
|
||||
try deque.pushLast(3);
|
||||
try deque.pushLast(2);
|
||||
try deque.pushLast(5);
|
||||
std.debug.print("Двусторонняя очередь deque = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try deque.toArray());
|
||||
|
||||
// Доступ к элементу
|
||||
var peek_first = deque.peekFirst();
|
||||
std.debug.print("\nЭлемент в начале очереди peek_first = {}", .{peek_first});
|
||||
var peek_last = deque.peekLast();
|
||||
std.debug.print("\nЭлемент в конце очереди peek_last = {}", .{peek_last});
|
||||
|
||||
// Добавление элемента в очередь
|
||||
try deque.pushLast(4);
|
||||
std.debug.print("\nПосле добавления элемента 4 в хвост deque = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try deque.toArray());
|
||||
try deque.pushFirst(1);
|
||||
std.debug.print("\nПосле добавления элемента 1 в голову deque = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try deque.toArray());
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
var pop_last = deque.popLast();
|
||||
std.debug.print("\nИзвлечен элемент из хвоста = {}, deque после извлечения из хвоста = ", .{pop_last});
|
||||
inc.PrintUtil.printArray(i32, try deque.toArray());
|
||||
var pop_first = deque.popFirst();
|
||||
std.debug.print("\nИзвлечен элемент из головы = {}, deque после извлечения из головы = ", .{pop_first});
|
||||
inc.PrintUtil.printArray(i32, try deque.toArray());
|
||||
|
||||
// Получение длины двусторонней очереди
|
||||
var size = deque.size();
|
||||
std.debug.print("\nДлина двусторонней очереди size = {}", .{size});
|
||||
|
||||
// Проверка, пуста ли двусторонняя очередь
|
||||
var is_empty = deque.isEmpty();
|
||||
std.debug.print("\nПуста ли двусторонняя очередь = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
// File: linkedlist_queue.zig
|
||||
// Created Time: 2023-01-15
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Очередь на основе связного списка
|
||||
pub fn LinkedListQueue(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
front: ?*inc.ListNode(T) = null, // Головной узел front
|
||||
rear: ?*inc.ListNode(T) = null, // Хвостовой узел rear
|
||||
que_size: usize = 0, // Длина очереди
|
||||
mem_arena: ?std.heap.ArenaAllocator = null,
|
||||
mem_allocator: std.mem.Allocator = undefined, // Аллокатор памяти
|
||||
|
||||
// Конструктор (выделение памяти + инициализация очереди)
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
|
||||
if (self.mem_arena == null) {
|
||||
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
|
||||
self.mem_allocator = self.mem_arena.?.allocator();
|
||||
}
|
||||
self.front = null;
|
||||
self.rear = null;
|
||||
self.que_size = 0;
|
||||
}
|
||||
|
||||
// Деструктор (освобождение памяти)
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.mem_arena == null) return;
|
||||
self.mem_arena.?.deinit();
|
||||
}
|
||||
|
||||
// Получение длины очереди
|
||||
pub fn size(self: *Self) usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
pub fn isEmpty(self: *Self) bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
pub fn peek(self: *Self) T {
|
||||
if (self.size() == 0) @panic("очередь пуста");
|
||||
return self.front.?.val;
|
||||
}
|
||||
|
||||
// Поместить в очередь
|
||||
pub fn push(self: *Self, num: T) !void {
|
||||
// Добавить num после хвостового узла
|
||||
var node = try self.mem_allocator.create(inc.ListNode(T));
|
||||
node.init(num);
|
||||
// Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
|
||||
if (self.front == null) {
|
||||
self.front = node;
|
||||
self.rear = node;
|
||||
// Если очередь не пуста, добавить этот узел после хвостового узла
|
||||
} else {
|
||||
self.rear.?.next = node;
|
||||
self.rear = node;
|
||||
}
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
// Извлечь из очереди
|
||||
pub fn pop(self: *Self) T {
|
||||
var num = self.peek();
|
||||
// Удалить головной узел
|
||||
self.front = self.front.?.next;
|
||||
self.que_size -= 1;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Преобразовать связный список в массив
|
||||
pub fn toArray(self: *Self) ![]T {
|
||||
var node = self.front;
|
||||
var res = try self.mem_allocator.alloc(T, self.size());
|
||||
@memset(res, @as(T, 0));
|
||||
var i: usize = 0;
|
||||
while (i < res.len) : (i += 1) {
|
||||
res[i] = node.?.val;
|
||||
node = node.?.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация очереди
|
||||
var queue = LinkedListQueue(i32){};
|
||||
try queue.init(std.heap.page_allocator);
|
||||
defer queue.deinit();
|
||||
|
||||
// Добавление элемента в очередь
|
||||
try queue.push(1);
|
||||
try queue.push(3);
|
||||
try queue.push(2);
|
||||
try queue.push(5);
|
||||
try queue.push(4);
|
||||
std.debug.print("Очередь queue = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try queue.toArray());
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
var peek = queue.peek();
|
||||
std.debug.print("\nЭлемент в начале очереди peek = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
var pop = queue.pop();
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, очередь после извлечения queue = ", .{pop});
|
||||
inc.PrintUtil.printArray(i32, try queue.toArray());
|
||||
|
||||
// Получение длины очереди
|
||||
var size = queue.size();
|
||||
std.debug.print("\nДлина очереди size = {}", .{size});
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
var is_empty = queue.isEmpty();
|
||||
std.debug.print("\nПуста ли очередь = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
// File: linkedlist_stack.zig
|
||||
// Created Time: 2023-01-08
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Стек на основе связного списка
|
||||
pub fn LinkedListStack(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
stack_top: ?*inc.ListNode(T) = null, // Использовать головной узел как вершину стека
|
||||
stk_size: usize = 0, // Длина стека
|
||||
mem_arena: ?std.heap.ArenaAllocator = null,
|
||||
mem_allocator: std.mem.Allocator = undefined, // Аллокатор памяти
|
||||
|
||||
// Конструктор (выделение памяти + инициализация стека)
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
|
||||
if (self.mem_arena == null) {
|
||||
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
|
||||
self.mem_allocator = self.mem_arena.?.allocator();
|
||||
}
|
||||
self.stack_top = null;
|
||||
self.stk_size = 0;
|
||||
}
|
||||
|
||||
// Деструктор (освобождение памяти)
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.mem_arena == null) return;
|
||||
self.mem_arena.?.deinit();
|
||||
}
|
||||
|
||||
// Получение длины стека
|
||||
pub fn size(self: *Self) usize {
|
||||
return self.stk_size;
|
||||
}
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
pub fn isEmpty(self: *Self) bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
pub fn peek(self: *Self) T {
|
||||
if (self.size() == 0) @panic("стек пуст");
|
||||
return self.stack_top.?.val;
|
||||
}
|
||||
|
||||
// Поместить в стек
|
||||
pub fn push(self: *Self, num: T) !void {
|
||||
var node = try self.mem_allocator.create(inc.ListNode(T));
|
||||
node.init(num);
|
||||
node.next = self.stack_top;
|
||||
self.stack_top = node;
|
||||
self.stk_size += 1;
|
||||
}
|
||||
|
||||
// Извлечь из стека
|
||||
pub fn pop(self: *Self) T {
|
||||
var num = self.peek();
|
||||
self.stack_top = self.stack_top.?.next;
|
||||
self.stk_size -= 1;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Преобразовать стек в массив
|
||||
pub fn toArray(self: *Self) ![]T {
|
||||
var node = self.stack_top;
|
||||
var res = try self.mem_allocator.alloc(T, self.size());
|
||||
@memset(res, @as(T, 0));
|
||||
var i: usize = 0;
|
||||
while (i < res.len) : (i += 1) {
|
||||
res[res.len - i - 1] = node.?.val;
|
||||
node = node.?.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация стека
|
||||
var stack = LinkedListStack(i32){};
|
||||
try stack.init(std.heap.page_allocator);
|
||||
// Отложенное освобождение памяти
|
||||
defer stack.deinit();
|
||||
|
||||
// Помещение элемента в стек
|
||||
try stack.push(1);
|
||||
try stack.push(3);
|
||||
try stack.push(2);
|
||||
try stack.push(5);
|
||||
try stack.push(4);
|
||||
std.debug.print("Стек stack = ", .{});
|
||||
inc.PrintUtil.printArray(i32, try stack.toArray());
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
var peek = stack.peek();
|
||||
std.debug.print("\nВерхний элемент стека top = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из стека
|
||||
var pop = stack.pop();
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, стек после извлечения stack = ", .{pop});
|
||||
inc.PrintUtil.printArray(i32, try stack.toArray());
|
||||
|
||||
// Получение длины стека
|
||||
var size = stack.size();
|
||||
std.debug.print("\nДлина стека size = {}", .{size});
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
var is_empty = stack.isEmpty();
|
||||
std.debug.print("\nПуст ли стек = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
// File: queue.zig
|
||||
// Created Time: 2023-01-15
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализация очереди
|
||||
const L = std.TailQueue(i32);
|
||||
var queue = L{};
|
||||
|
||||
// Добавление элемента в очередь
|
||||
var node1 = L.Node{ .data = 1 };
|
||||
var node2 = L.Node{ .data = 3 };
|
||||
var node3 = L.Node{ .data = 2 };
|
||||
var node4 = L.Node{ .data = 5 };
|
||||
var node5 = L.Node{ .data = 4 };
|
||||
queue.append(&node1);
|
||||
queue.append(&node2);
|
||||
queue.append(&node3);
|
||||
queue.append(&node4);
|
||||
queue.append(&node5);
|
||||
std.debug.print("Очередь queue = ", .{});
|
||||
inc.PrintUtil.printQueue(i32, queue);
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
var peek = queue.first.?.data;
|
||||
std.debug.print("\nЭлемент в начале очереди peek = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
var pop = queue.popFirst().?.data;
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, очередь после извлечения queue = ", .{pop});
|
||||
inc.PrintUtil.printQueue(i32, queue);
|
||||
|
||||
// Получение длины очереди
|
||||
var size = queue.len;
|
||||
std.debug.print("\nДлина очереди size = {}", .{size});
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
var is_empty = if (queue.len == 0) true else false;
|
||||
std.debug.print("\nПуста ли очередь = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
// File: stack.zig
|
||||
// Created Time: 2023-01-08
|
||||
// Author: codingonion (coderonion@gmail.com)
|
||||
|
||||
const std = @import("std");
|
||||
const inc = @import("include");
|
||||
|
||||
// Driver Code
|
||||
pub fn main() !void {
|
||||
// Инициализировать стек
|
||||
// В Zig рекомендуется использовать ArrayList как стек
|
||||
var stack = std.ArrayList(i32).init(std.heap.page_allocator);
|
||||
// Отложенное освобождение памяти
|
||||
defer stack.deinit();
|
||||
|
||||
// Помещение элемента в стек
|
||||
try stack.append(1);
|
||||
try stack.append(3);
|
||||
try stack.append(2);
|
||||
try stack.append(5);
|
||||
try stack.append(4);
|
||||
std.debug.print("Стек stack = ", .{});
|
||||
inc.PrintUtil.printList(i32, stack);
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
var peek = stack.items[stack.items.len - 1];
|
||||
std.debug.print("\nВерхний элемент стека peek = {}", .{peek});
|
||||
|
||||
// Извлечение элемента из стека
|
||||
var pop = stack.pop();
|
||||
std.debug.print("\nИзвлечен элемент pop = {}, стек после извлечения stack = ", .{pop});
|
||||
inc.PrintUtil.printList(i32, stack);
|
||||
|
||||
// Получение длины стека
|
||||
var size = stack.items.len;
|
||||
std.debug.print("\nДлина стека size = {}", .{size});
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
var is_empty = if (stack.items.len == 0) true else false;
|
||||
std.debug.print("\nПуст ли стек = {}", .{is_empty});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
Reference in New Issue
Block a user