xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-08-23 16:47:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2025-09-11 03:53:49 +08:00
parent 3f088184e4
commit ae2e2535f4
24 changed files with 456 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zh-Hant/docs/chapter_array_and_linkedlist/array.md
+22 -12
View File
@@ -21,7 +21,7 @@ comments: true
```python title="array.py"
# 初始化陣列
arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: list[int] = [1, 3, 2, 5, 4]
nums: list[int] = [1, 3, 2, 5, 4]
```
=== "C++"
@@ -136,8 +136,8 @@ comments: true
```zig title="array.zig"
// 初始化陣列
var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
var nums = [_]i32{ 1, 3, 2, 5, 4 };
const arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
const nums = [_]i32{ 1, 3, 2, 5, 4 };
```
??? pythontutor "視覺化執行"
@@ -330,11 +330,11 @@ comments: true
```zig title="array.zig"
// 隨機訪問元素
fn randomAccess(nums: []i32) i32 {
fn randomAccess(nums: []const i32) i32 {
// 在區間 [0, nums.len) 中隨機抽取一個整數
var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
// 獲取並返回隨機元素
var randomNum = nums[randomIndex];
const randomNum = nums[random_index];
return randomNum;
}
```
@@ -984,18 +984,26 @@ comments: true
```zig title="array.zig"
// 走訪陣列
fn traverse(nums: []i32) void {
fn traverse(nums: []const i32) void {
var count: i32 = 0;
// 透過索引走訪陣列
var i: i32 = 0;
var i: usize = 0;
while (i < nums.len) : (i += 1) {
count += nums[i];
}
count = 0;
// 直接走訪陣列元素
count = 0;
for (nums) |num| {
count += num;
}
// 同時走訪資料索引和元素
for (nums, 0..) |num, index| {
count += nums[index];
count += num;
}
}
```
@@ -1427,12 +1435,14 @@ comments: true
```zig title="array.zig"
// 擴展陣列長度
fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
// 初始化一個擴展長度後的陣列
var res = try mem_allocator.alloc(i32, nums.len + enlarge);
const res = try allocator.alloc(i32, nums.len + enlarge);
@memset(res, 0);
// 將原陣列中的所有元素複製到新陣列
std.mem.copy(i32, res, nums);
std.mem.copyForwards(i32, res, nums);
// 返回擴展後的新陣列
return res;
}
zh-Hant/docs/chapter_array_and_linkedlist/linked_list.md
+21 -19
View File
@@ -621,10 +621,10 @@ comments: true
```zig title="linked_list.zig"
// 在鏈結串列的節點 n0 之後插入節點 P
fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
P.?.next = n1;
n0.?.next = P;
fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
const n1 = n0.next;
P.next = n1;
n0.next = P;
}
```
@@ -835,12 +835,11 @@ comments: true
```zig title="linked_list.zig"
// 刪除鏈結串列的節點 n0 之後的首個節點
fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
var P = n0.?.next;
var n1 = P.?.next;
n0.?.next = n1;
fn remove(comptime T: type, n0: *ListNode(T)) void {
// n0 -> P -> n1 => n0 -> n1
const P = n0.next;
const n1 = P.?.next;
n0.next = n1;
}
```
@@ -1052,12 +1051,15 @@ comments: true
```zig title="linked_list.zig"
// 訪問鏈結串列中索引為 index 的節點
fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
var head: ?*ListNode(T) = node;
var i: i32 = 0;
while (i < index) : (i += 1) {
head = head.?.next;
if (head == null) return null;
if (head) |cur| {
head = cur.next;
} else {
return null;
}
}
return head;
}
@@ -1293,12 +1295,12 @@ comments: true
```zig title="linked_list.zig"
// 在鏈結串列中查詢值為 target 的首個節點
fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
var head: ?*ListNode(T) = node;
var index: i32 = 0;
while (head != null) {
if (head.?.val == target) return index;
head = head.?.next;
while (head) |cur| {
if (cur.val == target) return index;
head = cur.next;
index += 1;
}
return -1;
zh-Hant/docs/chapter_array_and_linkedlist/list.md
+135 -99
View File
@@ -2372,121 +2372,157 @@ comments: true
```zig title="my_list.zig"
// 串列類別
fn MyList(comptime T: type) type {
return struct {
const Self = @This();
arr: []T = undefined, // 陣列（儲存串列元素）
arrCapacity: usize = 10, // 串列容量
numSize: usize = 0, // 串列長度（當前元素數量）
extendRatio: usize = 2, // 每次串列擴容的倍數
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 記憶體分配器
const MyList = struct {
const Self = @This();
// 建構子（分配記憶體+初始化串列）
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.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
@memset(self.arr, @as(T, 0));
}
items: []i32, // 陣列（儲存串列元素）
capacity: usize, // 串列容量
allocator: std.mem.Allocator, // 記憶體分配器
// 析構函式（釋放記憶體）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
extend_ratio: usize = 2, // 每次串列擴容的倍數
// 獲取串列長度（當前元素數量）
pub fn size(self: *Self) usize {
return self.numSize;
}
// 建構子（分配記憶體+初始化串列）
pub fn init(allocator: std.mem.Allocator) Self {
return Self{
.items = &[_]i32{},
.capacity = 0,
.allocator = allocator,
};
}
// 獲取串列容量
pub fn capacity(self: *Self) usize {
return self.arrCapacity;
}
// 析構函式（釋放記憶體）
pub fn deinit(self: Self) void {
self.allocator.free(self.allocatedSlice());
}
// 訪問元素
pub fn get(self: *Self, index: usize) T {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
return self.arr[index];
}
// 在尾部新增元素
pub fn add(self: *Self, item: i32) !void {
// 元素數量超出容量時，觸發擴容機制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 更新元素
pub fn set(self: *Self, index: usize, num: T) void {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
self.arr[index] = num;
}
self.items.len += 1;
const new_item_ptr = &self.items[self.items.len - 1];
new_item_ptr.* = item;
}
// 在尾部新增元素
pub fn add(self: *Self, num: T) !void {
// 元素數量超出容量時，觸發擴容機制
if (self.size() == self.capacity()) try self.extendCapacity();
self.arr[self.size()] = num;
// 更新元素數量
self.numSize += 1;
}
// 獲取串列長度（當前元素數量）
pub fn getSize(self: *Self) usize {
return self.items.len;
}
// 在中間插入元素
pub fn insert(self: *Self, index: usize, num: T) !void {
if (index < 0 or index >= self.size()) @panic("索引越界");
// 元素數量超出容量時，觸發擴容機制
if (self.size() == self.capacity()) try self.extendCapacity();
// 將索引 index 以及之後的元素都向後移動一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.arr[j + 1] = self.arr[j];
// 獲取串列容量
pub fn getCapacity(self: *Self) usize {
return self.capacity;
}
// 訪問元素
pub fn get(self: *Self, index: usize) i32 {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
return self.items[index];
}
// 更新元素
pub fn set(self: *Self, index: usize, num: i32) void {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
self.items[index] = num;
}
// 在中間插入元素
pub fn insert(self: *Self, index: usize, item: i32) !void {
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
// 元素數量超出容量時，觸發擴容機制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 將索引 index 以及之後的元素都向後移動一位
self.items.len += 1;
var i = self.items.len - 1;
while (i >= index) : (i -= 1) {
self.items[i] = self.items[i - 1];
}
self.items[index] = item;
}
// 刪除元素
pub fn remove(self: *Self, index: usize) i32 {
if (index < 0 or index >= self.getSize()) {
@panic("索引越界");
}
// 將索引 index 之後的元素都向前移動一位
const item = self.items[index];
var i = index;
while (i < self.items.len - 1) : (i += 1) {
self.items[i] = self.items[i + 1];
}
self.items.len -= 1;
// 返回被刪除的元素
return item;
}
// 將串列轉換為陣列
pub fn toArraySlice(self: *Self) ![]i32 {
return self.toOwnedSlice(false);
}
// 返回新的切片並設定是否要重置或清空串列容器
pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
const allocator = self.allocator;
const old_memory = self.allocatedSlice();
if (allocator.remap(old_memory, self.items.len)) |new_items| {
if (clear) {
self.* = init(allocator);
}
self.arr[index] = num;
// 更新元素數量
self.numSize += 1;
return new_items;
}
// 刪除元素
pub fn remove(self: *Self, index: usize) T {
if (index < 0 or index >= self.size()) @panic("索引越界");
var num = self.arr[index];
// 將索引 index 之後的元素都向前移動一位
var j = index;
while (j < self.size() - 1) : (j += 1) {
self.arr[j] = self.arr[j + 1];
}
// 更新元素數量
self.numSize -= 1;
// 返回被刪除的元素
return num;
const new_memory = try allocator.alloc(i32, self.items.len);
@memcpy(new_memory, self.items);
if (clear) {
self.clearAndFree();
}
return new_memory;
}
// 串列擴容
pub fn extendCapacity(self: *Self) !void {
// 新建一個長度為 size * extendRatio 的陣列，並將原陣列複製到新陣列
var newCapacity = self.capacity() * self.extendRatio;
var extend = try self.mem_allocator.alloc(T, newCapacity);
@memset(extend, @as(T, 0));
// 將原陣列中的所有元素複製到新陣列
std.mem.copy(T, extend, self.arr);
self.arr = extend;
// 更新串列容量
self.arrCapacity = newCapacity;
}
// 串列擴容
fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
if (self.capacity >= new_capacity) return;
const capcacity = if (self.capacity == 0) 10 else self.capacity;
const better_capacity = capcacity * self.extend_ratio;
// 將串列轉換為陣列
pub fn toArray(self: *Self) ![]T {
// 僅轉換有效長度範圍內的串列元素
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 arr;
const old_memory = self.allocatedSlice();
if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
} else {
const new_memory = try self.allocator.alloc(i32, better_capacity);
@memcpy(new_memory[0..self.items.len], self.items);
self.allocator.free(old_memory);
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
}
};
}
}
fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
allocator.free(self.allocatedSlice());
self.items.len = 0;
self.capacity = 0;
}
fn allocatedSlice(self: Self) []i32 {
return self.items.ptr[0..self.capacity];
}
};
```
??? pythontutor "視覺化執行"
zh-Hant/docs/chapter_computational_complexity/iteration_and_recursion.md
+13 -13
View File
@@ -205,11 +205,11 @@ comments: true
fn forLoop(n: usize) i32 {
var res: i32 = 0;
// 迴圈求和 1, 2, ..., n-1, n
for (1..n+1) |i| {
res = res + @as(i32, @intCast(i));
for (1..n + 1) |i| {
res += @intCast(i);
}
return res;
}
}
```
??? pythontutor "視覺化執行"
@@ -450,9 +450,8 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化條件變數
// 迴圈求和 1, 2, ..., n-1, n
while (i <= n) {
while (i <= n) : (i += 1) {
res += @intCast(i);
i += 1;
}
return res;
}
@@ -711,11 +710,12 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化條件變數
// 迴圈求和 1, 4, 10, ...
while (i <= n) {
res += @intCast(i);
while (i <= n) : ({
// 更新條件變數
i += 1;
i *= 2;
}) {
res += @intCast(i);
}
return res;
}
@@ -965,11 +965,11 @@ comments: true
defer res.deinit();
var buffer: [20]u8 = undefined;
// 迴圈 i = 1, 2, ..., n-1, n
for (1..n+1) |i| {
for (1..n + 1) |i| {
// 迴圈 j = 1, 2, ..., n-1, n
for (1..n+1) |j| {
var _str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{i, j});
try res.appendSlice(_str);
for (1..n + 1) |j| {
const str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{ i, j });
try res.appendSlice(str);
}
}
return res.toOwnedSlice();
@@ -1209,7 +1209,7 @@ comments: true
return 1;
}
// 遞：遞迴呼叫
var res: i32 = recur(n - 1);
const res = recur(n - 1);
// 迴：返回結果
return n + res;
}
@@ -1678,7 +1678,7 @@ comments: true
return n - 1;
}
// 遞迴呼叫 f(n) = f(n-1) + f(n-2)
var res: i32 = fib(n - 1) + fib(n - 2);
const res: i32 = fib(n - 1) + fib(n - 2);
// 返回結果 f(n)
return res;
}
zh-Hant/docs/chapter_computational_complexity/performance_evaluation.md
+2 -2
View File
@@ -30,10 +30,10 @@ comments: true
由於實際測試具有較大的侷限性，我們可以考慮僅透過一些計算來評估演算法的效率。這種估算方法被稱為<u>漸近複雜度分析（asymptotic complexity analysis）</u>，簡稱<u>複雜度分析</u>。
複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料大小之間的關係。**它描述了隨著輸入資料大小的增加，演算法執行所需時間和空間的增長趨勢**。這個定義有些拗口，我們可以將其分為三個重點來理解。
複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料規模之間的關係。**它描述了隨著輸入資料規模的增加，演算法執行所需時間和空間的增長趨勢**。這個定義有些拗口，我們可以將其分為三個重點來理解。
- “時間和空間資源”分別對應<u>時間複雜度（time complexity）</u>和<u>空間複雜度（space complexity）</u>。
- “隨著輸入資料大小的增加”意味著複雜度反映了演算法執行效率與輸入資料體量之間的關係。
- “隨著輸入資料規模的增加”意味著複雜度反映了演算法執行效率與輸入資料規模之間的關係。
- “時間和空間的增長趨勢”表示複雜度分析關注的不是執行時間或佔用空間的具體值，而是時間或空間增長的“快慢”。
**複雜度分析克服了實際測試方法的弊端**，體現在以下幾個方面。
zh-Hant/docs/chapter_computational_complexity/space_complexity.md
+11 -11
View File
@@ -1208,13 +1208,13 @@ $$
fn constant(n: i32) void {
// 常數、變數、物件佔用 O(1) 空間
const a: i32 = 0;
var b: i32 = 0;
var nums = [_]i32{0}**10000;
var node = inc.ListNode(i32){.val = 0};
const b: i32 = 0;
const nums = [_]i32{0} ** 10000;
const node = ListNode(i32){ .val = 0 };
var i: i32 = 0;
// 迴圈中的變數佔用 O(1) 空間
while (i < n) : (i += 1) {
var c: i32 = 0;
const c: i32 = 0;
_ = c;
}
// 迴圈中的函式佔用 O(1) 空間
@@ -1513,7 +1513,7 @@ $$
// 線性階
fn linear(comptime n: i32) !void {
// 長度為 n 的陣列佔用 O(n) 空間
var nums = [_]i32{0}**n;
const nums = [_]i32{0} ** n;
// 長度為 n 的串列佔用 O(n) 空間
var nodes = std.ArrayList(i32).init(std.heap.page_allocator);
defer nodes.deinit();
@@ -2146,8 +2146,8 @@ $$
// 平方階（遞迴實現）
fn quadraticRecur(comptime n: i32) i32 {
if (n <= 0) return 0;
var nums = [_]i32{0}**n;
std.debug.print("遞迴 n = {} 中的 nums 長度 = {}\n", .{n, nums.len});
const nums = [_]i32{0} ** n;
std.debug.print("遞迴 n = {} 中的 nums 長度 = {}\n", .{ n, nums.len });
return quadraticRecur(n - 1);
}
```
@@ -2350,12 +2350,12 @@ $$
```zig title="space_complexity.zig"
// 指數階（建立滿二元樹）
fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
fn buildTree(allocator: std.mem.Allocator, n: i32) !?*TreeNode(i32) {
if (n == 0) return null;
const root = try mem_allocator.create(inc.TreeNode(i32));
const root = try allocator.create(TreeNode(i32));
root.init(0);
root.left = try buildTree(mem_allocator, n - 1);
root.right = try buildTree(mem_allocator, n - 1);
root.left = try buildTree(allocator, n - 1);
root.right = try buildTree(allocator, n - 1);
return root;
}
```
zh-Hant/docs/chapter_computational_complexity/time_complexity.md
+9 -11
View File
@@ -1275,7 +1275,7 @@ $$
var count: i32 = 0;
const size: i32 = 100_000;
var i: i32 = 0;
while(i<size) : (i += 1) {
while (i < size) : (i += 1) {
count += 1;
}
return count;
@@ -2215,7 +2215,7 @@ $$
```zig title="time_complexity.zig"
// 平方階（泡沫排序）
fn bubbleSort(nums: []i32) i32 {
var count: i32 = 0; // 計數器
var count: i32 = 0; // 計數器
// 外迴圈：未排序區間為 [0, i]
var i: i32 = @as(i32, @intCast(nums.len)) - 1;
while (i > 0) : (i -= 1) {
@@ -2224,10 +2224,10 @@ $$
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
var tmp = nums[j];
const tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交換包含 3 個單元操作
count += 3; // 元素交換包含 3 個單元操作
}
}
}
@@ -2870,11 +2870,9 @@ $$
// 對數階（迴圈實現）
fn logarithmic(n: i32) i32 {
var count: i32 = 0;
var n_var = n;
while (n_var > 1)
{
n_var = n_var / 2;
count +=1;
var n_var: i32 = n;
while (n_var > 1) : (n_var = @divTrunc(n_var, 2)) {
count += 1;
}
return count;
}
@@ -3037,7 +3035,7 @@ $$
// 對數階（遞迴實現）
fn logRecur(n: i32) i32 {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
return logRecur(@divTrunc(n, 2)) + 1;
}
```
@@ -3261,7 +3259,7 @@ $$
// 線性對數階
fn linearLogRecur(n: i32) i32 {
if (n <= 1) return 1;
var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);
var count: i32 = linearLogRecur(@divTrunc(n, 2)) + linearLogRecur(@divTrunc(n, 2));
var i: i32 = 0;
while (i < n) : (i += 1) {
count += 1;
zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md
+1 -1
View File
@@ -417,7 +417,7 @@ $$
<p align="center"> 圖 14-14 &nbsp; 暴力搜尋遞迴樹 </p>
每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 $m + n - 2$ 步，所以最差時間複雜度為 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網路邊界時只剩下一種選擇，因此實際的路徑數量會少一些。
每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 $m + n - 2$ 步，所以最差時間複雜度為 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網格邊界時只剩下一種選擇，因此實際的路徑數量會少一些。
### 2. &nbsp; 方法二：記憶化搜尋
zh-Hant/docs/chapter_graph/graph_operations.md
+11 -18
View File
@@ -882,7 +882,7 @@ comments: true
// 在鄰接矩陣中新增一行
self.adj_mat.push(vec![0; n]);
// 在鄰接矩陣中新增一列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.push(0);
}
}
@@ -897,7 +897,7 @@ comments: true
// 在鄰接矩陣中刪除索引 index 的行
self.adj_mat.remove(index);
// 在鄰接矩陣中刪除索引 index 的列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.remove(index);
}
}
@@ -1982,7 +1982,7 @@ comments: true
/* 基於鄰接表實現的無向圖型別 */
pub struct GraphAdjList {
// 鄰接表，key：頂點，value：該頂點的所有鄰接頂點
pub adj_list: HashMap<Vertex, Vec<Vertex>>,
pub adj_list: HashMap<Vertex, Vec<Vertex>>, // maybe HashSet<Vertex> for value part is better?
}
impl GraphAdjList {
@@ -2009,31 +2009,27 @@ comments: true
/* 新增邊 */
pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 新增邊 vet1 - vet2
self.adj_list.get_mut(&vet1).unwrap().push(vet2);
self.adj_list.get_mut(&vet2).unwrap().push(vet1);
self.adj_list.entry(vet1).or_default().push(vet2);
self.adj_list.entry(vet2).or_default().push(vet1);
}
/* 刪除邊 */
#[allow(unused)]
pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 刪除邊 vet1 - vet2
self.adj_list
.get_mut(&vet1)
.unwrap()
.retain(|&vet| vet != vet2);
.entry(vet1)
.and_modify(|v| v.retain(|&e| e != vet2));
self.adj_list
.get_mut(&vet2)
.unwrap()
.retain(|&vet| vet != vet1);
.entry(vet2)
.and_modify(|v| v.retain(|&e| e != vet1));
}
/* 新增頂點 */
@@ -2048,9 +2044,6 @@ comments: true
/* 刪除頂點 */
#[allow(unused)]
pub fn remove_vertex(&mut self, vet: Vertex) {
if !self.adj_list.contains_key(&vet) {
panic!("value error");
}
// 在鄰接表中刪除頂點 vet 對應的鏈結串列
self.adj_list.remove(&vet);
// 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊
zh-Hant/docs/chapter_graph/graph_traversal.md
+1 -2
View File
@@ -324,8 +324,7 @@ BFS 通常藉助佇列來實現，程式碼如下所示。佇列具有“先入
let mut que = VecDeque::new();
que.push_back(start_vet);
// 以頂點 vet 為起點，迴圈直至訪問完所有頂點
while !que.is_empty() {
let vet = que.pop_front().unwrap(); // 佇列首頂點出隊
while let Some(vet) = que.pop_front() {
res.push(vet); // 記錄訪問頂點
// 走訪該頂點的所有鄰接頂點
zh-Hant/docs/chapter_searching/searching_algorithm_revisited.md
+1 -1
View File
@@ -65,7 +65,7 @@ comments: true
</div>
搜尋演算法的選擇還取決於資料體量、搜尋效能要求、資料查詢與更新頻率等。
搜尋演算法的選擇還取決規模、搜尋效能要求、資料查詢與更新頻率等。
**線性搜尋**
zh-Hant/docs/chapter_searching/summary.md
+1 -1
View File
@@ -7,6 +7,6 @@ comments: true
- 二分搜尋依賴資料的有序性，透過迴圈逐步縮減一半搜尋區間來進行查詢。它要求輸入資料有序，且僅適用於陣列或基於陣列實現的資料結構。
- 暴力搜尋透過走訪資料結構來定位資料。線性搜尋適用於陣列和鏈結串列，廣度優先搜尋和深度優先搜尋適用於圖和樹。此類演算法通用性好，無須對資料進行預處理，但時間複雜度 $O(n)$ 較高。
- 雜湊查詢、樹查詢和二分搜尋屬於高效搜尋方法，可在特定資料結構中快速定位目標元素。此類演算法效率高，時間複雜度可達 $O(\log n)$ 甚至 $O(1)$ ，但通常需要藉助額外資料結構。
- 實際中，我們需要對資料體量、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。
- 實際中，我們需要對資料規模、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。
- 線性搜尋適用於小型或頻繁更新的資料；二分搜尋適用於大型、排序的資料；雜湊查詢適用於對查詢效率要求較高且無須範圍查詢的資料；樹查詢適用於需要維護順序和支持範圍查詢的大型動態資料。
- 用雜湊查詢替換線性查詢是一種常用的最佳化執行時間的策略，可將時間複雜度從 $O(n)$ 降至 $O(1)$ 。