标签：最坏情况 closed 构建 ble nbsp play 频繁 情况 event
.
for(i=0;i<length-1;i++) for(j=i+1;j<length;j++) if(arrayVal[i]>arrayVal[j]) { //置换位置 temp=arrayVal[i]; arrayVal[i]=arrayVal[j]; arrayVal[j]=temp; } }
for(int i = 0; i < arr.length - 1; i++) { int k = i; for(int j = k + 1; j < arr.length; j++){ if( arr[j] < arr[k]){ k =j; } //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换 if( i != k) { int temp= arr[i]; arr[i] = arr[k]; arr[k] = temp; }
// 第1个数肯定是有序的，从第2个数开始遍历，依次插入有序序列
public static void insertionSort(int[] a){
for(int i = 1 ; i < a.length; i++){
int temp = a[i];
int j = i - 1;
while( j >= 0 && temp < a[j]){
a[j+1] = a[j];
j--;
}
a[j+1] = temp;
}
Shell排序算法：（希尔排序、缩小增量排序）：
//希尔排序
public static void shellSort(int a[]){
for(int r = a.length/2 ; r >= 1; r/=2 ){
for(int i = r; i < a.length ; i++){
int temp = a[i];
int j = i - r;
while(j >= 0 && temp < a[j]){
a[j+r] = a[j];
j -= r;
}
a[j+r] = temp;
}
}
}
快速排序算法
public static void quickSort3(int arr[],int _left,int _right){
int left = _left;
int right = _right;
int temp = 0;
if(left <= right){ //待排序的元素至少有两个的情况
temp = arr[left]; //待排序的第一个元素作为基准元素
while(left != right){ //从左右两边交替扫描，直到left = right
while(right > left && arr[right] >= temp){
right --; //从右往左扫描，找到第一个比基准元素小的元素
}
arr[left] = arr[right];
while(left < right && arr[left] <= temp){
left ++; //从左往右扫描，找到第一个比基准元素大的元素
}
arr[right] = arr[left];
}
arr[right] = temp; //基准元素归位
quickSort3(arr,_left,left-1); //对基准元素左边的元素进行递归排序
quickSort3(arr, right+1,_right); //对基准元素右边的进行递归排序
}
}
堆排序算法
堆排序的基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
堆排序的基本步骤：
1.构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
2.将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
public class HeapSort {
public static void main(String []args){
int []arr = {9,8,7,6,5,4,3,2,1};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int []arr){
//1.构建大顶堆
for(int i=arr.length/2-1;i>=0;i--){
adjustHeap(arr,i,arr.length);
}
for(int j=arr.length-1;j>0;j--){
swap(arr,0,j);
adjustHeap(arr,0,j);
}
}
// 调整大顶堆
public static void adjustHeap(int []arr,int i,int length){
int temp = arr[i];
for(int k=i*2+1;k<length;k=k*2+1){
if(k+1<length && arr[k]<arr[k+1]){
k++;
}
if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点
arr[i] = arr[k];
i = k;
}else{
break;
}
}
arr[i] = temp;
}
//交换元素
public static void swap(int []arr,int a ,int b){
int temp=arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
public class MergeSort {
public static void main(String []args){
int []arr = {9,8,7,6,5,4,3,2,1};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int []arr){
int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
sort(arr,0,arr.length-1,temp);
}
private static void sort(int[] arr,int left,int right,int []temp){
if(left<right){
int mid = (left+right)/2;
sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
}
}
private static void merge(int[] arr,int left,int mid,int right,int[] temp){
int i = left;
int j = mid+1;
int t = 0;
while (i<=mid && j<=right){
if(arr[i]<=arr[j]){
temp[t++] = arr[i++];
}else {
temp[t++] = arr[j++];
}
}
while(i<=mid){
temp[t++] = arr[i++];
}
while(j<=right){
temp[t++] = arr[j++];
}
t = 0;
//将temp中的元素全部拷贝到原数组中
while(left <= right){
arr[left++] = temp[t++];
}
}
}
各个排序算法比较：
| 排序算法 | 平均速度 | 最坏情况 | 是否稳定 |
| 冒泡排序 | O( n^2) | O( n^2) | 稳定 |
| 快速排序 | O(nlogn) | O( n^2) | 不稳定 |
| 选择排序 | O( n^2) | O( n^2) | 不稳定 |
| 插入排序 | O( n^2) | O( n^2) | 稳定 |
| 堆排序 | O(nlogn) | O(nlogn) | 不稳定 |
| Shell排序 | O( n^(3/2) ) | O( n^2) | 不稳定 |
| 合并排序 | O(nlogn) | O(nlogn) | 稳定 |
标签：最坏情况 closed 构建 ble nbsp play 频繁 情况 event
原文地址：https://www.cnblogs.com/lmyau/p/9157272.html
