Skip to content

Commit 0c1ec54

Browse files
committed
update
1 parent a7696ab commit 0c1ec54

File tree

3 files changed

+19
-10
lines changed

3 files changed

+19
-10
lines changed

README.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -78,9 +78,9 @@ CBTType root = null; // 定义二叉树根结点引用
7878

7979
# 排序算法总结 :elephant:
8080

81-
![](https://i.imgur.com/1OW23bg.png)
81+
![](https://i.imgur.com/UsDuUM6.png)
8282

83-
[点击详见](./src/sortingAlgorithm/README.md)
83+
[点击详见](./src/sortingAlgorithm/#top)
8484
# 数据结构与算法 面试题(Java版) :sparkles:
8585

8686
- [单例模式的六种实现](./src/review02#top)

src/sortingAlgorithm/README.md

+15-6
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
# <a id="top"></a>排序算法 ✈
22
排序算法的分类
33

4-
![](https://i.imgur.com/1OW23bg.png)
4+
![](https://i.imgur.com/UsDuUM6.png)
55

66
## 冒泡排序
77
冒泡排序算法通过多次比较和交换来实现排序,其排序流程如下:
@@ -29,6 +29,7 @@ public void bubbleSort(int[] a,int n){
2929
}
3030
```
3131
完整示例代码:[bubble.java](./bubble.java)
32+
3233
## 快速排序
3334
快速排序算法通过多次比较和交换来实现排序,其排序流程如下:
3435
1. 首先设定一个分界值,通过该分界值来将数组分成两部分。
@@ -64,10 +65,10 @@ public void quickSort(int[] a, int left, int right){ // 快速排序算法
6465
ltemp++;
6566
}
6667
if(left<rtemp){
67-
quickSort(a, left, ltemp-1); // 递归调用
68+
quickSort(a, left, ltemp-1); // 左递归调用
6869
}
6970
if(ltemp<right){
70-
quickSort(a, rtemp+1, right); // 递归调用
71+
quickSort(a, rtemp+1, right); // 右递归调用
7172
}
7273
}
7374
```
@@ -102,7 +103,7 @@ public void bubbleSort(int[] a,int n){
102103
完整示例代码:[select.java](./select.java)
103104
## 堆排序
104105
堆排序(Heap Sort)算法是基于选择排序思想的算法,其利用堆结构和二叉树的一些性质来完成数据的排序。堆结构是一种树结构,准确的说是一个完全二叉树。在这个树中每个结点对应于原始数据的一个记录,并且每个结点应满足以下条件:
105-
- 如果按照从小到打的顺序排序,要求非叶结点的数据要大于或等于其左、右子结点的数据。
106+
- 如果按照从小到大的顺序排序,要求非叶结点的数据要大于或等于其左、右子结点的数据。
106107
- 如果按照从大到小的顺序排列,要求非叶结点的数据要小于或等于其左、右子结点的数据。
107108

108109
#### 堆排序过程
@@ -129,7 +130,7 @@ public void bubbleSort(int[] a,int n){
129130
a[j+1]=a[j];
130131
j--;
131132
}
132-
a[j+1]=t;
133+
a[j+1]=t; // 将腾出来的那个位置插入新元素
133134
}
134135
}
135136
```
@@ -181,7 +182,7 @@ public void bubbleSort(int[] a,int n){
181182
a[j+r]=a[j];
182183
j-=r;
183184
}
184-
a[j+r]=t;
185+
a[j+r]=t; // 将腾出来的那个位置插入新元素
185186
}
186187
}
187188
}
@@ -194,3 +195,11 @@ public void bubbleSort(int[] a,int n){
194195

195196
一个待排序的原始数据序列进行合并排序的基本思路是,首先将含有n个结点的待排序数据序列看作由n个长度为1的有序子表组成,将其依次两两合并,得到长度为4的若干有序子表······,重复上述过程,一直到最后的子表长度为n,从而完成排序过程。
196197

198+
# 算法时间复杂度分析
199+
- 冒泡排序算法:冒泡排序中,存在二层循环遍历,所以平均时间复杂度为O(n²),最坏情况下的时间复杂度为O(n²);
200+
- 快速排序算法:快序中,while循环部分时间复杂度为O(logn),左递归和右递归总和的时间复杂度为O(n),所以总的平均时间复杂度为O(n²);
201+
- 选择排序算法:选择排序中,依次从数组中选取最小的,次小的,... 从而得到整个序列。两层循环遍历,所以时间复杂度为O(n²),最坏情况下的时间复杂度为O(n²);
202+
- 堆排序算法:从堆中,一次堆排序挑选最小(或最大)元素的时间复杂度为O(logn),一共要进行n次堆排序得到有序队列,所以平均时间复杂度为O(nlogn),最坏情况下的时间复杂度为O(nlogn);
203+
- 插入排序算法:插入排序中,两层循环,第一层遍历n个元素,第二层遍历在已排序队列中逐一向前比较,找到合适的位置插入,所以平均时间复杂度为O(n²),最坏情况下的时间复杂度为O(n²);
204+
- 折半插入排序算法:在插入排序的基础上进行优化,在第二层遍历在已排序队列中通过二分查找的方式,找到合适的位置插入,所以平均时间复杂度为O(n²),最坏情况下的时间复杂度为O(n²);
205+
- 合并排序算法:均时间复杂度为O(nlogn),最坏情况下的时间复杂度为O(n²);:

src/sortingAlgorithm/insert.java

+2-2
Original file line numberDiff line numberDiff line change
@@ -30,12 +30,12 @@ public void bubbleSort(int[] a,int n){
3030
for(i=1; i<n; i++){
3131
t=a[i];
3232
j=i-1;
33-
while(j>=0 && t<a[j]){ // 后移每个比t大的元素
33+
while(j>=0 && t<a[j]){ // 后移每个比t大的元素
3434
a[j+1]=a[j];
3535
j--;
3636
ex++;
3737
}
38-
a[j+1]=t;
38+
a[j+1]=t; // 将腾出来的那个位置插入新元素
3939
count++;
4040
System.out.print("第"+count+"趟排序结果:");
4141
for (int k = 0; k < a.length; k++) {

0 commit comments

Comments
 (0)