algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-04 14:18:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Updathe time_complexity.md

Browse Source
This commit is contained in:
krahets
2023-02-28 00:14:59 +08:00
parent ff6022796c
commit 10903b2781
2 changed files with 12 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -89,7 +89,6 @@ func (g *graphAdjList) removeVertex(vet Vertex) {
func (g *graphAdjList) print() { func (g *graphAdjList) print() {
var builder strings.Builder var builder strings.Builder
fmt.Printf("邻接表 = \n") fmt.Printf("邻接表 = \n")
// 使邻接表有序输出
for k, v := range g.adjList { for k, v := range g.adjList {
builder.WriteString("\t\t" + strconv.Itoa(k.Val) + ": ") builder.WriteString("\t\t" + strconv.Itoa(k.Val) + ": ")
for _, vet := range v { for _, vet := range v {

158
docs/chapter_computational_complexity/time_complexity.md
View File

@ -1528,30 +1528,9 @@ $$
=== "C++" === "C++"
```cpp title="worst_best_time_complexity.cpp" ```cpp title="worst_best_time_complexity.cpp"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
vector<int> randomNumbers(int n) {
vector<int> nums(n);
// 生成数组 nums = { 1, 2, 3, ..., n }
for (int i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 使用系统时间生成随机种子
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
// 随机打乱数组元素
shuffle(nums.begin(), nums.end(), default_random_engine(seed));
return nums;
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
int findOne(vector<int>& nums) {
for (int i = 0; i < nums.size(); i++) {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if (nums[i] == 1)
return i;
}
return -1;
}
``` ```
=== "Python" === "Python"
@ -1565,129 +1544,33 @@ $$
=== "Go" === "Go"
```go title="worst_best_time_complexity.go" ```go title="worst_best_time_complexity.go"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
func randomNumbers(n int) []int {
nums := make([]int, n)
// 生成数组 nums = { 1, 2, 3, ..., n }
for i := 0; i < n; i++ {
nums[i] = i + 1
}
// 随机打乱数组元素
rand.Shuffle(len(nums), func(i, j int) {
nums[i], nums[j] = nums[j], nums[i]
})
return nums
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
func findOne(nums []int) int {
for i := 0; i < len(nums); i++ {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if nums[i] == 1 {
return i
}
}
return -1
}
``` ```
=== "JavaScript" === "JavaScript"
```javascript title="worst_best_time_complexity.js" ```javascript title="worst_best_time_complexity.js"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
function randomNumbers(n) {
const nums = Array(n);
// 生成数组 nums = { 1, 2, 3, ..., n }
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 随机打乱数组元素
for (let i = 0; i < n; i++) {
const r = Math.floor(Math.random() * (i + 1));
const temp = nums[i];
nums[i] = nums[r];
nums[r] = temp;
}
return nums;
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
function findOne(nums) {
for (let i = 0; i < nums.length; i++) {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if (nums[i] === 1) {
return i;
}
}
return -1;
}
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="worst_best_time_complexity.ts" ```typescript title="worst_best_time_complexity.ts"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
function randomNumbers(n: number): number[] {
const nums = Array(n);
// 生成数组 nums = { 1, 2, 3, ..., n }
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 随机打乱数组元素
for (let i = 0; i < n; i++) {
const r = Math.floor(Math.random() * (i + 1));
const temp = nums[i];
nums[i] = nums[r];
nums[r] = temp;
}
return nums;
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
function findOne(nums: number[]): number {
for (let i = 0; i < nums.length; i++) {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if (nums[i] === 1) {
return i;
}
}
return -1;
}
``` ```
=== "C" === "C"
```c title="worst_best_time_complexity.c" ```c title="worst_best_time_complexity.c"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
int *randomNumbers(int n) {
// 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
int *nums = (int *)malloc(n * sizeof(int));
// 生成数组 nums = { 1, 2, 3, ..., n }
for (int i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 随机打乱数组元素
for (int i = n - 1; i > 0; i--) {
int j = rand() % (i + 1);
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
return nums;
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
int findOne(int *nums, int n) {
for (int i = 0; i < n; i++) {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if (nums[i] == 1) return i;
}
return -1;
}
``` ```
=== "C#" === "C#"
@ -1701,26 +1584,9 @@ $$
=== "Swift" === "Swift"
```swift title="worst_best_time_complexity.swift" ```swift title="worst_best_time_complexity.swift"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ [class]{}-[func]{randomNumbers}
func randomNumbers(n: Int) -> [Int] {
// 生成数组 nums = { 1, 2, 3, ..., n }
var nums = Array(1 ... n)
// 随机打乱数组元素
nums.shuffle()
return nums
}
/* 查找数组 nums 中数字 1 所在索引 */ [class]{}-[func]{findOne}
func findOne(nums: [Int]) -> Int {
for i in nums.indices {
// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
if nums[i] == 1 {
return i
}
}
return -1
}
``` ```
=== "Zig" === "Zig"