1. 冒泡排序
public void Popsort(int[] nums){
int n = nums.length;
for(int i = 0; i < n - 1; i++){
boolean flag = false;
for(int j = 1; j <= n - 1 - i; j++){
if(nums[j] < nums[j - 1]){
swap(nums, j, j - 1);
flag = true;
}
}
if(flag == false)return;
}
}
public void swap(int[] a, int i, int j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
时间复杂度:
- 最好:原始序列为正序,O( n n^{} n);
- 最坏:O( n 2 n^{2} n2);
- 平均:O( n 2 n^{2} n2);
空间复杂度: O( 1 1 1);
稳定性: 稳定
2. 直接插入排序
public static void insertSort(int[] a){
for(int i = 1; i < a.length; i++){
if(a[i] < a[i - 1]){//小的时候才插入
int temp = a[i];
int j = i - 1;
while(j >= 0 && temp < a[j]){
a[j + 1] = a[j];
j--;
}
a[j + 1] = temp;//插入
}
}
}
时间复杂度:
- 原始序列正序,此时为最好时间复杂度:O( n n^{} n);
- 原始序列倒序,此时为最坏时间复杂度:O( n 2 n^{2} n2);
- 平均时间复杂度:O( n 2 n^{2} n2);
空间复杂度: O( 1 1^{} 1);
稳定性: 稳定
3. 简单选择排序
public void chooseMinSort(int[] nums){
for(int i = 0; i < nums.length; i++){
int k = i;
for(int j = i + 1; j < nums.length; j++){
if(nums[j] < nums[k])k = j;
}
if(i != k)swap(nums, i, k);
}
}
public void sort(int[] nums, int i, int j){
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
时间复杂度: O( n 2 n^{2} n2)
空间复杂度: O( 1 1^{} 1);
稳定性:
上面因为有判断i != k
时才交换,所以是稳定的,但是如果没有这个判断,就是不稳定的。
4. 堆排序
public void heapSort(int[] nums, int n){//n表示有n个元素
if(nums == null || nums.length == 0)return;
//建堆
for(int i = n / 2 - 1; i >= 0; i--){
heapify(nums, n, i);
}
//排序
for(int i = n - 1; i > 0; i--){
swap(nums, i, 0);
heapify(nums, i, 0);
}
}
public void heapify(int[] nums, int n, int i){
int leftChild = i * 2 + 1;
int rightChild = i * 2 + 2;
int maxIndexOfChild = i;
if(leftChild < n && nums[maxIndexOfChild] < nums[leftChild])maxIndexOfChild= leftChild;
if(rightChild < n && nums[maxIndexOfChild] < nums[rightChild])
maxIndexOfChild= rightChild;
if(maxIndexOfChild != i){
swap(nums, maxIndexOfChild, i);
heapify(nums, n, maxIndexOfChild);
}
}
public void swap(int[] nums, int i, int j){
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
注意:
-
主要分2步:建堆,排序
-
建堆时,是从下往上建,如果有n个结点,建堆的第1个结点为 n / 2 - 1;
-
排序,就是将堆头部最大的元素和堆最下面的元素互换,然后再将其他的n-1个元素建堆。
-
建堆:查看当前节点的子节点,看有没有哪个子节点的val大于父节点,如果有,交换父子节点,如果没有,就不用交换,交换后,再次去建堆。
-
当前节点索引为i,则子节点索引为 2 * i + 1 和 2 * i + 2;
时间复杂度: O( N l o g N Nlog{N} NlogN)
空间复杂度: O( 1 1^{} 1)
稳定性: 不稳定
建堆的时间复杂度: O( N {N} N)
5. 快速排序
public void quickSort(int[] nums, int lower, int high){
int i = lower;
int j = high;
if(lower < high){
int temp = nums[lower];
while(i != j){
while(i < j && nums[j] >= temp)j--;
if(i < j){
nums[i] = nums[j];
i++;
}
while(i < j && nums[i] <= temp)i++;
if(i < j){
nums[j] = nums[i];
j--;
}
}
nums[i] = temp;
quickSort(nums, lower, i - 1);
quickSort(nums, i + 1, high);
}
}
时间复杂度:
最坏: O(
n
2
n^{2}
n2)
最好:O(
n
l
o
g
n
n{logn}
nlogn)
平均:O(
n
l
o
g
n
n{logn}
nlogn)
空间复杂度:
O(log2n),最坏O(n)
稳定性: 不稳定
最后附上之前总结的快速排序—跳转
(未完待续)