algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-19 07:17:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Yudong Jin
2022-12-11 02:33:05 +08:00
committed by GitHub
parent ba91e25239 00bb56f01a
commit 60103f1a41
108 changed files with 922 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
codes/go/chapter_searching/binary_search.go Normal file
View File

@@ -0,0 +1,43 @@
// File: binary_search.go
// Created Time: 2022-12-05
// Author: Slone123c (274325721@qq.com)
package chapter_searching
/* 二分查找（双闭区间） */
func binarySearch(nums []int, target int) int {
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
i, j := 0, len(nums)-1
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
for i <= j {
m := (i + j) / 2 // 计算中点索引 m
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
i = m + 1
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
j = m - 1
} else { // 找到目标元素，返回其索引
return m
}
}
// 未找到目标元素，返回 -1
return -1
}
/* 二分查找（左闭右开） */
func binarySearch1(nums []int, target int) int {
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
i, j := 0, len(nums)
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
for i < j {
m := (i + j) / 2 // 计算中点索引 m
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
i = m + 1
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
j = m
} else { // 找到目标元素，返回其索引
return m
}
}
// 未找到目标元素，返回 -1
return -1
}

24
codes/go/chapter_searching/binary_search_test.go Normal file
View File

@@ -0,0 +1,24 @@
// File: binary_search_test.go
// Created Time: 2022-12-05
// Author: Slone123c (274325721@qq.com)
package chapter_searching
import (
"fmt"
"testing"
)
func TestBinarySearch(t *testing.T) {
var (
target = 3
nums = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
expected = 2
)
// 在数组中执行二分查找
actual := binarySearch(nums, target)
fmt.Println("目标元素 3 的索引 =", actual)
if actual != expected {
t.Errorf("目标元素 3 的索引 = %d, 应该为 %d", actual, expected)
}
}

38
codes/go/chapter_sorting/bubble_sort/bubble_sort.go Normal file
View File

@@ -0,0 +1,38 @@
// File: bubble_sort.go
// Created Time: 2022-12-06
// Author: Slone123c (274325721@qq.com)
package bubble_sort
/* 冒泡排序 */
func bubbleSort(nums []int) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i := len(nums) - 1; i > 0; i-- {
// 内循环：冒泡操作
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]
nums[j], nums[j+1] = nums[j+1], nums[j]
}
}
}
}
/* 冒泡排序（标志优化）*/
func bubbleSortWithFlag(nums []int) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i := len(nums) - 1; i > 0; i-- {
flag := false // 初始化标志位
// 内循环：冒泡操作
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]
nums[j], nums[j+1] = nums[j+1], nums[j]
flag = true // 记录交换元素
}
}
if flag == false { // 此轮冒泡未交换任何元素，直接跳出
break
}
}
}

20
codes/go/chapter_sorting/bubble_sort/bubble_sort_test.go Normal file
View File

@@ -0,0 +1,20 @@
// File: bubble_sort_test.go
// Created Time: 2022-12-06
// Author: Slone123c (274325721@qq.com)
package bubble_sort
import (
"fmt"
"testing"
)
func TestBubbleSort(t *testing.T) {
nums := []int{4, 1, 3, 1, 5, 2}
bubbleSort(nums)
fmt.Println("冒泡排序完成后 nums = ", nums)
nums1 := []int{4, 1, 3, 1, 5, 2}
bubbleSortWithFlag(nums1)
fmt.Println("冒泡排序完成后 nums1 = ", nums)
}

24
codes/java/chapter_hashing/array_hash_map.java
View File

@@ -22,15 +22,15 @@ class ArrayHashMap {
private List<Entry> bucket;
public ArrayHashMap() {
// 初始化一个长度为 10 的桶（数组）
bucket = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
bucket = new ArrayList<>();
for (int i = 0; i < 100; i++) {
bucket.add(null);
}
}
/* 哈希函数 */
private int hashFunc(int key) {
int index = key % 10000;
int index = key % 100;
return index;
}
@@ -102,23 +102,23 @@ public class array_hash_map {
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(10001, "小哈");
map.put(10002, "小啰");
map.put(10003, "小算");
map.put(10004, "小法");
map.put(10005, "小哇");
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
System.out.println("\n添加完成后，哈希表为\nKey -> Value");
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String name = map.get(10002);
System.out.println("\n输入学号 10002 ，查询到姓名 " + name);
String name = map.get(15937);
System.out.println("\n输入学号 15937 ，查询到姓名 " + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(10005);
System.out.println("\n删除 10005 后，哈希表为\nKey -> Value");
map.remove(10583);
System.out.println("\n删除 10583 后，哈希表为\nKey -> Value");
map.print();
/* 遍历哈希表 */

18
codes/java/chapter_hashing/hash_map.java
View File

@@ -15,23 +15,23 @@ public class hash_map {
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(10001, "小哈");
map.put(10002, "小啰");
map.put(10003, "小算");
map.put(10004, "小法");
map.put(10005, "小哇");
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
System.out.println("\n添加完成后，哈希表为\nKey -> Value");
PrintUtil.printHashMap(map);
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String name = map.get(10002);
System.out.println("\n输入学号 10002 ，查询到姓名 " + name);
String name = map.get(15937);
System.out.println("\n输入学号 15937 ，查询到姓名 " + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(10005);
System.out.println("\n删除 10005 后，哈希表为\nKey -> Value");
map.remove(10583);
System.out.println("\n删除 10583 后，哈希表为\nKey -> Value");
PrintUtil.printHashMap(map);
/* 遍历哈希表 */

218
codes/java/chapter_tree/avl_tree.java Normal file
View File

@@ -0,0 +1,218 @@
/*
* File: avl_tree.java
* Created Time: 2022-12-10
* Author: Krahets (krahets@163.com)
*/
package chapter_tree;
import include.*;
// Tree class
class AVLTree {
TreeNode root; // 根节点
/* 获取结点高度 */
public int height(TreeNode node) {
// 空结点高度为 -1 ，叶结点高度为 0
return node == null ? -1 : node.height;
}
/* 更新结点高度 */
private void updateHeight(TreeNode node) {
node.height = Math.max(height(node.left), height(node.right)) + 1;
}
/* 获取平衡因子 */
public int balanceFactor(TreeNode node) {
if (node == null)
return 0;
return height(node.left) - height(node.right);
}
/* 右旋操作 */
private TreeNode rightRotate(TreeNode node) {
TreeNode child = node.left;
TreeNode grandChild = child.right;
child.right = node;
node.left = grandChild;
updateHeight(node);
updateHeight(child);
return child;
}
/* 左旋操作 */
private TreeNode leftRotate(TreeNode node) {
TreeNode child = node.right;
TreeNode grandChild = child.left;
child.left = node;
node.right = grandChild;
updateHeight(node);
updateHeight(child);
return child;
}
/* 执行旋转操作，使该子树重新恢复平衡 */
private TreeNode rotate(TreeNode node) {
int balanceFactor = balanceFactor(node);
// 根据失衡情况分为四种操作：右旋、左旋、先左后右、先右后左
if (balanceFactor > 1) {
if (balanceFactor(node.left) >= 0) {
// 右旋
return rightRotate(node);
} else {
// 先左旋后右旋
node.left = leftRotate(node.left);
return rightRotate(node);
}
}
if (balanceFactor < -1) {
if (balanceFactor(node.right) <= 0) {
// 左旋
return leftRotate(node);
} else {
// 先右旋后左旋
node.right = rightRotate(node.right);
return leftRotate(node);
}
}
return node;
}
/* 插入结点 */
public TreeNode insert(int val) {
root = insertHelper(root, val);
return root;
}
/* 递归插入结点 */
private TreeNode insertHelper(TreeNode node, int val) {
// 1. 查找插入位置，并插入结点
if (node == null)
return new TreeNode(val);
if (val < node.val)
node.left = insertHelper(node.left, val);
else if (val > node.val)
node.right = insertHelper(node.right, val);
else
return node; // 重复结点则直接返回
// 2. 更新结点高度
updateHeight(node);
// 3. 执行旋转操作，使该子树重新恢复平衡
node = rotate(node);
// 返回该子树的根节点
return node;
}
/* 删除结点 */
public TreeNode remove(int val) {
root = removeHelper(root, val);
return root;
}
/* 递归删除结点 */
private TreeNode removeHelper(TreeNode node, int val) {
// 1. 查找结点，并删除之
if (node == null)
return null;
if (val < node.val)
node.left = removeHelper(node.left, val);
else if (val > node.val)
node.right = removeHelper(node.right, val);
else {
if (node.left == null || node.right == null) {
TreeNode child = node.left != null ? node.left : node.right;
// 子结点数量 = 0 ，直接删除 node 并返回
if (child == null)
return null;
// 子结点数量 = 1 ，直接删除 node
else
node = child;
} else {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
TreeNode temp = minNode(node.right);
node.right = removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
// 2. 更新结点高度
updateHeight(node);
// 3. 执行旋转操作，使该子树重新恢复平衡
node = rotate(node);
// 返回该子树的根节点
return node;
}
/* 获取最小结点 */
private TreeNode minNode(TreeNode node) {
if (node == null) return node;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
while (node.left != null) {
node = node.left;
}
return node;
}
/* 查找结点 */
public TreeNode search(int val) {
TreeNode cur = root;
// 循环查找，越过叶结点后跳出
while (cur != null) {
// 目标结点在 root 的右子树中
if (cur.val < val) cur = cur.right;
// 目标结点在 root 的左子树中
else if (cur.val > val) cur = cur.left;
// 找到目标结点，跳出循环
else break;
}
// 返回目标结点
return cur;
}
}
public class avl_tree {
static void testInsert(AVLTree tree, int val) {
tree.insert(val);
System.out.println("\n插入结点 " + val + " 后，AVL 树为");
PrintUtil.printTree(tree.root);
}
static void testRemove(AVLTree tree, int val) {
tree.remove(val);
System.out.println("\n删除结点 " + val + " 后，AVL 树为");
PrintUtil.printTree(tree.root);
}
public static void main(String[] args) {
/* 初始化空 AVL 树 */
AVLTree avlTree = new AVLTree();
/* 插入结点 */
// 请关注插入结点后，AVL 树是如何保持平衡的
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 插入重复结点 */
testInsert(avlTree, 7);
/* 删除结点 */
// 请关注删除结点后，AVL 树是如何保持平衡的
testRemove(avlTree, 8); // 删除度为 0 的结点
testRemove(avlTree, 5); // 删除度为 1 的结点
testRemove(avlTree, 4); // 删除度为 2 的结点
/* 查询结点 */
TreeNode node = avlTree.search(7);
System.out.println("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
}
}

8
codes/java/include/TreeNode.java Executable file → Normal file
View File

@@ -12,10 +12,10 @@ import java.util.*;
* Definition for a binary tree node.
*/
public class TreeNode {
public int val;
public int height;
public TreeNode left;
public TreeNode right;
public int val; // 结点值
public int height; // 结点高度
public TreeNode left; // 左子结点引用
public TreeNode right; // 右子结点引用
public TreeNode(int x) {
val = x;

84
codes/javascript/chapter_stack_and_queue/array_stack.js Normal file
View File

@@ -0,0 +1,84 @@
/**
* File: array_stack.js
* Created Time: 2022-12-09
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 基于数组实现的栈 */
class ArrayStack {
stack;
constructor() {
this.stack = [];
}
/* 获取栈的长度 */
get size() {
return this.stack.length;
}
/* 判断栈是否为空 */
empty() {
return this.stack.length === 0;
}
/* 入栈 */
push(num) {
this.stack.push(num);
}
/* 出栈 */
pop() {
return this.stack.pop();
}
/* 访问栈顶元素 */
top() {
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index) {
return this.stack[index];
}
/* 返回 Array */
toArray() {
return this.stack;
}
};
/* Driver Code */
/* 初始化栈 */
const stack = new ArrayStack();
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
console.log("栈 stack = ");
console.log(stack.toArray());
/* 访问栈顶元素 */
const top = stack.top();
console.log("栈顶元素 top = " + top);
/* 访问索引 index 处元素 */
const num = stack.get(3);
console.log("栈索引 3 处的元素为 num = " + num);
/* 元素出栈 */
const pop = stack.pop();
console.log("出栈元素 pop = " + pop + "，出栈后 stack = ");
console.log(stack.toArray());
/* 获取栈的长度 */
const size = stack.size;
console.log("栈的长度 size = " + size);
/* 判断是否为空 */
const empty = stack.empty();
console.log("栈是否为空 = " + empty);

30
codes/javascript/chapter_stack_and_queue/queue.js Normal file
View File

@@ -0,0 +1,30 @@
/**
* File: queue.js
* Created Time: 2022-12-05
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 初始化队列 */
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue = [];
/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 访问队首元素 */
const peek = queue[0];
/* 元素出队 */
// O(n)
const poll = queue.shift();
/* 获取队列的长度 */
const size = queue.length;
/* 判断队列是否为空 */
const empty = queue.length === 0;

2
codes/python/chapter_stack_and_queue/queue.py
View File

@@ -1,5 +1,5 @@
'''
File: que.py
File: queue.py
Created Time: 2022-11-29
Author: Peng Chen (pengchzn@gmail.com)
'''

86
codes/typescript/chapter_stack_and_queue/array_stack.ts Normal file
View File

@@ -0,0 +1,86 @@
/**
* File: array_stack.ts
* Created Time: 2022-12-08
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 基于数组实现的栈 */
class ArrayStack {
private stack: number[];
constructor() {
this.stack = [];
}
/* 获取栈的长度 */
get size(): number {
return this.stack.length;
}
/* 判断栈是否为空 */
empty(): boolean {
return this.stack.length === 0;
}
/* 入栈 */
push(num: number): void {
this.stack.push(num);
}
/* 出栈 */
pop(): number | undefined {
return this.stack.pop();
}
/* 访问栈顶元素 */
top(): number | undefined {
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index: number): number | undefined {
return this.stack[index];
}
/* 返回 Array */
toArray() {
return this.stack;
}
};
/* Driver Code */
/* 初始化栈 */
const stack = new ArrayStack();
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
console.log("栈 stack = ");
console.log(stack.toArray());
/* 访问栈顶元素 */
const top = stack.top();
console.log("栈顶元素 top = " + top);
/* 访问索引 index 处元素 */
const num = stack.get(3);
console.log("栈索引 3 处的元素为 num = " + num);
/* 元素出栈 */
const pop = stack.pop();
console.log("出栈元素 pop = " + pop + "，出栈后 stack = ");
console.log(stack.toArray());
/* 获取栈的长度 */
const size = stack.size;
console.log("栈的长度 size = " + size);
/* 判断是否为空 */
const empty = stack.empty();
console.log("栈是否为空 = " + empty);
export { };

32
codes/typescript/chapter_stack_and_queue/queue.ts Normal file
View File

@@ -0,0 +1,32 @@
/**
* File: queue.ts
* Created Time: 2022-12-05
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 初始化队列 */
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue: number[] = [];
/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 访问队首元素 */
const peek = queue[0];
/* 元素出队 */
// O(n)
const poll = queue.shift();
/* 获取队列的长度 */
const size = queue.length;
/* 判断队列是否为空 */
const empty = queue.length === 0;
export { };