常见的Java排序算法总结如下：
（1）快速排序算法 — 平均时间复杂度O(nlogn)
private static void QuickSort(int[] arr, int start, int end){
if(start < end){
//先找一个基数
int stad = arr[start];
//记录需要排序的下标
int low = arr[start];
int high = arr[end];
//循环找出比基数大的数，比基数小的数
while(low < high){
//右边的数比基数大
while(low < high && stad <= arr[high]){
high--;
}
//使用右边的数替换左边的数
arr[low] = arr[high];
//左边的数比基数小
while(low < high && arr[low] <= stad){
low++;
}
//使用左边的数替换右边的数
arr[high] = arr[low];
}
//把基数赋给低位置所在元素
arr[low] = stad;
//使用递归进行排序剩下的数
QuickSort(arr, stad, low);
QuickSort(arr, low+1, high);
}
}
(2) 冒泡排序算法 — 平均时间复杂度O(n^2)
private static void BubbleSort(int[] arr){
//控制一共要进行比较多少轮
for(int i = 0; i < arr.length-1; i++){
//比较次数
for(int j = 0; j < arr.length-i-1; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
(3) 选择排序算法 — 平均时间复杂度O(n^2)
private static void SelectSort(int[] arr){
int len = arr.length;
for(int i = 0; i < len-1; i++){
for(int j = i+1; j < len; j++){
if(arr[i] > arr[j]){
int remp = arr[i];
arr[i] = arr[j];
arr[j] = remp;
}
}
}
}
(4) 插入排序算法 — 平均时间复杂度O(n^2)
private static void InSertSort(int[] arr){
//遍历所有数字
for(int i = 1; i < arr.length; i++){
//如果当前数字比前一个数字小
if(arr[i] < arr[i-1]){
//把当前遍历数存储起来
int temp = arr[i];
//遍历当前数字前的所有数字
for(int j = i-1; j >= 0 && temp < arr[j]; j--){
//如果当前数小于前一个数，把当前数赋给后一个数
arr[j+1] = arr[j];
}
//把临时变量（外层for循环的当前元素）赋给不满足条件的后一个元素
arr[j+1] = temp;
}
}
}
(5) 归并排序算法 — 平均时间复杂度O(nlogn)
private static void MergeSort(int[] arr, int low, int high){
if(low < high){
int mid = (low + high)/2;
//递归遍历
MergeSort(arr, low mid);
MergeSort(arr, mid+1, high);
merge(arr, low, mid, high);
}
}
private static void merge(int[] arr, int low, int mid, int high){
//用于存储归并后的数组
int[] temp = new int[high - low + 1];
//记录第一个数组中需要遍历的下标
int i = low;
//记录第二个数组中需要遍历的下标
int j = mid+1;
//记录在临时数组中存放的下标
int index = 0;
//遍历两个数组取出小的数字放入临时数组中
while(i <= mid && j <= high){
//第一个数组中的元素更小
if(arr[i] <= arr[j]){
//将小的数据放入临时数组中
temp[index++] = arr[i++];
}else{
temp[index++] = arr[j++];
}
}
//出来多余的数组
while(i <= mid){
temp[index++] = arr[i++];
}
while(j <= high){
temp[index++] = arr[j++];
}
//把临时数组中的元素放回原数组
for(int k = 0; k < temp.length; k++){
arr[k+low] = temp[k];
}
}
(6) 希尔排序算法 — 平均时间复杂度O(nlogn)
private static void ShellSort(int[] arr){
int step = arr.length/2;
while(step > 1){
for(int i = step; i < arr.length; i += step){
int temp = arr[i];
for(int j = i; j > 0 && arr[j-step] > temp; j -= step){
arr[j] = arr[j-step];
}
arr[j] = temp;
}
step /= 2;
}
}
（7）一个简单的列表递归排序算法
private static void RecursionSort(List<Integer> items){
if(items.size() > 1){
//新建三个临时链表
List<Integer> smaller = new ArrayList<>(); //较小的数
List<Integer> same= new ArrayList<>(); //相同的数字
List<Integer> larger= new ArrayList<>(); //较大的数
//取到链表中间位置的数
Integer choseItem = items.get(items.size()/2);
//遍历和该数进行比较
for(Integer i : items){
if(i > choseItem)
larger.add(i);
else if(i < choseItem)
smaller.add(i);
else
same.add(i);
}
//遍历对每一个临时链表中数进行排序
RecursionSort(smaller);
RecursionSort(larger);
//把临时链表的数放回到原链表中
items.clear();
items.addAll(smaller);
items.addAll(same);
items.addAll(larger);
}
}
常见Java排序算法时间复杂度总结如下：
