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

Update variable names in list and my_list

Browse Source
This commit is contained in:
krahets
2023-10-09 18:20:42 +08:00
parent e5f8c93f5d
commit fb552987f5
25 changed files with 966 additions and 966 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
codes/zig/chapter_array_and_linkedlist/list.zig
View File

@@ -8,71 +8,71 @@ const inc = @import("include");
// Driver Code
pub fn main() !void {
// 初始化列表
var list = std.ArrayList(i32).init(std.heap.page_allocator);
var nums = std.ArrayList(i32).init(std.heap.page_allocator);
// 延迟释放内存
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
std.debug.print("列表 list = ", .{});
inc.PrintUtil.printList(i32, list);
defer nums.deinit();
try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
std.debug.print("列表 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 访问元素
var num = list.items[1];
var num = nums.items[1];
std.debug.print("\n访问索引 1 处的元素，得到 num = {}", .{num});
// 更新元素
list.items[1] = 0;
std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
nums.items[1] = 0;
std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 清空列表
list.clearRetainingCapacity();
std.debug.print("\n清空列表后 list = ", .{});
inc.PrintUtil.printList(i32, list);
nums.clearRetainingCapacity();
std.debug.print("\n清空列表后 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 尾部添加元素
try list.append(1);
try list.append(3);
try list.append(2);
try list.append(5);
try list.append(4);
std.debug.print("\n添加元素后 list = ", .{});
inc.PrintUtil.printList(i32, list);
try nums.append(1);
try nums.append(3);
try nums.append(2);
try nums.append(5);
try nums.append(4);
std.debug.print("\n添加元素后 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 中间插入元素
try list.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
try nums.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 删除元素
_ = list.orderedRemove(3);
std.debug.print("\n删除索引 3 处的元素，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
_ = nums.orderedRemove(3);
std.debug.print("\n删除索引 3 处的元素，得到 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 通过索引遍历列表
var count: i32 = 0;
var i: i32 = 0;
while (i < list.items.len) : (i += 1) {
while (i < nums.items.len) : (i += 1) {
count += 1;
}
// 直接遍历列表元素
count = 0;
for (list.items) |_| {
for (nums.items) |_| {
count += 1;
}
// 拼接两个列表
var list1 = std.ArrayList(i32).init(std.heap.page_allocator);
defer list1.deinit();
try list1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
try list.insertSlice(list.items.len, list1.items);
std.debug.print("\n将列表 list1 拼接到 list 之后，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
var nums1 = std.ArrayList(i32).init(std.heap.page_allocator);
defer nums1.deinit();
try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
try nums.insertSlice(nums.items.len, nums1.items);
std.debug.print("\n将列表 nums1 拼接到 nums 之后，得到 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
// 排序列表
std.mem.sort(i32, list.items, {}, comptime std.sort.asc(i32));
std.debug.print("\n排序列表后 list = ", .{});
inc.PrintUtil.printList(i32, list);
std.mem.sort(i32, nums.items, {}, comptime std.sort.asc(i32));
std.debug.print("\n排序列表后 nums = ", .{});
inc.PrintUtil.printList(i32, nums);
_ = try std.io.getStdIn().reader().readByte();
}

89
codes/zig/chapter_array_and_linkedlist/my_list.zig
View File

@@ -10,8 +10,8 @@ pub fn MyList(comptime T: type) type {
return struct {
const Self = @This();
nums: []T = undefined, // 数组（存储列表元素）
numsCapacity: usize = 10, // 列表容量
arr: []T = undefined, // 数组（存储列表元素）
arrCapacity: usize = 10, // 列表容量
numSize: usize = 0, // 列表长度（即当前元素数量）
extendRatio: usize = 2, // 每次列表扩容的倍数
mem_arena: ?std.heap.ArenaAllocator = null,
@@ -23,8 +23,8 @@ pub fn MyList(comptime T: type) type {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.nums = try self.mem_allocator.alloc(T, self.numsCapacity);
@memset(self.nums, @as(T, 0));
self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
@memset(self.arr, @as(T, 0));
}
// 析构函数（释放内存）
@@ -40,28 +40,28 @@ pub fn MyList(comptime T: type) type {
// 获取列表容量
pub fn capacity(self: *Self) usize {
return self.numsCapacity;
return self.arrCapacity;
}
// 访问元素
pub fn get(self: *Self, index: usize) T {
// 索引如果越界则抛出异常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
return self.nums[index];
return self.arr[index];
}
// 更新元素
pub fn set(self: *Self, index: usize, num: T) void {
// 索引如果越界则抛出异常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
self.nums[index] = num;
self.arr[index] = num;
}
// 尾部添加元素
pub fn add(self: *Self, num: T) !void {
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
self.nums[self.size()] = num;
self.arr[self.size()] = num;
// 更新元素数量
self.numSize += 1;
}
@@ -74,9 +74,9 @@ pub fn MyList(comptime T: type) type {
// 将索引 index 以及之后的元素都向后移动一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.nums[j + 1] = self.nums[j];
self.arr[j + 1] = self.arr[j];
}
self.nums[index] = num;
self.arr[index] = num;
// 更新元素数量
self.numSize += 1;
}
@@ -84,11 +84,11 @@ pub fn MyList(comptime T: type) type {
// 删除元素
pub fn remove(self: *Self, index: usize) T {
if (index < 0 or index >= self.size()) @panic("索引越界");
var num = self.nums[index];
var num = self.arr[index];
// 索引 i 之后的元素都向前移动一位
var j = index;
while (j < self.size() - 1) : (j += 1) {
self.nums[j] = self.nums[j + 1];
self.arr[j] = self.arr[j + 1];
}
// 更新元素数量
self.numSize -= 1;
@@ -103,21 +103,21 @@ pub fn MyList(comptime T: type) type {
var extend = try self.mem_allocator.alloc(T, newCapacity);
@memset(extend, @as(T, 0));
// 将原数组中的所有元素复制到新数组
std.mem.copy(T, extend, self.nums);
self.nums = extend;
std.mem.copy(T, extend, self.arr);
self.arr = extend;
// 更新列表容量
self.numsCapacity = newCapacity;
self.arrCapacity = newCapacity;
}
// 将列表转换为数组
pub fn toArray(self: *Self) ![]T {
// 仅转换有效长度范围内的列表元素
var nums = try self.mem_allocator.alloc(T, self.size());
@memset(nums, @as(T, 0));
for (nums, 0..) |*num, i| {
var arr = try self.mem_allocator.alloc(T, self.size());
@memset(arr, @as(T, 0));
for (arr, 0..) |*num, i| {
num.* = self.get(i);
}
return nums;
return arr;
}
};
}
@@ -125,50 +125,49 @@ pub fn MyList(comptime T: type) type {
// Driver Code
pub fn main() !void {
// 初始化列表
var list = MyList(i32){};
try list.init(std.heap.page_allocator);
var nums = MyList(i32){};
try nums.init(std.heap.page_allocator);
// 延迟释放内存
defer list.deinit();
defer nums.deinit();
// 尾部添加元素
try list.add(1);
try list.add(3);
try list.add(2);
try list.add(5);
try list.add(4);
std.debug.print("列表 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
std.debug.print(" ，容量 = {} ，长度 = {}", .{list.capacity(), list.size()});
try nums.add(1);
try nums.add(3);
try nums.add(2);
try nums.add(5);
try nums.add(4);
std.debug.print("列表 nums = ", .{});
inc.PrintUtil.printArray(i32, try nums.toArray());
std.debug.print(" ，容量 = {} ，长度 = {}", .{nums.capacity(), nums.size()});
// 中间插入元素
try list.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
try nums.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, try nums.toArray());
// 删除元素
_ = list.remove(3);
std.debug.print("\n删除索引 3 处的元素，得到 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
_ = nums.remove(3);
std.debug.print("\n删除索引 3 处的元素，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, try nums.toArray());
// 访问元素
var num = list.get(1);
var num = nums.get(1);
std.debug.print("\n访问索引 1 处的元素，得到 num = {}", .{num});
// 更新元素
list.set(1, 0);
std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
nums.set(1, 0);
std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, try nums.toArray());
// 测试扩容机制
var i: i32 = 0;
while (i < 10) : (i += 1) {
// 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
try list.add(i);
try nums.add(i);
}
std.debug.print("\n扩容后的列表 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
std.debug.print(" ，容量 = {} ，长度 = {}\n", .{list.capacity(), list.size()});
std.debug.print("\n扩容后的列表 nums = ", .{});
inc.PrintUtil.printArray(i32, try nums.toArray());
std.debug.print(" ，容量 = {} ，长度 = {}\n", .{nums.capacity(), nums.size()});
_ = try std.io.getStdIn().reader().readByte();
}