交换排序
- |–冒泡排序
- |–快速排序
- 插入排序
- |–直接插入排序
- |–希尔排序
- 选择排序
- |–简单选择排序
- |–堆排序
- 归并排序
- 基数排序
稳定排序:假设在待排序的文件中,存在了两个或两个以上的记录具有相同的关键字,在某种排序算法排序后,若这些相同关键字的元素的相对次序依然不变,则这种排序方法是稳定的。
- 稳定:冒泡、插入、归并、基数
- 不稳定:选择、快速、希尔、堆
public static void main(String[] args) {
int[] arr = {
3,9,7,6,8,4,5,10,2,1};
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
//bubbleSort(arr);
//quickSort(arr, 0, arr.length-1);
//insertSort(arr);
//shellSort(arr);
//selectSort(arr);
heapSort(arr, arr.length);
//int[] merge = new int[10];
//mergeSort(arr, merge, 0, arr.length-1);
//basketSort(arr);
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
}
public static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
冒泡
/*
冒泡排序
最好时间复杂度 o(n),最坏时间复杂度o(n^2),平均o(n^2),稳定
*/
public static void bubbleSort(int[] arr){
if (arr == null || arr.length == 0) {
return;
}
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j] > arr[j+1]) {
swap(arr,j,j+1);
}
}
}
}
每趟排序结果:
start : 3 9 7 6 8 4 5 10 2 1
process: 3 7 6 8 4 5 9 2 1 10
process: 3 6 7 4 5 8 2 1 9 10
process: 3 6 4 5 7 2 1 8 9 10
process: 3 4 5 6 2 1 7 8 9 10
process: 3 4 5 2 1 6 7 8 9 10
process: 3 4 2 1 5 6 7 8 9 10
process: 3 2 1 4 5 6 7 8 9 10
process: 2 1 3 4 5 6 7 8 9 10
process: 1 2 3 4 5 6 7 8 9 10
end : 1 2 3 4 5 6 7 8 9 10
快排
/*
* 快速排序
* 最好时间复杂度 o(nlog(2)n),最坏时间复杂度o(n^2),平均o(n^2),不稳定
*/
public static void quickSort(int[] arr,int left,int right){
//左边索引小于右边,则还未排序完成
if (left < right) {
//取中间的元素作为比较基准,小于他的往左边移,大于他的往右边移
int mid = arr[(left+right)/2];
int i = left - 1;
int j = right + 1;
while (true) {
//移动下标,左边的往右移动,右边的向左移动
while(arr[++i] < mid && i < right);
while(arr[--j] > mid && j > left);
if (i >= j) break;
swap(arr, i, j);
}
quickSort(arr, left, i-1);
quickSort(arr, j+1, right);
}
}
每趟排序结果:
start : 3 9