七大經典排序(Java版)
阿新 • • 發佈:2018-06-08
AR The 插入 構建 選擇 n個元素 升序 基準 互換
.
冒泡排序: 通過相鄰的兩個數的比較, 根據需要決定是否將兩個數互換位置, 然後將比較往前(或往後)推進. 最簡單的排序算法,直接上代碼。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]View Code 選擇排序: "選擇排序"就是第0個逐步和後面全部的比,比完0位置就得到最小的數,緊接著再從1位置對比後面的元素,以此類推,逐步得到從小到大的值.=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; }View Code 插入排序: 首先對數組的前兩個數據進行從小到大的排序。 接著將第三個數據與排好序的兩個數據比較,將第三個數據插入合適的位置。 然後將第四個數據插入到已排好序的前3個數據中。 ....
// 第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排序算法:(希爾排序、縮小增量排序):
Shell排序是基於插入排序的思想。 1.將有n個元素的數組分成n/2個數字序列,第1個數據和第n/2+1個數據為一對,... 2.一次循環使每一個序列對排好順序。 3.然後,變為n/4個序列,在次排序。 4.直到序列變為1個。 //希爾排序
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;
}
}
}
快速排序算法
1.在待排序的元素任取一個元素作為基準(通常選第一個元素,但最的選擇方法是從待排序元素中隨機選取一個作為基準),稱為基準元素; 2.將待排序的元素進行分區,比基準元素大的元素放在它的右邊,比其小的放在它的左邊; 3.對左右兩個分區重復以上步驟直到所有元素都是有序的。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); //對基準元素右邊的進行遞歸排序
}
}
堆排序算法
堆排序是利用堆這種數據結構而設計的一種排序算法,堆排序是一種選擇排序,它的最壞,最好,平均時間復雜度均為O(nlogn),它也是不穩定排序。首先簡單了解下堆結構。 堆: 堆是具有以下性質的完全二叉樹: 每個結點的值都大於或等於其左右孩子結點的值,稱為大頂堆;或者每個結點的值都小於或等於其左右孩子結點的值,稱為小頂堆。
堆排序的基本思想:將待排序序列構造成一個大頂堆,此時,整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換,此時末尾就為最大值。然後將剩余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;
}
}
歸並排序
歸並排序(MERGE-SORT)是利用歸並的思想實現的排序方法,該算法采用經典的分治(divide-and-conquer)策略(分治法將問題分(divide)成一些小的問題然後遞歸求解,而治(conquer)的階段則將分的階段得到的各答案"修補"在一起,即分而治之)。
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) | 穩定 |
七大經典排序(Java版)