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

Polish the chapter of heap, introduction, preface.

Browse Source 
Replace "其它" with "其他"
This commit is contained in:
krahets
2023-04-09 19:12:37 +08:00
parent 10e2180013
commit 0bec52d7cc
29 changed files with 185 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
codes/c/chapter_sorting/bucket_sort.c
View File

@@ -7,23 +7,24 @@
#include "../include/include.h"
/* 冒泡排序 */
void bucketSort(double nums[], int size) {
void bucketSort(double nums[], int size)
{
// 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
int k = size / 2;
// 1. 将数组元素分配到各个桶中
// 1. 将数组元素分配到各个桶中
// 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
// 将 num 添加进桶 i
// 2. 对各个桶执行排序
// 2. 对各个桶执行排序
// 使用内置切片排序函数，也可以替换成其它排序算法
// 3. 遍历桶合并结果
// 使用内置切片排序函数，也可以替换成其他排序算法
// 3. 遍历桶合并结果
}
/* Driver Code */
int main() {
int main()
{
// 设输入数据为浮点数，范围为 [0, 1)
double nums[] = {0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37};
int size = sizeof(nums) / sizeof(double);
@@ -31,7 +32,8 @@ int main() {
printf("桶排序完成后 nums = ");
printf("[");
for (int i = 0; i < size - 1; i++) {
for (int i = 0; i < size - 1; i++)
{
printf("%g, ", nums[i]);
}
printf("]");

54
codes/cpp/chapter_graph/graph_adjacency_list.cpp
View File

@@ -7,15 +7,19 @@
#include "../include/include.hpp"
/* 基于邻接表实现的无向图类 */
class GraphAdjList {
class GraphAdjList
{
public:
// 邻接表，key: 顶点，value：该顶点的所有邻接顶点
unordered_map<Vertex*, vector<Vertex*>> adjList;
unordered_map<Vertex *, vector<Vertex *>> adjList;
/* 在 vector 中删除指定节点 */
void remove(vector<Vertex*> &vec, Vertex *vet) {
for (int i = 0; i < vec.size(); i++) {
if (vec[i] == vet) {
void remove(vector<Vertex *> &vec, Vertex *vet)
{
for (int i = 0; i < vec.size(); i++)
{
if (vec[i] == vet)
{
vec.erase(vec.begin() + i);
break;
}
@@ -23,9 +27,11 @@ public:
}
/* 构造方法 */
GraphAdjList(const vector<vector<Vertex*>>& edges) {
GraphAdjList(const vector<vector<Vertex *>> &edges)
{
// 添加所有顶点和边
for (const vector<Vertex*>& edge : edges) {
for (const vector<Vertex *> &edge : edges)
{
addVertex(edge[0]);
addVertex(edge[1]);
addEdge(edge[0], edge[1]);
@@ -36,7 +42,8 @@ public:
int size() { return adjList.size(); }
/* 添加边 */
void addEdge(Vertex* vet1, Vertex* vet2) {
void addEdge(Vertex *vet1, Vertex *vet2)
{
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("不存在顶点");
// 添加边 vet1 - vet2
@@ -45,7 +52,8 @@ public:
}
/* 删除边 */
void removeEdge(Vertex* vet1, Vertex* vet2) {
void removeEdge(Vertex *vet1, Vertex *vet2)
{
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("不存在顶点");
// 删除边 vet1 - vet2
@@ -54,30 +62,36 @@ public:
}
/* 添加顶点 */
void addVertex(Vertex* vet) {
if (adjList.count(vet)) return;
void addVertex(Vertex *vet)
{
if (adjList.count(vet))
return;
// 在邻接表中添加一个新链表
adjList[vet] = vector<Vertex*>();
adjList[vet] = vector<Vertex *>();
}
/* 删除顶点 */
void removeVertex(Vertex* vet) {
void removeVertex(Vertex *vet)
{
if (!adjList.count(vet))
throw invalid_argument("不存在顶点");
// 在邻接表中删除顶点 vet 对应的链表
adjList.erase(vet);
// 遍历其它顶点的链表，删除所有包含 vet 的边
for (auto& [key, vec] : adjList) {
// 遍历其他顶点的链表，删除所有包含 vet 的边
for (auto &[key, vec] : adjList)
{
remove(vec, vet);
}
}
/* 打印邻接表 */
void print() {
void print()
{
cout << "邻接表 =" << endl;
for (auto& adj : adjList) {
const auto& key= adj.first;
const auto& vec = adj.second;
for (auto &adj : adjList)
{
const auto &key = adj.first;
const auto &vec = adj.second;
cout << key->val << ": ";
PrintUtil::printVector(vetsToVals(vec));
}

20
codes/cpp/chapter_sorting/bucket_sort.cpp
View File

@@ -7,33 +7,39 @@
#include "../include/include.hpp"
/* 桶排序 */
void bucketSort(vector<float> &nums) {
void bucketSort(vector<float> &nums)
{
// 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. 将数组元素分配到各个桶中
for (float num : nums) {
for (float num : nums)
{
// 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
int i = num * k;
// 将 num 添加进桶 bucket_idx
buckets[i].push_back(num);
}
// 2. 对各个桶执行排序
for (vector<float> &bucket : buckets) {
// 使用内置排序函数，也可以替换成其它排序算法
for (vector<float> &bucket : buckets)
{
// 使用内置排序函数，也可以替换成其他排序算法
sort(bucket.begin(), bucket.end());
}
// 3. 遍历桶合并结果
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
for (vector<float> &bucket : buckets)
{
for (float num : bucket)
{
nums[i++] = num;
}
}
}
/* Driver Code */
int main() {
int main()
{
// 设输入数据为浮点数，范围为 [0, 1)
vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
bucketSort(nums);

2
codes/csharp/chapter_graph/graph_adjacency_list.cs
View File

@@ -70,7 +70,7 @@ public class GraphAdjList
throw new InvalidOperationException();
// 在邻接表中删除顶点 vet 对应的链表
adjList.Remove(vet);
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
foreach (List<Vertex> list in adjList.Values)
{
list.Remove(vet);

2
codes/go/chapter_graph/graph_adjacency_list.go
View File

@@ -79,7 +79,7 @@ func (g *graphAdjList) removeVertex(vet Vertex) {
}
// 在邻接表中删除顶点 vet 对应的链表
delete(g.adjList, vet)
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
for _, list := range g.adjList {
DeleteSliceElms(list, vet)
}

2
codes/go/chapter_sorting/bucket_sort.go
View File

@@ -23,7 +23,7 @@ func bucketSort(nums []float64) {
}
// 2. 对各个桶执行排序
for i := 0; i < k; i++ {
// 使用内置切片排序函数，也可以替换成其它排序算法
// 使用内置切片排序函数，也可以替换成其他排序算法
sort.Float64s(buckets[i])
}
// 3. 遍历桶合并结果

2
codes/java/chapter_graph/graph_adjacency_list.java
View File

@@ -62,7 +62,7 @@ class GraphAdjList {
throw new IllegalArgumentException();
// 在邻接表中删除顶点 vet 对应的链表
adjList.remove(vet);
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
for (List<Vertex> list : adjList.values()) {
list.remove(vet);
}

2
codes/java/chapter_sorting/bucket_sort.java
View File

@@ -26,7 +26,7 @@ public class bucket_sort {
}
// 2. 对各个桶执行排序
for (List<Float> bucket : buckets) {
// 使用内置排序函数，也可以替换成其它排序算法
// 使用内置排序函数，也可以替换成其他排序算法
Collections.sort(bucket);
}
// 3. 遍历桶合并结果

2
codes/javascript/chapter_graph/graph_adjacency_list.js
View File

@@ -61,7 +61,7 @@ class GraphAdjList {
}
// 在邻接表中删除顶点 vet 对应的链表
this.adjList.delete(vet);
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
for (let set of this.adjList.values()) {
const index = set.indexOf(vet);
if (index > -1) {

2
codes/javascript/chapter_sorting/bucket_sort.js
View File

@@ -21,7 +21,7 @@ function bucketSort(nums) {
}
// 2. 对各个桶执行排序
for (const bucket of buckets) {
// 使用内置排序函数，也可以替换成其它排序算法
// 使用内置排序函数，也可以替换成其他排序算法
bucket.sort((a, b) => a - b);
}
// 3. 遍历桶合并结果

2
codes/python/chapter_graph/graph_adjacency_list.py
View File

@@ -56,7 +56,7 @@ class GraphAdjList:
raise ValueError
# 在邻接表中删除顶点 vet 对应的链表
self.adj_list.pop(vet)
# 遍历其它顶点的链表，删除所有包含 vet 的边
# 遍历其他顶点的链表，删除所有包含 vet 的边
for vertex in self.adj_list:
if vet in self.adj_list[vertex]:
self.adj_list[vertex].remove(vet)

2
codes/python/chapter_sorting/bucket_sort.py
View File

@@ -18,7 +18,7 @@ def bucket_sort(nums: list[float]) -> None:
buckets[i].append(num)
# 2. 对各个桶执行排序5
for bucket in buckets:
# 使用内置排序函数，也可以替换成其它排序算法
# 使用内置排序函数，也可以替换成其他排序算法
bucket.sort()
# 3. 遍历桶合并结果
i = 0

2
codes/swift/chapter_graph/graph_adjacency_list.swift
View File

@@ -63,7 +63,7 @@ public class GraphAdjList {
}
// 在邻接表中删除顶点 vet 对应的链表
adjList.removeValue(forKey: vet)
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
for key in adjList.keys {
adjList[key]?.removeAll(where: { $0 == vet })
}

2
codes/swift/chapter_sorting/bucket_sort.swift
View File

@@ -18,7 +18,7 @@ func bucketSort(nums: inout [Double]) {
}
// 2. 对各个桶执行排序
for i in buckets.indices {
// 使用内置排序函数，也可以替换成其它排序算法
// 使用内置排序函数，也可以替换成其他排序算法
buckets[i].sort()
}
// 3. 遍历桶合并结果

2
codes/typescript/chapter_graph/graph_adjacency_list.ts
View File

@@ -61,7 +61,7 @@ class GraphAdjList {
}
// 在邻接表中删除顶点 vet 对应的链表
this.adjList.delete(vet);
// 遍历其它顶点的链表，删除所有包含 vet 的边
// 遍历其他顶点的链表，删除所有包含 vet 的边
for (let set of this.adjList.values()) {
const index: number = set.indexOf(vet);
if (index > -1) {

2
codes/typescript/chapter_sorting/bucket_sort.ts
View File

@@ -21,7 +21,7 @@ function bucketSort(nums: number[]): void {
}
// 2. 对各个桶执行排序
for (const bucket of buckets) {
// 使用内置排序函数，也可以替换成其它排序算法
// 使用内置排序函数，也可以替换成其他排序算法
bucket.sort((a, b) => a - b);
}
// 3. 遍历桶合并结果