github_mirrors/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-01-23 22:40:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'krahets:master' into master

Browse Source
This commit is contained in:
Zero 2023-01-14 15:11:26 +08:00 committed by GitHub
commit 3fc8275520
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 1891 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Dockerfile Normal file
View File

@ -0,0 +1,16 @@
FROM python:3.9.0-alpine
RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip
RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple mkdocs-material==9.0.2
WORKDIR /app
COPY codes /app/codes
COPY docs /app/docs
COPY mkdocs.yml /app/mkdocs.yml
RUN mkdir ./docs/overrides && mkdocs build
EXPOSE 8000
CMD ["mkdocs", "serve", "-a", "0.0.0.0:8000"]

45
codes/go/chapter_heap/heap.go Normal file
View File

@ -0,0 +1,45 @@
// File: intHeap.go
// Created Time: 2023-01-12
// Author: Reanon (793584285@qq.com)
package chapter_heap
// Go 语言中可以通过实现 heap.Interface 来构建整数大顶堆
// 实现 heap.Interface 需要同时实现 sort.Interface
type intHeap []any
// Push heap.Interface 的方法，实现推入元素到堆
func (h *intHeap) Push(x any) {
// Push 和 Pop 使用 pointer receiver 作为参数
// 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。
*h = append(*h, x.(int))
}
// Pop heap.Interface 的方法，实现弹出堆顶元素
func (h *intHeap) Pop() any {
// 待出堆元素存放在最后
last := (*h)[len(*h)-1]
*h = (*h)[:len(*h)-1]
return last
}
// Len sort.Interface 的方法
func (h *intHeap) Len() int {
return len(*h)
}
// Less sort.Interface 的方法
func (h *intHeap) Less(i, j int) bool {
// 如果实现小顶堆，则需要调整为小于号
return (*h)[i].(int) > (*h)[j].(int)
}
// Swap sort.Interface 的方法
func (h *intHeap) Swap(i, j int) {
(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
}
// Top 获取堆顶元素
func (h *intHeap) Top() any {
return (*h)[0]
}

90
codes/go/chapter_heap/heap_test.go Normal file
View File

@ -0,0 +1,90 @@
// File: heap_test.go
// Created Time: 2023-01-12
// Author: Reanon (793584285@qq.com)
package chapter_heap
import (
"container/heap"
"fmt"
"testing"
. "github.com/krahets/hello-algo/pkg"
)
func testPush(h *intHeap, val int) {
// 调用 heap.Interface 的方法，来添加元素
heap.Push(h, val)
fmt.Printf("\n元素 %d 入堆后 \n", val)
PrintHeap(*h)
}
func testPop(h *intHeap) {
// 调用 heap.Interface 的方法，来移除元素
val := heap.Pop(h)
fmt.Printf("\n堆顶元素 %d 出堆后 \n", val)
PrintHeap(*h)
}
func TestHeap(t *testing.T) {
/* 初始化堆 */
// 初始化大顶堆
maxHeap := &intHeap{}
heap.Init(maxHeap)
/* 元素入堆 */
testPush(maxHeap, 1)
testPush(maxHeap, 3)
testPush(maxHeap, 2)
testPush(maxHeap, 5)
testPush(maxHeap, 4)
/* 获取堆顶元素 */
top := maxHeap.Top()
fmt.Printf("堆顶元素为 %d\n", top)
/* 堆顶元素出堆 */
testPop(maxHeap)
testPop(maxHeap)
testPop(maxHeap)
testPop(maxHeap)
testPop(maxHeap)
/* 获取堆大小 */
size := len(*maxHeap)
fmt.Printf("堆元素数量为 %d\n", size)
/* 判断堆是否为空 */
isEmpty := len(*maxHeap) == 0
fmt.Printf("堆是否为空 %t\n", isEmpty)
}
func TestMyHeap(t *testing.T) {
/* 初始化堆 */
// 初始化大顶堆
maxHeap := newMaxHeap([]any{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2})
fmt.Printf("输入数组并建堆后\n")
maxHeap.print()
/* 获取堆顶元素 */
peek := maxHeap.peek()
fmt.Printf("\n堆顶元素为 %d\n", peek)
/* 元素入堆 */
val := 7
maxHeap.push(val)
fmt.Printf("\n元素 %d 入堆后\n", val)
maxHeap.print()
/* 堆顶元素出堆 */
peek = maxHeap.poll()
fmt.Printf("\n堆顶元素 %d 出堆后\n", peek)
maxHeap.print()
/* 获取堆大小 */
size := maxHeap.size()
fmt.Printf("\n堆元素数量为 %d\n", size)
/* 判断堆是否为空 */
isEmpty := maxHeap.isEmpty()
fmt.Printf("\n堆是否为空 %t\n", isEmpty)
}

139
codes/go/chapter_heap/my_heap.go Normal file
View File

@ -0,0 +1,139 @@
// File: my_heap.go
// Created Time: 2023-01-12
// Author: Reanon (793584285@qq.com)
package chapter_heap
import (
"fmt"
. "github.com/krahets/hello-algo/pkg"
)
type maxHeap struct {
// 使用切片而非数组，这样无需考虑扩容问题
data []any
}
/* 构造函数，建立空堆 */
func newHeap() *maxHeap {
return &maxHeap{
data: make([]any, 0),
}
}
/* 构造函数，根据切片建堆 */
func newMaxHeap(nums []any) *maxHeap {
// 所有元素入堆
h := &maxHeap{data: nums}
for i := len(h.data) - 1; i >= 0; i-- {
// 堆化除叶结点以外的其他所有结点
h.siftDown(i)
}
return h
}
/* 获取左子结点索引 */
func (h *maxHeap) left(i int) int {
return 2*i + 1
}
/* 获取右子结点索引 */
func (h *maxHeap) right(i int) int {
return 2*i + 2
}
/* 获取父结点索引 */
func (h *maxHeap) parent(i int) int {
// 向下整除
return (i - 1) / 2
}
/* 交换元素 */
func (h *maxHeap) swap(i, j int) {
h.data[i], h.data[j] = h.data[j], h.data[i]
}
/* 获取堆大小 */
func (h *maxHeap) size() int {
return len(h.data)
}
/* 判断堆是否为空 */
func (h *maxHeap) isEmpty() bool {
return len(h.data) == 0
}
/* 访问堆顶元素 */
func (h *maxHeap) peek() any {
return h.data[0]
}
/* 元素入堆 */
func (h *maxHeap) push(val any) {
// 添加结点
h.data = append(h.data, val)
// 从底至顶堆化
h.siftUp(len(h.data) - 1)
}
/* 从结点 i 开始，从底至顶堆化 */
func (h *maxHeap) siftUp(i int) {
for true {
// 获取结点 i 的父结点
p := h.parent(i)
// 当“越过根结点”或“结点无需修复”时，结束堆化
if p < 0 || h.data[i].(int) <= h.data[p].(int) {
break
}
// 交换两结点
h.swap(i, p)
// 循环向上堆化
i = p
}
}
/* 元素出堆 */
func (h *maxHeap) poll() any {
// 判空处理
if h.isEmpty() {
fmt.Println("error")
}
// 交换根结点与最右叶结点（即交换首元素与尾元素）
h.swap(0, h.size()-1)
// 删除结点
val := h.data[len(h.data)-1]
h.data = h.data[:len(h.data)-1]
// 从顶至底堆化
h.siftDown(0)
// 返回堆顶元素
return val
}
/* 从结点 i 开始，从顶至底堆化 */
func (h *maxHeap) siftDown(i int) {
for true {
// 判断结点 i, l, r 中值最大的结点，记为 max
l, r, max := h.left(i), h.right(i), i
if l < h.size() && h.data[l].(int) > h.data[max].(int) {
max = l
}
if r < h.size() && h.data[r].(int) > h.data[max].(int) {
max = r
}
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if max == i {
break
}
// 交换两结点
h.swap(i, max)
// 循环向下堆化
i = max
}
}
/* 打印堆（二叉树） */
func (h *maxHeap) print() {
PrintHeap(h.data)
}

23
codes/go/pkg/print_utils.go
View File

@ -29,6 +29,22 @@ func PrintList(list *list.List) {
fmt.Print(e.Value, "]\n")
}
// PrintMap Print a hash map
func PrintMap[K comparable, V any](m map[K]V) {
for key, value := range m {
fmt.Println(key, "->", value)
}
}
// PrintHeap Print a heap
func PrintHeap(h []any) {
fmt.Printf("堆的数组表示：")
fmt.Printf("%v", h)
fmt.Printf("\n堆的树状表示：\n")
root := ArrToTree(h)
PrintTree(root)
}
// PrintLinkedList Print a linked list
func PrintLinkedList(node *ListNode) {
if node == nil {
@ -97,10 +113,3 @@ func showTrunk(t *trunk) {
showTrunk(t.prev)
fmt.Print(t.str)
}
// PrintMap Print a hash map
func PrintMap[K comparable, V any](m map[K]V) {
for key, value := range m {
fmt.Println(key, "->", value)
}
}

6
codes/swift/Package.swift
View File

@ -16,6 +16,9 @@ let package = Package(
.executable(name: "stack", targets: ["stack"]),
.executable(name: "linkedlist_stack", targets: ["linkedlist_stack"]),
.executable(name: "array_stack", targets: ["array_stack"]),
.executable(name: "queue", targets: ["queue"]),
.executable(name: "linkedlist_queue", targets: ["linkedlist_queue"]),
.executable(name: "array_queue", targets: ["array_queue"]),
],
targets: [
.target(name: "utils", path: "utils"),
@ -30,5 +33,8 @@ let package = Package(
.executableTarget(name: "stack", path: "chapter_stack_and_queue", sources: ["stack.swift"]),
.executableTarget(name: "linkedlist_stack", dependencies: ["utils"], path: "chapter_stack_and_queue", sources: ["linkedlist_stack.swift"]),
.executableTarget(name: "array_stack", path: "chapter_stack_and_queue", sources: ["array_stack.swift"]),
.executableTarget(name: "queue", path: "chapter_stack_and_queue", sources: ["queue.swift"]),
.executableTarget(name: "linkedlist_queue", dependencies: ["utils"], path: "chapter_stack_and_queue", sources: ["linkedlist_queue.swift"]),
.executableTarget(name: "array_queue", path: "chapter_stack_and_queue", sources: ["array_queue.swift"]),
]
)

116
codes/swift/chapter_stack_and_queue/array_queue.swift Normal file
View File

@ -0,0 +1,116 @@
/**
* File: array_queue.swift
* Created Time: 2023-01-11
* Author: nuomi1 (nuomi1@qq.com)
*/
/* 基于环形数组实现的队列 */
class ArrayQueue {
private var nums: [Int] // 用于存储队列元素的数组
private var front = 0 // 头指针，指向队首
private var rear = 0 // 尾指针，指向队尾 + 1
init(capacity: Int) {
// 初始化数组
nums = Array(repeating: 0, count: capacity)
}
/* 获取队列的容量 */
func capacity() -> Int {
nums.count
}
/* 获取队列的长度 */
func size() -> Int {
let capacity = capacity()
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
return (capacity + rear - front) % capacity
}
/* 判断队列是否为空 */
func isEmpty() -> Bool {
rear - front == 0
}
/* 入队 */
func offer(num: Int) {
if size() == capacity() {
print("队列已满")
return
}
// 尾结点后添加 num
nums[rear] = num
// 尾指针向后移动一位，越过尾部后返回到数组头部
rear = (rear + 1) % capacity()
}
/* 出队 */
@discardableResult
func poll() -> Int {
let num = peek()
// 队头指针向后移动一位，若越过尾部则返回到数组头部
front = (front + 1) % capacity()
return num
}
/* 访问队首元素 */
func peek() -> Int {
if isEmpty() {
fatalError("队列为空")
}
return nums[front]
}
/* 返回数组 */
func toArray() -> [Int] {
let size = size()
let capacity = capacity()
// 仅转换有效长度范围内的列表元素
var res = Array(repeating: 0, count: size)
for (i, j) in sequence(first: (0, front), next: { $0 < size - 1 ? ($0 + 1, $1 + 1) : nil }) {
res[i] = nums[j % capacity]
}
return res
}
}
@main
enum _ArrayQueue {
/* Driver Code */
static func main() {
/* 初始化队列 */
let capacity = 10
let queue = ArrayQueue(capacity: capacity)
/* 元素入队 */
queue.offer(num: 1)
queue.offer(num: 3)
queue.offer(num: 2)
queue.offer(num: 5)
queue.offer(num: 4)
print("队列 queue = \(queue.toArray())")
/* 访问队首元素 */
let peek = queue.peek()
print("队首元素 peek = \(peek)")
/* 元素出队 */
let poll = queue.poll()
print("出队元素 poll = \(poll)，出队后 queue = \(queue.toArray())")
/* 获取队列的长度 */
let size = queue.size()
print("队列长度 size = \(size)")
/* 判断队列是否为空 */
let isEmpty = queue.isEmpty()
print("队列是否为空 = \(isEmpty)")
/* 测试环形数组 */
for i in 0 ..< 10 {
queue.offer(num: i)
queue.poll()
print("第 \(i) 轮入队 + 出队后 queue = \(queue.toArray())")
}
}
}

5
codes/swift/chapter_stack_and_queue/array_stack.swift
View File

@ -29,8 +29,9 @@ class ArrayStack {
}
/* 出栈 */
@discardableResult
func pop() -> Int {
if stack.isEmpty {
if isEmpty() {
fatalError("栈为空")
}
return stack.removeLast()
@ -38,7 +39,7 @@ class ArrayStack {
/* 访问栈顶元素 */
func peek() -> Int {
if stack.isEmpty {
if isEmpty() {
fatalError("栈为空")
}
return stack.last!

105
codes/swift/chapter_stack_and_queue/linkedlist_queue.swift Normal file
View File

@ -0,0 +1,105 @@
/**
* File: linkedlist_queue.swift
* Created Time: 2023-01-11
* Author: nuomi1 (nuomi1@qq.com)
*/
import utils
/* 基于链表实现的队列 */
class LinkedListQueue {
private var front: ListNode? // 头结点
private var rear: ListNode? // 尾结点
private var _size = 0
init() {}
/* 获取队列的长度 */
func size() -> Int {
_size
}
/* 判断队列是否为空 */
func isEmpty() -> Bool {
size() == 0
}
/* 入队 */
func offer(num: Int) {
// 尾结点后添加 num
let node = ListNode(x: num)
// 如果队列为空，则令头、尾结点都指向该结点
if front == nil {
front = node
rear = node
}
// 如果队列不为空，则将该结点添加到尾结点后
else {
rear?.next = node
rear = node
}
_size += 1
}
/* 出队 */
@discardableResult
func poll() -> Int {
let num = peek()
// 删除头结点
front = front?.next
_size -= 1
return num
}
/* 访问队首元素 */
func peek() -> Int {
if isEmpty() {
fatalError("队列为空")
}
return front!.val
}
/* 将链表转化为 Array 并返回 */
func toArray() -> [Int] {
var node = front
var res = Array(repeating: 0, count: size())
for i in res.indices {
res[i] = node!.val
node = node?.next
}
return res
}
}
@main
enum _LinkedListQueue {
/* Driver Code */
static func main() {
/* 初始化队列 */
let queue = LinkedListQueue()
/* 元素入队 */
queue.offer(num: 1)
queue.offer(num: 3)
queue.offer(num: 2)
queue.offer(num: 5)
queue.offer(num: 4)
print("队列 queue = \(queue.toArray())")
/* 访问队首元素 */
let peek = queue.peek()
print("队首元素 peek = \(peek)")
/* 元素出队 */
let poll = queue.poll()
print("出队元素 poll = \(poll)，出队后 queue = \(queue.toArray())")
/* 获取队列的长度 */
let size = queue.size()
print("队列长度 size = \(size)")
/* 判断队列是否为空 */
let isEmpty = queue.isEmpty()
print("队列是否为空 = \(isEmpty)")
}
}

5
codes/swift/chapter_stack_and_queue/linkedlist_stack.swift
View File

@ -20,7 +20,7 @@ class LinkedListStack {
/* 判断栈是否为空 */
func isEmpty() -> Bool {
_size == 0
size() == 0
}
/* 入栈 */
@ -32,6 +32,7 @@ class LinkedListStack {
}
/* 出栈 */
@discardableResult
func pop() -> Int {
let num = peek()
_peek = _peek?.next
@ -41,7 +42,7 @@ class LinkedListStack {
/* 访问栈顶元素 */
func peek() -> Int {
if _size == 0 {
if isEmpty() {
fatalError("栈为空")
}
return _peek!.val

39
codes/swift/chapter_stack_and_queue/queue.swift Normal file
View File

@ -0,0 +1,39 @@
/**
* File: queue.swift
* Created Time: 2023-01-11
* Author: nuomi1 (nuomi1@qq.com)
*/
@main
enum Queue {
/* Driver Code */
static func main() {
/* 初始化队列 */
// Swift 没有内置的队列类，可以把 Array 当作队列来使用
var queue: [Int] = []
/* 元素入队 */
queue.append(1)
queue.append(3)
queue.append(2)
queue.append(5)
queue.append(4)
print("队列 queue = \(queue)")
/* 访问队首元素 */
let peek = queue.first!
print("队首元素 peek = \(peek)")
/* 元素出队 */
let pool = queue.removeFirst()
print("出队元素 poll = \(pool)，出队后 queue = \(queue)")
/* 获取队列的长度 */
let size = queue.count
print("队列长度 size = \(size)")
/* 判断队列是否为空 */
let isEmpty = queue.isEmpty
print("队列是否为空 = \(isEmpty)")
}
}

123
codes/zig/build.zig
View File

@ -64,4 +64,127 @@ pub fn build(b: *std.build.Builder) void {
if (b.args) |args| run_cmd_leetcode_two_sum.addArgs(args);
const run_step_leetcode_two_sum = b.step("run_leetcode_two_sum", "Run leetcode_two_sum");
run_step_leetcode_two_sum.dependOn(&run_cmd_leetcode_two_sum.step);
// Section: "Array"
// Source File: "chapter_array_and_linkedlist/array.zig"
// Run Command: zig build run_array
const exe_array = b.addExecutable("array", "chapter_array_and_linkedlist/array.zig");
exe_array.addPackagePath("include", "include/include.zig");
exe_array.setTarget(target);
exe_array.setBuildMode(mode);
exe_array.install();
const run_cmd_array = exe_array.run();
run_cmd_array.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_array.addArgs(args);
const run_step_array = b.step("run_array", "Run array");
run_step_array.dependOn(&run_cmd_array.step);
// Section: "LinkedList"
// Source File: "chapter_array_and_linkedlist/linked_list.zig"
// Run Command: zig build run_linked_list
const exe_linked_list = b.addExecutable("linked_list", "chapter_array_and_linkedlist/linked_list.zig");
exe_linked_list.addPackagePath("include", "include/include.zig");
exe_linked_list.setTarget(target);
exe_linked_list.setBuildMode(mode);
exe_linked_list.install();
const run_cmd_linked_list = exe_linked_list.run();
run_cmd_linked_list.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_linked_list.addArgs(args);
const run_step_linked_list = b.step("run_linked_list", "Run linked_list");
run_step_linked_list.dependOn(&run_cmd_linked_list.step);
// Section: "List"
// Source File: "chapter_array_and_linkedlist/list.zig"
// Run Command: zig build run_list
const exe_list = b.addExecutable("list", "chapter_array_and_linkedlist/list.zig");
exe_list.addPackagePath("include", "include/include.zig");
exe_list.setTarget(target);
exe_list.setBuildMode(mode);
exe_list.install();
const run_cmd_list = exe_list.run();
run_cmd_list.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_list.addArgs(args);
const run_step_list = b.step("run_list", "Run list");
run_step_list.dependOn(&run_cmd_list.step);
// Source File: "chapter_array_and_linkedlist/my_list.zig"
// Run Command: zig build run_my_list
const exe_my_list = b.addExecutable("my_list", "chapter_array_and_linkedlist/my_list.zig");
exe_my_list.addPackagePath("include", "include/include.zig");
exe_my_list.setTarget(target);
exe_my_list.setBuildMode(mode);
exe_my_list.install();
const run_cmd_my_list = exe_my_list.run();
run_cmd_my_list.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_my_list.addArgs(args);
const run_step_my_list = b.step("run_my_list", "Run my_list");
run_step_my_list.dependOn(&run_cmd_my_list.step);
// Section: "Stack"
// Source File: "chapter_stack_and_queue/stack.zig"
// Run Command: zig build run_stack
const exe_stack = b.addExecutable("stack", "chapter_stack_and_queue/stack.zig");
exe_stack.addPackagePath("include", "include/include.zig");
exe_stack.setTarget(target);
exe_stack.setBuildMode(mode);
exe_stack.install();
const run_cmd_stack = exe_stack.run();
run_cmd_stack.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_stack.addArgs(args);
const run_step_stack = b.step("run_stack", "Run stack");
run_step_stack.dependOn(&run_cmd_stack.step);
// Source File: "chapter_stack_and_queue/linkedlist_stack.zig"
// Run Command: zig build run_linkedlist_stack
const exe_linkedlist_stack = b.addExecutable("linkedlist_stack", "chapter_stack_and_queue/linkedlist_stack.zig");
exe_linkedlist_stack.addPackagePath("include", "include/include.zig");
exe_linkedlist_stack.setTarget(target);
exe_linkedlist_stack.setBuildMode(mode);
exe_linkedlist_stack.install();
const run_cmd_linkedlist_stack = exe_linkedlist_stack.run();
run_cmd_linkedlist_stack.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_linkedlist_stack.addArgs(args);
const run_step_linkedlist_stack = b.step("run_linkedlist_stack", "Run linkedlist_stack");
run_step_linkedlist_stack.dependOn(&run_cmd_linkedlist_stack.step);
// Source File: "chapter_stack_and_queue/array_stack.zig"
// Run Command: zig build run_array_stack
const exe_array_stack = b.addExecutable("array_stack", "chapter_stack_and_queue/array_stack.zig");
exe_array_stack.addPackagePath("include", "include/include.zig");
exe_array_stack.setTarget(target);
exe_array_stack.setBuildMode(mode);
exe_array_stack.install();
const run_cmd_array_stack = exe_linkedlist_stack.run();
run_cmd_array_stack.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_array_stack.addArgs(args);
const run_step_array_stack = b.step("run_array_stack", "Run array_stack");
run_step_array_stack.dependOn(&run_cmd_array_stack.step);
// Section: "Bubble Sort"
// Source File: "chapter_sorting/bubble_sort.zig"
// Run Command: zig build run_bubble_sort
const exe_bubble_sort = b.addExecutable("bubble_sort", "chapter_sorting/bubble_sort.zig");
exe_bubble_sort.addPackagePath("include", "include/include.zig");
exe_bubble_sort.setTarget(target);
exe_bubble_sort.setBuildMode(mode);
exe_bubble_sort.install();
const run_cmd_bubble_sort = exe_bubble_sort.run();
run_cmd_bubble_sort.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_bubble_sort.addArgs(args);
const run_step_bubble_sort = b.step("run_bubble_sort", "Run bubble_sort");
run_step_bubble_sort.dependOn(&run_cmd_bubble_sort.step);
// Section: "Insertion Sort"
// Source File: "chapter_sorting/insertion_sort.zig"
// Run Command: zig build run_insertion_sort
const exe_insertion_sort = b.addExecutable("insertion_sort", "chapter_sorting/insertion_sort.zig");
exe_insertion_sort.addPackagePath("include", "include/include.zig");
exe_insertion_sort.setTarget(target);
exe_insertion_sort.setBuildMode(mode);
exe_insertion_sort.install();
const run_cmd_insertion_sort = exe_insertion_sort.run();
run_cmd_insertion_sort.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd_insertion_sort.addArgs(args);
const run_step_insertion_sort = b.step("run_insertion_sort", "Run insertion_sort");
run_step_insertion_sort.dependOn(&run_cmd_insertion_sort.step);
}

117
codes/zig/chapter_array_and_linkedlist/array.zig Normal file
View File

@ -0,0 +1,117 @@
// File: array.zig
// Created Time: 2023-01-07
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 随机返回一个数组元素
pub fn randomAccess(nums: []i32) i32 {
// 在区间 [0, nums.len) 中随机抽取一个整数
var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
// 获取并返回随机元素
var randomNum = nums[randomIndex];
return randomNum;
}
// 扩展数组长度
pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
// 初始化一个扩展长度后的数组
var res = try mem_allocator.alloc(i32, nums.len + enlarge);
std.mem.set(i32, res, 0);
// 将原数组中的所有元素复制到新数组
std.mem.copy(i32, res, nums);
// 返回扩展后的新数组
return res;
}
// 在数组的索引 index 处插入元素 num
pub fn insert(nums: []i32, num: i32, index: usize) void {
// 把索引 index 以及之后的所有元素向后移动一位
var i = nums.len - 1;
while (i > index) : (i -= 1) {
nums[i] = nums[i - 1];
}
// 将 num 赋给 index 处元素
nums[index] = num;
}
// 删除索引 index 处元素
pub fn remove(nums: []i32, index: usize) void {
// 把索引 index 之后的所有元素向前移动一位
var i = index;
while (i < nums.len - 1) : (i += 1) {
nums[i] = nums[i + 1];
}
}
// 遍历数组
pub fn traverse(nums: []i32) void {
var count: i32 = 0;
// 通过索引遍历数组
var i: i32 = 0;
while (i < nums.len) : (i += 1) {
count += 1;
}
count = 0;
// 直接遍历数组
for (nums) |_| {
count += 1;
}
}
// 在数组中查找指定元素
pub fn find(nums: []i32, target: i32) i32 {
for (nums) |num, i| {
if (num == target) return @intCast(i32, i);
}
return -1;
}
// Driver Code
pub fn main() !void {
// 初始化数组
const size: i32 = 5;
var arr = [_]i32{0} ** size;
std.debug.print("数组 arr = ", .{});
inc.PrintUtil.printArray(i32, &arr);
var array = [_]i32{ 1, 3, 2, 5, 4 };
std.debug.print("\n数组 nums = ", .{});
inc.PrintUtil.printArray(i32, &array);
// 随机访问
var randomNum = randomAccess(&array);
std.debug.print("\n在 nums 中获取随机元素 {}", .{randomNum});
// 长度扩展
var known_at_runtime_zero: usize = 0;
var nums: []i32 = array[known_at_runtime_zero..array.len];
var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer mem_arena.deinit();
const mem_allocator = mem_arena.allocator();
nums = try extend(mem_allocator, nums, 3);
std.debug.print("\n将数组长度扩展至 8 ，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, nums);
// 插入元素
insert(nums, 6, 3);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, nums);
// 删除元素
remove(nums, 2);
std.debug.print("\n删除索引 2 处的元素，得到 nums = ", .{});
inc.PrintUtil.printArray(i32, nums);
// 遍历数组
traverse(nums);
// 查找元素
var index = find(nums, 3);
std.debug.print("\n在 nums 中查找元素 3 ，得到索引 = {}\n", .{index});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

85
codes/zig/chapter_array_and_linkedlist/linked_list.zig Normal file
View File

@ -0,0 +1,85 @@
// File: linked_list.zig
// Created Time: 2023-01-07
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 在链表的结点 n0 之后插入结点 P
pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
n0.?.next = P;
P.?.next = n1;
}
// 删除链表的结点 n0 之后的首个结点
pub 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;
}
// 访问链表中索引为 index 的结点
pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
var i: i32 = 0;
while (i < index) : (i += 1) {
head = head.?.next;
if (head == null) return null;
}
return head;
}
// 在链表中查找值为 target 的首个结点
pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
var index: i32 = 0;
while (head != null) {
if (head.?.val == target) return index;
head = head.?.next;
index += 1;
}
return -1;
}
// Driver Code
pub fn main() !void {
// 初始化链表
// 初始化各个结点
var n0 = inc.ListNode(i32){.val = 1};
var n1 = inc.ListNode(i32){.val = 3};
var n2 = inc.ListNode(i32){.val = 2};
var n3 = inc.ListNode(i32){.val = 5};
var n4 = inc.ListNode(i32){.val = 4};
// 构建引用指向
n0.next = &n1;
n1.next = &n2;
n2.next = &n3;
n3.next = &n4;
std.debug.print("初始化的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 插入结点
var tmp = inc.ListNode(i32){.val = 0};
insert(&n0, &tmp);
std.debug.print("插入结点后的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 删除结点
remove(&n0);
std.debug.print("删除结点后的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 访问结点
var node = access(&n0, 3);
std.debug.print("链表中索引 3 处的结点的值 = {}\n", .{node.?.val});
// 查找结点
var index = find(&n0, 2);
std.debug.print("链表中值为 2 的结点的索引 = {}\n", .{index});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

81
codes/zig/chapter_array_and_linkedlist/list.zig Normal file
View File

@ -0,0 +1,81 @@
// File: list.zig
// Created Time: 2023-01-07
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// Driver Code
pub fn main() !void {
// 初始化列表
var list = 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);
// 访问元素
var num = list.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);
// 清空列表
list.clearRetainingCapacity();
std.debug.print("\n清空列表后 list = ", .{});
inc.PrintUtil.printList(i32, list);
// 尾部添加元素
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 list.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
// 删除元素
var value = list.orderedRemove(3);
_ = value;
std.debug.print("\n删除索引 3 处的元素，得到 list = ", .{});
inc.PrintUtil.printList(i32, list);
// 通过索引遍历列表
var count: i32 = 0;
var i: i32 = 0;
while (i < list.items.len) : (i += 1) {
count += 1;
}
// 直接遍历列表元素
count = 0;
for (list.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);
// 排序列表
std.sort.sort(i32, list.items, {}, comptime std.sort.asc(i32));
std.debug.print("\n排序列表后 list = ", .{});
inc.PrintUtil.printList(i32, list);
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

177
codes/zig/chapter_array_and_linkedlist/my_list.zig Normal file
View File

@ -0,0 +1,177 @@
// File: my_list.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 列表类简易实现
// 编译期泛型
pub fn MyList(comptime T: type) type {
return struct {
const Self = @This();
nums: []T = undefined, // 数组（存储列表元素）
numsCapacity: usize = 10, // 列表容量
numSize: usize = 0, // 列表长度（即当前元素数量）
extendRatio: usize = 2, // 每次列表扩容的倍数
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.nums = try self.mem_allocator.alloc(T, self.numsCapacity);
std.mem.set(T, self.nums, @as(T, 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.numSize;
}
// 获取列表容量
pub fn capacity(self: *Self) usize {
return self.numsCapacity;
}
// 访问元素
pub fn get(self: *Self, index: usize) T {
// 索引如果越界则抛出异常，下同
if (index >= self.size()) @panic("索引越界");
return self.nums[index];
}
// 更新元素
pub fn set(self: *Self, index: usize, num: T) void {
// 索引如果越界则抛出异常，下同
if (index >= self.size()) @panic("索引越界");
self.nums[index] = num;
}
// 尾部添加元素
pub fn add(self: *Self, num: T) !void {
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
self.nums[self.size()] = num;
// 更新元素数量
self.numSize += 1;
}
// 中间插入元素
pub fn insert(self: *Self, index: usize, num: T) !void {
if (index >= self.size()) @panic("索引越界");
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
// 索引 i 以及之后的元素都向后移动一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.nums[j + 1] = self.nums[j];
}
self.nums[index] = num;
// 更新元素数量
self.numSize += 1;
}
// 删除元素
pub fn remove(self: *Self, index: usize) T {
if (index >= self.size()) @panic("索引越界");
var num = self.nums[index];
// 索引 i 之后的元素都向前移动一位
var j = index;
while (j < self.size() - 1) : (j += 1) {
self.nums[j] = self.nums[j + 1];
}
// 更新元素数量
self.numSize -= 1;
// 返回被删除元素
return num;
}
// 列表扩容
pub fn extendCapacity(self: *Self) !void {
// 新建一个长度为 size * extendRatio 的数组，并将原数组拷贝到新数组
var newCapacity = self.capacity() * self.extendRatio;
var extend = try self.mem_allocator.alloc(T, newCapacity);
std.mem.set(T, extend, @as(T, 0));
// 将原数组中的所有元素复制到新数组
std.mem.copy(T, extend, self.nums);
self.nums = extend;
// 更新列表容量
self.numsCapacity = newCapacity;
}
// 将列表转换为数组
pub fn toArray(self: *Self) ![]T {
// 仅转换有效长度范围内的列表元素
var nums = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, nums, @as(T, 0));
for (nums) |*num, i| {
num.* = self.get(i);
}
return nums;
}
};
}
// Driver Code
pub fn main() !void {
// 初始化列表
var list = MyList(i32){};
try list.init(std.heap.page_allocator);
// 延迟释放内存
defer list.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 list.insert(3, 6);
std.debug.print("\n在索引 3 处插入数字 6 ，得到 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
// 删除元素
_ = list.remove(3);
std.debug.print("\n删除索引 3 处的元素，得到 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
// 访问元素
var num = list.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());
// 测试扩容机制
list.set(1, 0);
var i: i32 = 0;
while (i < 10) : (i += 1) {
// 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
try list.add(i);
}
std.debug.print("\n扩容后的列表 list = ", .{});
inc.PrintUtil.printArray(i32, try list.toArray());
std.debug.print(" ，容量 = {} ，长度 = {}\n", .{list.capacity(), list.size()});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

62
codes/zig/chapter_sorting/bubble_sort.zig Normal file
View File

@ -0,0 +1,62 @@
// File: time_complexity.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 冒泡排序
fn bubbleSort(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var j: usize = 0;
// 内循环：冒泡操作
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
var tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
// 冒泡排序（标志优化）
fn bubbleSortWithFlag(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var flag = false; // 初始化标志位
var j: usize = 0;
// 内循环：冒泡操作
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
var tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true;
}
}
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
}
}
// Driver Code
pub fn main() !void {
var nums = [_]i32{ 4, 1, 3, 1, 5, 2 };
bubbleSort(&nums);
std.debug.print("冒泡排序完成后 nums = ", .{});
inc.PrintUtil.printArray(i32, &nums);
var nums1 = [_]i32{ 4, 1, 3, 1, 5, 2 };
bubbleSortWithFlag(&nums1);
std.debug.print("\n冒泡排序完成后 nums1 = ", .{});
inc.PrintUtil.printArray(i32, &nums1);
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

33
codes/zig/chapter_sorting/insertion_sort.zig Normal file
View File

@ -0,0 +1,33 @@
// File: time_complexity.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 插入排序
fn insertionSort(nums: []i32) void {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
var i: usize = 1;
while (i < nums.len) : (i += 1) {
var base = nums[i];
var j: usize = i;
// 内循环：将 base 插入到左边的正确位置
while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
nums[j] = nums[j - 1]; // 1. 将 nums[j] 向右移动一位
}
nums[j] = base; // 2. 将 base 赋值到正确位置
}
}
// Driver Code
pub fn main() !void {
var nums = [_]i32{ 4, 1, 3, 1, 5, 2 };
insertionSort(&nums);
std.debug.print("插入排序完成后 nums = ", .{});
inc.PrintUtil.printArray(i32, &nums);
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

99
codes/zig/chapter_stack_and_queue/array_stack.zig Normal file
View File

@ -0,0 +1,99 @@
// File: stack.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@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 empty(self: *Self) bool {
return self.size() == 0;
}
// 访问栈顶元素
pub fn top(self: *Self) T {
if (self.size() == 0) @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 top = stack.top();
std.debug.print("\n栈顶元素 top = {}", .{top});
// 元素出栈
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 empty = stack.empty();
std.debug.print("\n栈是否为空 = {}", .{empty});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

120
codes/zig/chapter_stack_and_queue/linkedlist_stack.zig Normal file
View File

@ -0,0 +1,120 @@
// File: linkedlist_stack.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@gmail.com)
const std = @import("std");
const inc = @import("include");
// 基于链表实现的栈
// 编译期泛型
pub fn LinkedListStack(comptime T: type) type {
return struct {
const Self = @This();
stackTop: ?*inc.ListNode(T) = null, // 将头结点作为栈顶
stkSize: 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.stackTop = null;
self.stkSize = 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.stkSize;
}
// 判断栈是否为空
pub fn empty(self: *Self) bool {
return self.size() == 0;
}
// 访问栈顶元素
pub fn top(self: *Self) T {
if (self.size() == 0) @panic("栈为空");
return self.stackTop.?.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;
}
// 出栈
pub fn pop(self: *Self) T {
var num = self.top();
self.stackTop = self.stackTop.?.next;
self.stkSize -= 1;
return num;
}
// 将栈转换为数组
pub fn toArray(self: *Self) ![]T {
var node = self.stackTop;
var res = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, 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 top = stack.top();
std.debug.print("\n栈顶元素 top = {}", .{top});
// 元素出栈
top = stack.pop();
std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{top});
inc.PrintUtil.printArray(i32, try stack.toArray());
// 获取栈的长度
var size = stack.size();
std.debug.print("\n栈的长度 size = {}", .{size});
// 判断栈是否为空
var empty = stack.empty();
std.debug.print("\n栈是否为空 = {}", .{empty});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

44
codes/zig/chapter_stack_and_queue/stack.zig Normal file
View File

@ -0,0 +1,44 @@
// File: stack.zig
// Created Time: 2023-01-08
// Author: sjinzh (sjinzh@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 top = stack.items[stack.items.len - 1];
std.debug.print("\n栈顶元素 top = {}", .{top});
// 元素出栈
top = stack.pop();
std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{top});
inc.PrintUtil.printList(i32, stack);
// 获取栈的长度
var size = stack.items.len;
std.debug.print("\n栈的长度 size = {}", .{size});
// 判断栈是否为空
var empty = if (stack.items.len == 0) true else false;
std.debug.print("\n栈是否为空 = {}", .{empty});
const getchar = try std.io.getStdIn().reader().readByte();
_ = getchar;
}

32
codes/zig/include/PrintUtil.zig
View File

@ -7,16 +7,42 @@ const ListNode = @import("ListNode.zig").ListNode;
const TreeNode = @import("TreeNode.zig").TreeNode;
// Print an array
// 编译期泛型
pub fn printArray(comptime T: type, nums: []T) void {
std.debug.print("[", .{});
if (nums.len > 0) {
for (nums) |num, j| {
std.debug.print("{}{s}", .{num, if (j == nums.len-1) "]\n" else ", " });
std.debug.print("{}{s}", .{num, if (j == nums.len-1) "]" else ", " });
}
} else {
std.debug.print("]", .{});
std.debug.print("\n", .{});
}
}
// Print a list
pub fn printList(comptime T: type, list: std.ArrayList(T)) void {
std.debug.print("[", .{});
if (list.items.len > 0) {
for (list.items) |value, i| {
std.debug.print("{}{s}", .{value, if (i == list.items.len-1) "]" else ", " });
}
} else {
std.debug.print("]", .{});
}
}
// Print a linked list
pub fn printLinkedList(comptime T: type, node: ?*ListNode(T)) !void {
if (node == null) return;
var list = std.ArrayList(i32).init(std.heap.page_allocator);
defer list.deinit();
var head = node;
while (head != null) {
try list.append(head.?.val);
head = head.?.next;
}
for (list.items) |value, i| {
std.debug.print("{}{s}", .{value, if (i == list.items.len-1) "\n" else "->" });
}
}

7
docker-compose.yml Normal file
View File

@ -0,0 +1,7 @@
version: '3'
services:
hello-algo:
build: .
ports:
- "8000:8000"

175
docs/chapter_heap/heap.md
View File

@ -97,7 +97,80 @@ comments: true
=== "Go"
```go title="heap.go"
// Go 语言中可以通过实现 heap.Interface 来构建整数大顶堆
// 实现 heap.Interface 需要同时实现 sort.Interface
type intHeap []any
// Push heap.Interface 的方法，实现推入元素到堆
func (h *intHeap) Push(x any) {
// Push 和 Pop 使用 pointer receiver 作为参数
// 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。
*h = append(*h, x.(int))
}
// Pop heap.Interface 的方法，实现弹出堆顶元素
func (h *intHeap) Pop() any {
// 待出堆元素存放在最后
last := (*h)[len(*h)-1]
*h = (*h)[:len(*h)-1]
return last
}
// Len sort.Interface 的方法
func (h *intHeap) Len() int {
return len(*h)
}
// Less sort.Interface 的方法
func (h *intHeap) Less(i, j int) bool {
// 如果实现小顶堆，则需要调整为小于号
return (*h)[i].(int) > (*h)[j].(int)
}
// Swap sort.Interface 的方法
func (h *intHeap) Swap(i, j int) {
(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
}
// Top 获取堆顶元素
func (h *intHeap) Top() any {
return (*h)[0]
}
/* Driver Code */
func TestHeap(t *testing.T) {
/* 初始化堆 */
// 初始化大顶堆
maxHeap := &intHeap{}
heap.Init(maxHeap)
/* 元素入堆 */
// 调用 heap.Interface 的方法，来添加元素
heap.Push(maxHeap, 1)
heap.Push(maxHeap, 3)
heap.Push(maxHeap, 2)
heap.Push(maxHeap, 4)
heap.Push(maxHeap, 5)
/* 获取堆顶元素 */
top := maxHeap.Top()
fmt.Printf("堆顶元素为 %d\n", top)
/* 堆顶元素出堆 */
// 调用 heap.Interface 的方法，来移除元素
heap.Pop(maxHeap)
heap.Pop(maxHeap)
heap.Pop(maxHeap)
heap.Pop(maxHeap)
heap.Pop(maxHeap)
/* 获取堆大小 */
size := len(*maxHeap)
fmt.Printf("堆元素数量为 %d\n", size)
/* 判断堆是否为空 */
isEmpty := len(*maxHeap) == 0
fmt.Printf("堆是否为空 %t\n", isEmpty)
}
```
=== "JavaScript"
@ -188,7 +261,33 @@ comments: true
=== "Go"
```go title="my_heap.go"
type maxHeap struct {
// 使用切片而非数组，这样无需考虑扩容问题
data []any
}
/* 构造函数，建立空堆 */
func newHeap() *maxHeap {
return &maxHeap{
data: make([]any, 0),
}
}
/* 获取左子结点索引 */
func (h *maxHeap) left(i int) int {
return 2*i + 1
}
/* 获取右子结点索引 */
func (h *maxHeap) right(i int) int {
return 2*i + 2
}
/* 获取父结点索引 */
func (h *maxHeap) parent(i int) int {
// 向下整除
return (i - 1) / 2
}
```
=== "JavaScript"
@ -249,7 +348,10 @@ comments: true
=== "Go"
```go title="my_heap.go"
/* 访问堆顶元素 */
func (h *maxHeap) peek() any {
return h.data[0]
}
```
=== "JavaScript"
@ -350,7 +452,29 @@ comments: true
=== "Go"
```go title="my_heap.go"
/* 元素入堆 */
func (h *maxHeap) push(val any) {
// 添加结点
h.data = append(h.data, val)
// 从底至顶堆化
h.siftUp(len(h.data) - 1)
}
/* 从结点 i 开始，从底至顶堆化 */
func (h *maxHeap) siftUp(i int) {
for true {
// 获取结点 i 的父结点
p := h.parent(i)
// 当“越过根结点”或“结点无需修复”时，结束堆化
if p < 0 || h.data[i].(int) <= h.data[p].(int) {
break
}
// 交换两结点
h.swap(i, p)
// 循环向上堆化
i = p
}
}
```
=== "JavaScript"
@ -477,7 +601,45 @@ comments: true
=== "Go"
```go title="my_heap.go"
/* 元素出堆 */
func (h *maxHeap) poll() any {
// 判空处理
if h.isEmpty() {
fmt.Println("error")
}
// 交换根结点与最右叶结点（即交换首元素与尾元素）
h.swap(0, h.size()-1)
// 删除结点
val := h.data[len(h.data)-1]
h.data = h.data[:len(h.data)-1]
// 从顶至底堆化
h.siftDown(0)
// 返回堆顶元素
return val
}
/* 从结点 i 开始，从顶至底堆化 */
func (h *maxHeap) siftDown(i int) {
for true {
// 判断结点 i, l, r 中值最大的结点，记为 max
l, r, max := h.left(i), h.right(i), i
if l < h.size() && h.data[l].(int) > h.data[max].(int) {
max = l
}
if r < h.size() && h.data[r].(int) > h.data[max].(int) {
max = r
}
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if max == i {
break
}
// 交换两结点
h.swap(i, max)
// 循环向下堆化
i = max
}
}
```
=== "JavaScript"
@ -545,7 +707,16 @@ comments: true
=== "Go"
```go title="my_heap.go"
/* 构造函数，根据切片建堆 */
func newMaxHeap(nums []any) *maxHeap {
// 所有元素入堆
h := &maxHeap{data: nums}
for i := len(h.data) - 1; i >= 0; i-- {
// 堆化除叶结点以外的其他所有结点
h.siftDown(i)
}
return h
}
```
=== "JavaScript"

2
docs/chapter_introduction/what_is_dsa.md
View File

@ -6,7 +6,7 @@ comments: true
## 算法定义
「算法 Algorithm」是在有限时间内解决问题的一组指令或操作步骤。算法具有以下特性：
「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。算法具有以下特性：
- 问题是明确的，需要拥有明确的输入和输出定义。
- 解具有确定性，即给定相同输入时，输出一定相同。

21
docs/chapter_preface/contribution.md
View File

@ -41,4 +41,25 @@ comments: true
非常欢迎您和我一同来创作本书！
## 本地部署 hello-algo
### Docker
请确保 Docker 已经安装并启动，并根据如下命令离线部署。
稍等片刻，即可使用浏览器打开 `http://localhost:8000` 访问本项目。
```bash
git clone https://github.com/krahets/hello-algo.git
cd hello-algo
docker-compose up -d
```
使用如下命令即可删除部署。
```bash
docker-compose down
```
（TODO：教学视频）

5
docs/chapter_preface/installation.md
View File

@ -15,10 +15,9 @@ comments: true
1. 下载并安装 [OpenJDK](https://jdk.java.net/18/)（版本需满足 > JDK 9）。
2. 在 VSCode 的插件市场中搜索 `java` ，安装 Java Extension Pack 。
## C/C++ 环境
## C++ 环境
1. Windows 系统需要安装 [MinGW](https://www.mingw-w64.org/downloads/) ，MacOS 自带 Clang 无需安装。
1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/) （[完整配置教程](https://zhuanlan.zhihu.com/p/77074009)），MacOS 自带 Clang 无需安装。
2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。
## Python 环境

135
docs/chapter_stack_and_queue/queue.md
View File

@ -231,7 +231,28 @@ comments: true
=== "Swift"
```swift title="queue.swift"
/* 初始化队列 */
// Swift 没有内置的队列类，可以把 Array 当作队列来使用
var queue: [Int] = []
/* 元素入队 */
queue.append(1)
queue.append(3)
queue.append(2)
queue.append(5)
queue.append(4)
/* 访问队首元素 */
let peek = queue.first!
/* 元素出队 */
let pool = queue.removeFirst()
/* 获取队列的长度 */
let size = queue.count
/* 判断队列是否为空 */
let isEmpty = queue.isEmpty
```
## 队列实现
@ -627,7 +648,59 @@ comments: true
=== "Swift"
```swift title="linkedlist_queue.swift"
/* 基于链表实现的队列 */
class LinkedListQueue {
private var front: ListNode? // 头结点
private var rear: ListNode? // 尾结点
private var _size = 0
init() {}
/* 获取队列的长度 */
func size() -> Int {
_size
}
/* 判断队列是否为空 */
func isEmpty() -> Bool {
size() == 0
}
/* 入队 */
func offer(num: Int) {
// 尾结点后添加 num
let node = ListNode(x: num)
// 如果队列为空，则令头、尾结点都指向该结点
if front == nil {
front = node
rear = node
}
// 如果队列不为空，则将该结点添加到尾结点后
else {
rear?.next = node
rear = node
}
_size += 1
}
/* 出队 */
@discardableResult
func poll() -> Int {
let num = peek()
// 删除头结点
front = front?.next
_size -= 1
return num
}
/* 访问队首元素 */
func peek() -> Int {
if isEmpty() {
fatalError("队列为空")
}
return front!.val
}
}
```
### 基于数组的实现
@ -1042,7 +1115,63 @@ comments: true
=== "Swift"
```swift title="array_queue.swift"
/* 基于环形数组实现的队列 */
class ArrayQueue {
private var nums: [Int] // 用于存储队列元素的数组
private var front = 0 // 头指针，指向队首
private var rear = 0 // 尾指针，指向队尾 + 1
init(capacity: Int) {
// 初始化数组
nums = Array(repeating: 0, count: capacity)
}
/* 获取队列的容量 */
func capacity() -> Int {
nums.count
}
/* 获取队列的长度 */
func size() -> Int {
let capacity = capacity()
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
return (capacity + rear - front) % capacity
}
/* 判断队列是否为空 */
func isEmpty() -> Bool {
rear - front == 0
}
/* 入队 */
func offer(num: Int) {
if size() == capacity() {
print("队列已满")
return
}
// 尾结点后添加 num
nums[rear] = num
// 尾指针向后移动一位，越过尾部后返回到数组头部
rear = (rear + 1) % capacity()
}
/* 出队 */
@discardableResult
func poll() -> Int {
let num = peek()
// 队头指针向后移动一位，若越过尾部则返回到数组头部
front = (front + 1) % capacity()
return num
}
/* 访问队首元素 */
func peek() -> Int {
if isEmpty() {
fatalError("队列为空")
}
return nums[front]
}
}
```
## 队列典型应用

26
docs/chapter_stack_and_queue/stack.md
View File

@ -641,7 +641,7 @@ comments: true
/* 判断栈是否为空 */
func isEmpty() -> Bool {
_size == 0
size() == 0
}
/* 入栈 */
@ -653,6 +653,7 @@ comments: true
}
/* 出栈 */
@discardableResult
func pop() -> Int {
let num = peek()
_peek = _peek?.next
@ -662,22 +663,11 @@ comments: true
/* 访问栈顶元素 */
func peek() -> Int {
if _size == 0 {
if isEmpty() {
fatalError("栈为空")
}
return _peek!.val
}
/* 将 List 转化为 Array 并返回 */
func toArray() -> [Int] {
var node = _peek
var res = Array(repeating: 0, count: _size)
for i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {
res[i] = node!.val
node = node?.next
}
return res
}
}
```
@ -994,8 +984,9 @@ comments: true
}
/* 出栈 */
@discardableResult
func pop() -> Int {
if stack.isEmpty {
if isEmpty() {
fatalError("栈为空")
}
return stack.removeLast()
@ -1003,16 +994,11 @@ comments: true
/* 访问栈顶元素 */
func peek() -> Int {
if stack.isEmpty {
if isEmpty() {
fatalError("栈为空")
}
return stack.last!
}
/* 将 List 转化为 Array 并返回 */
func toArray() -> [Int] {
stack
}
}
```

2
docs/chapter_tree/binary_tree.md
View File

@ -114,7 +114,7 @@ comments: true
结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 及其以下结点形成的树」和「结点 5 及其以下结点形成的树」。
除了叶结点外，每个结点都有子结点和子树。例如，若将下图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 及其以下结点形成的树」和「结点 5 及其以下结点形成的树」。
![binary_tree_definition](binary_tree.assets/binary_tree_definition.png)