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

🚀feat: add rust codes for array_deque (#418)

Browse Source 
* update zig codes style

* feat: add rust codes for array_deque

* Update array_deque.rs

---------

Co-authored-by: Yudong Jin <krahets@163.com>
This commit is contained in:
sjinzh
2023-03-14 20:45:27 +08:00
committed by GitHub
parent 567497a6b8
commit c2be6ebfbe
7 changed files with 235 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
codes/zig/chapter_heap/heap.zig
View File

@@ -36,45 +36,45 @@ pub fn main() !void {
// 初始化堆
// 初始化小顶堆
const PQlt = std.PriorityQueue(i32, void, lessThan);
var minHeap = PQlt.init(std.heap.page_allocator, {});
defer minHeap.deinit();
var min_heap = PQlt.init(std.heap.page_allocator, {});
defer min_heap.deinit();
// 初始化大顶堆
const PQgt = std.PriorityQueue(i32, void, greaterThan);
var maxHeap = PQgt.init(std.heap.page_allocator, {});
defer maxHeap.deinit();
var max_heap = PQgt.init(std.heap.page_allocator, {});
defer max_heap.deinit();
std.debug.print("\n以下测试样例为大顶堆", .{});
// 元素入堆
try testPush(i32, mem_allocator, &maxHeap, 1);
try testPush(i32, mem_allocator, &maxHeap, 3);
try testPush(i32, mem_allocator, &maxHeap, 2);
try testPush(i32, mem_allocator, &maxHeap, 5);
try testPush(i32, mem_allocator, &maxHeap, 4);
try testPush(i32, mem_allocator, &max_heap, 1);
try testPush(i32, mem_allocator, &max_heap, 3);
try testPush(i32, mem_allocator, &max_heap, 2);
try testPush(i32, mem_allocator, &max_heap, 5);
try testPush(i32, mem_allocator, &max_heap, 4);
// 获取堆顶元素
var peek = maxHeap.peek().?;
var peek = max_heap.peek().?;
std.debug.print("\n堆顶元素为 {}\n", .{peek});
// 堆顶元素出堆
try testPop(i32, mem_allocator, &maxHeap);
try testPop(i32, mem_allocator, &maxHeap);
try testPop(i32, mem_allocator, &maxHeap);
try testPop(i32, mem_allocator, &maxHeap);
try testPop(i32, mem_allocator, &maxHeap);
try testPop(i32, mem_allocator, &max_heap);
try testPop(i32, mem_allocator, &max_heap);
try testPop(i32, mem_allocator, &max_heap);
try testPop(i32, mem_allocator, &max_heap);
try testPop(i32, mem_allocator, &max_heap);
// 获取堆的大小
var size = maxHeap.len;
var size = max_heap.len;
std.debug.print("\n堆元素数量为 {}\n", .{size});
// 判断堆是否为空
var is_empty = if (maxHeap.len == 0) true else false;
var is_empty = if (max_heap.len == 0) true else false;
std.debug.print("\n堆是否为空 {}\n", .{is_empty});
// 输入列表并建堆
try minHeap.addSlice(&[_]i32{ 1, 3, 2, 5, 4 });
try min_heap.addSlice(&[_]i32{ 1, 3, 2, 5, 4 });
std.debug.print("\n输入列表并建立小顶堆后\n", .{});
try inc.PrintUtil.printHeap(i32, mem_allocator, minHeap);
try inc.PrintUtil.printHeap(i32, mem_allocator, min_heap);
_ = try std.io.getStdIn().reader().readByte();
}

56
codes/zig/chapter_heap/my_heap.zig
View File

@@ -10,14 +10,14 @@ pub fn MaxHeap(comptime T: type) type {
return struct {
const Self = @This();
maxHeap: ?std.ArrayList(T) = null, // 使用列表而非数组，这样无需考虑扩容问题
max_heap: ?std.ArrayList(T) = null, // 使用列表而非数组，这样无需考虑扩容问题
// 构造方法，根据输入列表建堆
pub fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
if (self.maxHeap != null) return;
self.maxHeap = std.ArrayList(T).init(allocator);
if (self.max_heap != null) return;
self.max_heap = std.ArrayList(T).init(allocator);
// 将列表元素原封不动添加进堆
try self.maxHeap.?.appendSlice(nums);
try self.max_heap.?.appendSlice(nums);
// 堆化除叶结点以外的其他所有结点
var i: usize = parent(self.size() - 1) + 1;
while (i > 0) : (i -= 1) {
@@ -27,7 +27,7 @@ pub fn MaxHeap(comptime T: type) type {
// 析构方法，释放内存
pub fn deinit(self: *Self) void {
if (self.maxHeap != null) self.maxHeap.?.deinit();
if (self.max_heap != null) self.max_heap.?.deinit();
}
// 获取左子结点索引
@@ -48,16 +48,16 @@ pub fn MaxHeap(comptime T: type) type {
// 交换元素
fn swap(self: *Self, i: usize, j: usize) !void {
var a = self.maxHeap.?.items[i];
var b = self.maxHeap.?.items[j];
var a = self.max_heap.?.items[i];
var b = self.max_heap.?.items[j];
var tmp = a;
try self.maxHeap.?.replaceRange(i, 1, &[_]T{b});
try self.maxHeap.?.replaceRange(j, 1, &[_]T{tmp});
try self.max_heap.?.replaceRange(i, 1, &[_]T{b});
try self.max_heap.?.replaceRange(j, 1, &[_]T{tmp});
}
// 获取堆大小
pub fn size(self: *Self) usize {
return self.maxHeap.?.items.len;
return self.max_heap.?.items.len;
}
// 判断堆是否为空
@@ -67,13 +67,13 @@ pub fn MaxHeap(comptime T: type) type {
// 访问堆顶元素
pub fn peek(self: *Self) T {
return self.maxHeap.?.items[0];
return self.max_heap.?.items[0];
}
// 元素入堆
pub fn push(self: *Self, val: T) !void {
// 添加结点
try self.maxHeap.?.append(val);
try self.max_heap.?.append(val);
// 从底至顶堆化
try self.siftUp(self.size() - 1);
}
@@ -85,7 +85,7 @@ pub fn MaxHeap(comptime T: type) type {
// 获取结点 i 的父结点
var p = parent(i);
// 当“越过根结点”或“结点无需修复”时，结束堆化
if (p < 0 or self.maxHeap.?.items[i] <= self.maxHeap.?.items[p]) break;
if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
// 交换两结点
try self.swap(i, p);
// 循环向上堆化
@@ -100,7 +100,7 @@ pub fn MaxHeap(comptime T: type) type {
// 交换根结点与最右叶结点（即交换首元素与尾元素）
try self.swap(0, self.size() - 1);
// 删除结点
var val = self.maxHeap.?.pop();
var val = self.max_heap.?.pop();
// 从顶至底堆化
try self.siftDown(0);
// 返回堆顶元素
@@ -115,8 +115,8 @@ pub fn MaxHeap(comptime T: type) type {
var l = left(i);
var r = right(i);
var ma = i;
if (l < self.size() and self.maxHeap.?.items[l] > self.maxHeap.?.items[ma]) ma = l;
if (r < self.size() and self.maxHeap.?.items[r] > self.maxHeap.?.items[ma]) ma = r;
if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (ma == i) break;
// 交换两结点
@@ -140,7 +140,7 @@ pub fn MaxHeap(comptime T: type) type {
const PQgt = std.PriorityQueue(T, void, greaterThan);
var queue = PQgt.init(std.heap.page_allocator, {});
defer queue.deinit();
try queue.addSlice(self.maxHeap.?.items);
try queue.addSlice(self.max_heap.?.items);
try inc.PrintUtil.printHeap(T, mem_allocator, queue);
}
};
@@ -154,33 +154,33 @@ pub fn main() !void {
const mem_allocator = mem_arena.allocator();
// 初始化大顶堆
var maxHeap = MaxHeap(i32){};
try maxHeap.init(std.heap.page_allocator, &[_]i32{ 9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2 });
defer maxHeap.deinit();
var max_heap = MaxHeap(i32){};
try max_heap.init(std.heap.page_allocator, &[_]i32{ 9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2 });
defer max_heap.deinit();
std.debug.print("\n输入列表并建堆后\n", .{});
try maxHeap.print(mem_allocator);
try max_heap.print(mem_allocator);
// 获取堆顶元素
var peek = maxHeap.peek();
var peek = max_heap.peek();
std.debug.print("\n堆顶元素为 {}\n", .{peek});
// 元素入堆
const val = 7;
try maxHeap.push(val);
try max_heap.push(val);
std.debug.print("\n元素 {} 入堆后\n", .{val});
try maxHeap.print(mem_allocator);
try max_heap.print(mem_allocator);
// 堆顶元素出堆
peek = try maxHeap.pop();
peek = try max_heap.pop();
std.debug.print("\n堆顶元素 {} 出堆后\n", .{peek});
try maxHeap.print(mem_allocator);
try max_heap.print(mem_allocator);
// 获取堆的大小
var size = maxHeap.size();
var size = max_heap.size();
std.debug.print("\n堆元素数量为 {}", .{size});
// 判断堆是否为空
var is_empty = maxHeap.isEmpty();
var is_empty = max_heap.isEmpty();
std.debug.print("\n堆是否为空 {}\n", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();