feat: revise README.md

fiteen · Dec 27, 2019 · a086f4b · a086f4b
1 parent b790fe3
commit a086f4b
Show file tree

Hide file tree

Showing 3 changed files with 15 additions and 15 deletions.
diff --git a/BucketSort/README.md b/BucketSort/README.md
@@ -64,8 +64,8 @@ void bucket_sort(int arr[], int n, int r) {
 - r 次循环，每个桶中的数据进行排序（每个桶中平均有 n/m 个数据）
 
 假如桶内排序用的是选择排序这类时间复杂度较高的排序，整个桶排序的时间复杂度就是 O(n)+O(n²)，视作 O(n²)，这是最差的情况；
-假如桶内排序用的是比较先进的排序算法，时间复杂度为 O(nlogn)，那么整个桶排序的时间复杂度为 O(n)+O(r\*(n/r)\*log(n/r))=O(n+nlog(n/r))。k = nlog(n/r)，桶排序的平均时间复杂度为 O(n+k)。当 r 接近于 n 时，k 趋近于 0，这时桶排序的时间复杂度是最优的，就可以认为是 O(n)。也就是说如果数据被分配到同一个桶中，排序效率最低；但如果数据可以均匀分配到每一个桶中，时间效率最高，可以线性时间运行。但同样地，桶越多，空间就越大。
+假如桶内排序用的是比较先进的排序算法，时间复杂度为 O(nlogn)，那么整个桶排序的时间复杂度为 O(n)+O(r\*(n/r)\*log(n/r))=O(n+nlog(n/r))。k=nlog(n/r)，桶排序的平均时间复杂度为 O(n+k)。当 r 接近于 n 时，k 趋近于 0，这时桶排序的时间复杂度是最优的，就可以认为是 O(n)。也就是说如果数据被分配到同一个桶中，排序效率最低；但如果数据可以均匀分配到每一个桶中，时间效率最高，可以线性时间运行。但同样地，桶越多，空间就越大。
 
 #### 空间复杂度
 
-桶排序中，需要创建 r 个桶的额外空间，以及 n 个元素的额外空间，所以桶排序的空间复杂度为 O(n+r)。
+占用额外内存，需要创建 r 个桶的额外空间，以及 n 个元素的额外空间，所以桶排序的空间复杂度为 O(n+r)。
diff --git a/README.md b/README.md
@@ -8,23 +8,23 @@
 
 **比较类排序**：通过比较来决定元素间的相对次序，时间复杂度为 O(nlogn)～O(n²)。属于比较类的有：
 
-|         排序算法          | 时间复杂度 | 最差情况 | 最好情况 | 空间复杂度 | 稳定性 | 排序方式  |
+|         排序算法          | 时间复杂度 | 最差情况 | 最好情况 | 空间复杂度 | 排序方式 | 稳定性 |
 | :-----------------------: | :--------: | :------: | :------: | :--------: | :----: | :-------: |
-|  [冒泡排序](BubbleSort)   |   O(n²)    |  O(n²)   |   O(n)   |    O(1)    |  ✔  | In-place  |
-|   [快速排序](QuickSort)   |  O(nlogn)  |  O(n²)   | O(nlogn) |  O(logn)   | ✘ | In-place  |
-| [插入排序](InsertionSort) |   O(n²)    |  O(n²)   |   O(n)   |    O(1)    |  ✔  | In-place  |
-|   [希尔排序](ShellSort)   |  O(nlog²n)  |  O(n²)   |   O(n)   |    O(1)    | ✘ | In-place  |
-| [选择排序](SelectionSort) |   O(n²)    |  O(n²)   |  O(n²)   |    O(1)    | ✘ | In-place  |
-|    [堆排序](HeapSort)     |  O(nlogn)  | O(nlogn) | O(nlogn) |    O(1)    | ✘ | In-place  |
-|   [归并排序](MergeSort)   |  O(nlogn)  | O(nlogn) | O(nlogn) |    O(n)    |  ✔  | Out-place |
+|  [冒泡排序](BubbleSort)   |   O(n²)    |  O(n²)   |   O(n)   |    O(1)    |  In-place  | ✔ |
+|   [快速排序](QuickSort)   |  O(nlogn)  |  O(n²)   | O(nlogn) |  O(logn)   | In-place | ✘ |
+| [插入排序](InsertionSort) |   O(n²)    |  O(n²)   |   O(n)   |    O(1)    |  In-place  | ✔ |
+|   [希尔排序](ShellSort)   |  O(nlog²n)  |  O(n²)   |   O(n)   |    O(1)    | In-place | ✘ |
+| [选择排序](SelectionSort) |   O(n²)    |  O(n²)   |  O(n²)   |    O(1)    | In-place | ✘ |
+|    [堆排序](HeapSort)     |  O(nlogn)  | O(nlogn) | O(nlogn) |    O(1)    | In-place | ✘ |
+|   [归并排序](MergeSort)   |  O(nlogn)  | O(nlogn) | O(nlogn) |    O(n)    |  Out-place  | ✔ |
 
 **非比较类排序**：不通过比较来决定元素间的相对次序，其时间复杂度可以突破 O(nlogn)，以线性时间运行。属于非比较类的有：
 
-|         排序算法         | 时间复杂度 | 最差情况  | 最好情况 | 空间复杂度 | 稳定性 | 排序方式  |
+|         排序算法         | 时间复杂度 | 最差情况  | 最好情况 | 空间复杂度 | 排序方式 | 稳定性 |
 | :----------------------: | :--------: | :-------: | :------: | :--------: | :----: | :-------: |
-|   [桶排序](BucketSort)   |   O(n+nlog(n/r))   |   O(n²)   |   O(n)   |   O(n+r)   |  ✔  | Out-place |
-| [计数排序](CountingSort) |   O(n+r)   |  O(n+r)   |  O(n+r)  |   O(n+r)   |  ✔  | Out-place |
-|  [基数排序](RadixSort)   |  O(d(n+r))  | O(d(n+r)) |  O(d(n+r))  |   O(n+r)   |  ✔  | Out-place |
+|   [桶排序](BucketSort)   |   O(n+nlog(n/r))   |   O(n²)   |   O(n)   |   O(n+r)   |  Out-place  | ✔ |
+| [计数排序](CountingSort) |   O(n+r)   |  O(n+r)   |  O(n+r)  |   O(n+r)   |  Out-place  | ✔ |
+|  [基数排序](RadixSort)   |  O(d(n+r))  | O(d(n+r)) |  O(d(n+r))  |   O(n+r)   |  Out-place  | ✔ |
 
 **n**：待排序列的个数
 

diff --git a/RadixSort/README.md b/RadixSort/README.md
@@ -79,7 +79,7 @@ void radix_sort(int arr[], int n) {
 
 #### 空间复杂度
 
-占用额外内存，还需要 r 个桶，所以空间复杂度为 O(n+r)。
+占用额外内存，需要创建 r 个桶的额外空间，以及 n 个元素的额外空间，所以基数排序的空间复杂度为 O(n+r)。
 
 ### 计数排序 & 桶排序 & 基数排序