CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-09 05:41:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

🚀feat: add rust codes for linkedlist_stack, linkedlist_queue and linkedlist_deque (#410)

Browse Source 
* feat: add rust codes for space_complexity

* feat: add rust codes for linkedlist_stack

* update

* feat: add rust codes for linkedlist_queue

* feat: add rust codes for linkedlist_deque

* update
This commit is contained in:
sjinzh
2023-03-13 20:15:11 +08:00
committed by GitHub
parent 9151eaf533
commit 6924d15f63
10 changed files with 515 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
codes/zig/chapter_stack_and_queue/linkedlist_deque.zig
View File

@@ -30,7 +30,7 @@ pub fn LinkedListDeque(comptime T: type) type {
front: ?*ListNode(T) = null, // 头结点 front
rear: ?*ListNode(T) = null, // 尾结点 rear
deqSize: usize = 0, // 双向队列的长度
que_size: usize = 0, // 双向队列的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -42,7 +42,7 @@ pub fn LinkedListDeque(comptime T: type) type {
}
self.front = null;
self.rear = null;
self.deqSize = 0;
self.que_size = 0;
}
// 析构方法（释放内存）
@@ -53,7 +53,7 @@ pub fn LinkedListDeque(comptime T: type) type {
// 获取双向队列的长度
pub fn size(self: *Self) usize {
return self.deqSize;
return self.que_size;
}
// 判断双向队列是否为空
@@ -62,7 +62,7 @@ pub fn LinkedListDeque(comptime T: type) type {
}
// 入队操作
pub fn push(self: *Self, num: T, isFront: bool) !void {
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
@@ -70,7 +70,7 @@ pub fn LinkedListDeque(comptime T: type) type {
self.front = node;
self.rear = node;
// 队首入队操作
} else if (isFront) {
} else if (is_front) {
// 将 node 添加至链表头部
self.front.?.prev = node;
node.next = self.front;
@@ -82,7 +82,7 @@ pub fn LinkedListDeque(comptime T: type) type {
node.prev = self.rear;
self.rear = node; // 更新尾结点
}
self.deqSize += 1; // 更新队列长度
self.que_size += 1; // 更新队列长度
}
// 队首入队
@@ -96,11 +96,11 @@ pub fn LinkedListDeque(comptime T: type) type {
}
// 出队操作
pub fn poll(self: *Self, isFront: bool) T {
pub fn poll(self: *Self, is_front: bool) T {
if (self.isEmpty()) @panic("双向队列为空");
var val: T = undefined;
// 队首出队操作
if (isFront) {
if (is_front) {
val = self.front.?.val; // 暂存头结点值
// 删除头结点
var fNext = self.front.?.next;
@@ -120,7 +120,7 @@ pub fn LinkedListDeque(comptime T: type) type {
}
self.rear = rPrev; // 更新尾结点
}
self.deqSize -= 1; // 更新队列长度
self.que_size -= 1; // 更新队列长度
return val;
}
@@ -146,7 +146,7 @@ pub fn LinkedListDeque(comptime T: type) type {
return self.rear.?.val;
}
// 将链表转换为数组
// 返回数组用于打印
pub fn toArray(self: *Self) ![]T {
var node = self.front;
var res = try self.mem_allocator.alloc(T, self.size());
@@ -158,19 +158,6 @@ pub fn LinkedListDeque(comptime T: type) type {
}
return res;
}
// 打印双向队列
pub fn print(self: *Self) !void {
var nums = try self.toArray();
std.debug.print("[", .{});
if (nums.len > 0) {
for (nums) |num, j| {
std.debug.print("{}{s}", .{num, if (j == nums.len - 1) "]" else " <-> " });
}
} else {
std.debug.print("]", .{});
}
}
};
}
@@ -180,46 +167,37 @@ pub fn main() !void {
var deque = LinkedListDeque(i32){};
try deque.init(std.heap.page_allocator);
defer deque.deinit();
std.debug.print("初始化空队列\n", .{});
try deque.print();
try deque.pushLast(3);
try deque.pushLast(2);
try deque.pushLast(5);
std.debug.print("双向队列 deque = ", .{});
inc.PrintUtil.printArray(i32, try deque.toArray());
var nums = [_]i32{ 1, 2, 3}; // 测试数据
// 访问元素
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});
// 队尾入队
for (nums) |num| {
try deque.pushLast(num);
std.debug.print("\n元素 {} 队尾入队后，队列为\n", .{num});
try deque.print();
}
// 获取队尾元素
var last = deque.peekLast();
std.debug.print("\n队尾元素为 {}", .{last});
// 队尾出队
while (!deque.isEmpty()) {
last = deque.pollLast();
std.debug.print("\n队尾出队元素为 {} ，队列为\n", .{last});
try deque.print();
}
// 元素入队
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());
// 队首入队
for (nums) |num| {
try deque.pushFirst(num);
std.debug.print("\n元素 {} 队首入队后，队列为\n", .{num});
try deque.print();
}
// 获取队首元素
var first = deque.peekFirst();
std.debug.print("\n队首元素为 {}", .{first});
// 队首出队
while (!deque.isEmpty()) {
first = deque.pollFirst();
std.debug.print("\n队首出队元素为 {} ，队列为\n", .{first});
try deque.print();
}
// 元素出队
var poll_last = deque.pollLast();
std.debug.print("\n队尾出队元素 = {}，队尾出队后 deque = ", .{poll_last});
inc.PrintUtil.printArray(i32, try deque.toArray());
var poll_first = deque.pollFirst();
std.debug.print("\n队首出队元素 = {}，队首出队后 deque = ", .{poll_first});
inc.PrintUtil.printArray(i32, try deque.toArray());
// 获取队列的长度
// 获取双向队列的长度
var size = deque.size();
std.debug.print("\n队列长度 size = {}", .{size});
std.debug.print("\n双向队列长度 size = {}", .{size});
// 判断双向队列是否为空
var is_empty = deque.isEmpty();

10
codes/zig/chapter_stack_and_queue/linkedlist_queue.zig
View File

@@ -12,7 +12,7 @@ pub fn LinkedListQueue(comptime T: type) type {
front: ?*inc.ListNode(T) = null, // 头结点 front
rear: ?*inc.ListNode(T) = null, // 尾结点 rear
queSize: usize = 0, // 队列的长度
que_size: usize = 0, // 队列的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -24,7 +24,7 @@ pub fn LinkedListQueue(comptime T: type) type {
}
self.front = null;
self.rear = null;
self.queSize = 0;
self.que_size = 0;
}
// 析构方法（释放内存）
@@ -35,7 +35,7 @@ pub fn LinkedListQueue(comptime T: type) type {
// 获取队列的长度
pub fn size(self: *Self) usize {
return self.queSize;
return self.que_size;
}
// 判断队列是否为空
@@ -63,7 +63,7 @@ pub fn LinkedListQueue(comptime T: type) type {
self.rear.?.next = node;
self.rear = node;
}
self.queSize += 1;
self.que_size += 1;
}
// 出队
@@ -71,7 +71,7 @@ pub fn LinkedListQueue(comptime T: type) type {
var num = self.peek();
// 删除头结点
self.front = self.front.?.next;
self.queSize -= 1;
self.que_size -= 1;
return num;
}

36
codes/zig/chapter_stack_and_queue/linkedlist_stack.zig
View File

@@ -10,8 +10,8 @@ pub fn LinkedListStack(comptime T: type) type {
return struct {
const Self = @This();
stackTop: ?*inc.ListNode(T) = null, // 将头结点作为栈顶
stkSize: usize = 0, // 栈的长度
stack_top: ?*inc.ListNode(T) = null, // 将头结点作为栈顶
stk_size: usize = 0, // 栈的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -21,8 +21,8 @@ pub fn LinkedListStack(comptime T: type) type {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.stackTop = null;
self.stkSize = 0;
self.stack_top = null;
self.stk_size = 0;
}
// 析构方法（释放内存）
@@ -33,7 +33,7 @@ pub fn LinkedListStack(comptime T: type) type {
// 获取栈的长度
pub fn size(self: *Self) usize {
return self.stkSize;
return self.stk_size;
}
// 判断栈是否为空
@@ -42,31 +42,31 @@ pub fn LinkedListStack(comptime T: type) type {
}
// 访问栈顶元素
pub fn top(self: *Self) T {
pub fn peek(self: *Self) T {
if (self.size() == 0) @panic("栈为空");
return self.stackTop.?.val;
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.stackTop;
self.stackTop = node;
self.stkSize += 1;
node.next = self.stack_top;
self.stack_top = node;
self.stk_size += 1;
}
// 出栈
pub fn pop(self: *Self) T {
var num = self.top();
self.stackTop = self.stackTop.?.next;
self.stkSize -= 1;
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.stackTop;
var node = self.stack_top;
var res = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, res, @as(T, 0));
var i: usize = 0;
@@ -97,12 +97,12 @@ pub fn main() !void {
inc.PrintUtil.printArray(i32, try stack.toArray());
// 访问栈顶元素
var top = stack.top();
std.debug.print("\n栈顶元素 top = {}", .{top});
var peek = stack.peek();
std.debug.print("\n栈顶元素 top = {}", .{peek});
// 元素出栈
top = stack.pop();
std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{top});
var pop = stack.pop();
std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{pop});
inc.PrintUtil.printArray(i32, try stack.toArray());
// 获取栈的长度