java常见的排序算法_常见排序算法及Java实现
先上個總圖↓：
①、直接插入排序
插入排序(Insertion Sort)的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。插入排序在實現上，通常采用in-place排序(即只需用到O(1)的額外空間的排序)，因而在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
步驟：
1、從第一個元素開始，該元素可以認為已經被排序
2、取出下一個元素，在已經排序的元素序列中從后向前掃描
3、如果該元素(已排序)大于新元素，將該元素移到下一位置
4、重復步驟3，直到找到已排序的元素小于或者等于新元素的位置
5、將新元素插入到該位置中
6、重復步驟2
排序效果：
/*插入排序*/
private static > voidinsertSort(T[] a) {for (int i = 1; i < a.length; i++) {
T tmp=a[i];int j =i;for (; j > 0 && tmp.compareTo(a[j - 1]) < 0; j--) {
a[j]= a[j - 1];
}
a[j]=tmp;
}
}
②、希爾排序
希爾排序，也稱遞減增量排序算法，是插入排序的一種高速而穩定的改進版本。
希爾排序是基于插入排序的以下兩點性質而提出改進方法的：
1、插入排序在對幾乎已經排好序的數據操作時， 效率高， 即可以達到線性排序的效率
2、但插入排序一般來說是低效的， 因為插入排序每次只能將數據移動一位
排序效果：
/*希爾排序*/
private static > voidshellSort(T[] a) {for (int gap = a.length / 2; gap > 0; gap = gap == 2 ? 1 : (int) (gap / 2.2)) {for (int i = gap; i < a.length; i++) {
T tmp=a[i];int j =i;for (; j >= gap && tmp.compareTo(a[j - gap]) < 0; j -=gap)
a[j]= a[j -gap];
a[j]=tmp;
}
}
}
③、選擇排序
選擇排序(Selection sort)是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小元素，然后放到排序序列末尾。以此類推，直到所有元素均排序完畢。
排序效果：
/*選擇排序*/
private static > voidselectSort(T[] a) {intminIndex;
T temp;for (int i = 0; i < a.length; i++) {
minIndex=i;for (int j = i + 1; j < a.length; j++) {if (a[j].compareTo(a[minIndex]) < 0)
minIndex=j;
}if (minIndex !=i) {
temp=a[i];
a[i]=a[minIndex];
a[minIndex]=temp;
}
}
}
④、堆排序
堆積排序(Heapsort)是指利用堆這種數據結構所設計的一種排序算法。堆是一個近似完全二叉樹的結構，并同時滿足堆性質：即子結點的鍵值或索引總是小于(或者大于)它的父節點。
排序效果：
/*堆排序*/
public void heapSort(int[] arr) {int len =arr.length;int[] a = new int[len + 1];
a[0] = 0;for (int i = 0; i < len; i++) {
a[i+ 1] =arr[i];
}int[] ans = sort(a, len + 1);//copy the answer
for (int i = 0; i < len; i++) {
arr[i]= ans[i + 1];
}
}private int[] sort(int[] arr, intlen) {intindex ;int[] ans =arr;for (int i = len; i > 0; i--) {
index= (i - 1) / 2;
ans=buildHeap(ans, index, i);if ((i - 1) > 0 && ans[1] > ans[i - 1]) {
swap(ans,1, i - 1);
}
}returnans;
}//建大頂堆
private int[] buildHeap(int[] arr, int parent, intlen) {intleft, right;while (parent > 0) {
left= 2 *parent;
right= left + 1;if (right
swap(arr, parent, right);
}
}if (left
swap(arr, parent, left);
}
}
parent--;
}returnarr;
}private void swap(int[] arr, int a, intb) {
arr[0] =arr[a];
arr[a]=arr[b];
arr[b]= arr[0];
}
⑤、冒泡排序
冒泡排序(Bubble Sort，臺灣譯為：泡沫排序或氣泡排序)是一種簡單的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
步驟：
1、比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
3、針對所有的元素重復以上的步驟，除了最后一個。
4、持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
排序效果：
/*冒泡排序*/
public static > voidbubSort(T[] a) {
T temp;for (int i = 0; i < a.length - 1; i++) {for (int j = 0; j < a.length - 1 - i; j++) {if (a[j].compareTo(a[j + 1]) > 0) {
temp=a[j];
a[j]= a[j + 1];
a[j+ 1] =temp;
}
}
}
}
⑥、快速排序
快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他Ο(n log n) 算法更快，因為它的內部循環(inner loop)可以在大部分的架構上很有效率地被實現出來，且在大部分真實世界的數據，可以決定設計的選擇，減少所需時間的二次方項之可能性。
步驟：
1、從數列中挑出一個元素，稱為 “基準”(Pivot)，
2、重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面(相同的數可以到任一邊)。在這個分區退出之后，該基準就處于數列的中間位置。這個稱為分區(partition)操作。
3、遞歸地(recursive)把小于基準值元素的子數列和大于基準值元素的子數列排序。
排序效果：
/*快速排序*/
public static > voidquickSort(T[] a) {
quickSort(a,0, a.length - 1);
}private static > void quickSort(T[] a, int low, inthigh) {inti, j;
T choosen;if (low >high)return;
i=low;
j=high;
choosen=a[j];while (i
i++;if (i
a[j--] =a[i];while (i < j && a[j].compareTo(choosen) >= 0)
j--;if (i
a[i++] =a[j];
}
a[j]=choosen;
quickSort(a, low, i- 1);
quickSort(a, i+ 1, high);
}
⑦、歸并排序
歸并排序(Merge sort，也稱：合并排序)是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法(Divide and Conquer)的一個非常典型的應用。
步驟：
1、申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列
2、設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
3、比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置
4、重復步驟3直到某一指針達到序列尾
5、將另一序列剩下的所有元素直接復制到合并序列尾
排序效果：
/*歸并排序*/
private static > voidmergeSort(T[] a) {
T[] temp= (T[]) newComparable[a.length];
mergeSort(a, temp,0, a.length - 1);
}private static >
void mergeSort(T[] a, T[] temp, int left, intright) {if (left
mergeSort(a, temp, left, center);
mergeSort(a, temp, center+ 1, right);
merge(a, temp, left, center+ 1, right);
}
}private static >
void merge(T[] a, T[] temp, int leftPos, int rightPos, intrightEnd) {int leftEnd = rightPos - 1;int tempPos =leftPos;int numElements = rightEnd - leftPos + 1;while (leftPos <= leftEnd && rightPos <=rightEnd) {if (a[leftPos].compareTo(a[rightPos]) <= 0)
temp[tempPos++] = a[leftPos++];elsetemp[tempPos++] = a[rightPos++];
}while (leftPos <=leftEnd)
temp[tempPos++] = a[leftPos++];while (rightPos <=rightEnd)
temp[tempPos++] = a[rightPos++];for (int i = 0; i < numElements; i++, rightEnd--)
a[rightEnd]=temp[rightEnd];
}
THE END.
總結
以上是生活随笔為你收集整理的java常见的排序算法_常见排序算法及Java实现的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java secretkey_Java中
- 下一篇： java snychronized_Ja