首先我們貼出來快速排序的代碼
public class QuickSort {
public int QuickSort(int[] a, int left, int right) {
int temp = a[left];
while(left < right)
{
while(left < right && a[right] >= temp)
{
right--;
}
if(left < right && a[right] < temp)
{
a[left] = a[right];
}
while(left < right && a[left] <= temp)
{
left++;
}
if(left < right && a[left] > temp)
{
a[right] = a[left];
}
}
a[left] = temp;
return left;
}
public void partion(int a[], int left, int right) {
int num;
if(left < right)
{
num = QuickSort(a, left, right);
partion(a, left, num-1);
partion(a, num + 1, right);
}
}
public static void main(String[] args) {
int a[] = {7, 2, 3, 8, 9, 6, 5, 1, 4};
QuickSort test = new QuickSort();
test.partion(a, 0, 8);
for(int i = 0; i < 9; i++)
{
System.out.print(a[i]);
}
}
}
其次我們貼出歸併排序的代碼
public class MergeSort {
public void merge(int[] a, int left, int right) {
if(left + 1< right) {
int mid = (left + right) / 2;
merge(a, left, mid);
merge(a, mid, right);
mergesort(a, left, mid, right);
}
}
public void mergesort(int[] a, int left, int mid, int right) {
int testl[] = new int[10000];
int testr[] = new int[10000];
int n1 = mid - left;
int n2 = right - mid;
testl[n1] = Integer.MAX_VALUE;
testr[n2] = Integer.MAX_VALUE;
int num = right - left;
for(int i = 0; i < n1; i++) testl[i] = a[left + i];
for(int i = 0; i < n2; i++) testr[i] = a[mid + i];
int i = 0;
int j = 0;
for(int k = left; k < right; k++)
{
if(testl[i] < testr[j])
{
a[k] = testl[i];
i++;
}
else
{
a[k] = testr[j];
j++;
}
}
}
public static void main(String[] args) {
int[] a = {7, 2, 3, 8, 9, 6, 5, 1, 4};
MergeSort test = new MergeSort();
test.merge(a, 0, 9);
for(int i = 0; i < 9; i++)
System.out.print(a[i]);
}
}
閱讀完這兩個代碼，我們可以發現這兩種排序都存在遞歸，而差別則在於它們遞歸的順序。
歸併排序：是先遞歸在排序
快速排序：是先找到分割的標誌來將數組進行大致的切割（標誌的左邊都是小於標誌的值，右邊都是大於標誌的值），然後再進行遞歸
當然這兩種排序的時間複雜度和空間複雜度也不相同
快速排序的時間複雜度爲最快情況爲O(nlogn),最壞情況爲O(n*n),小計快速排序是冒泡排序的思想改進，快速排序是從整體到部分再到個體，而冒泡排序則是一個個個體去比較，所以快速排序更爲高級，當然因爲追求過快，而導致不穩定，最壞情況的出發條件則是一個有序的數組，且取得標誌爲數組的最大值或者最小值，這種情況也可能會導致棧遞歸過深，導致棧溢出，空間複雜度O(logn)；
歸併排序的時間複雜度最好情況最壞情況都爲O(nlogn)。空間複雜度O(n)。