在算法系列（三）排序演算法上篇 一文中，介紹了氣泡排序，插入排序和選擇排序演算法。這篇文章繼續講解排序演算法。

概述

歸併排序

基本原理

具體過程

程式碼實現

（比較容易理解，但是寫的不是很好，合併方法可以優化）

package com.algorithm.sort;

/**
 * 歸併排序
 * 
 * @author chao
 *
 */
public class MergeSort {
	/**
	 * 歸併排序
	 * 
	 * @param num
	 * @param start
	 * @param end
	 */
	public static void sort(int num[], int start, int end) {
		if (start >= end) {
			return;
		}
		int mid = (start + end) / 2;
		sort(num, start, mid);
		sort(num, mid + 1, end);
		merge(num, start, mid, end);

	}

	/**
	 * num[start]到num[mid]是有序的，num[mid+1]到num[end]是有序的，
	 * 重新合併陣列，使陣列num[start]到num[end]有序
	 * 
	 * @param num
	 * @param start
	 * @param mid
	 * @param end
	 */
	public static void merge(int[] num, int start, int mid, int end) {
		int[] num1 = new int[mid - start + 1];
		int[] num2 = new int[end - mid];
		int i, j, k;
		for (i = start; i <= end; i++) {
			if (i - start < num1.length) {
				num1[i - start] = num[i];
			} else {
				num2[i - start - num1.length] = num[i];
			}
		}
		i = j = k = 0;
		while (i < num1.length && j < num2.length) {
			if (num1[i] <= num2[j]) {
				num[start + k++] = num1[i++];
			} else {
				num[start + k++] = num2[j++];
			}
		}

		while (i < num1.length) {
			num[start + k++] = num1[i++];
		}
		while (j < num2.length) {
			num[start + k++] = num2[j++];
		}
	}

	public static void main(String[] args) {
		int[] num = { 1, 5, 3, 2 };
		sort(num, 0, num.length - 1);
		for (int i = 0; i < num.length; i++)
			System.out.print(num[i] + " ");
	}
}
 

時間複雜度

快速排序

基本原理

具體過程
待排序的陣列A的值分別是：（初始關鍵資料X=49）
                   A[0]     A[1]     A[2]     A[3]     A[4]      A[5]     A[6]：
                     49        38       65       97       76       13        27
進行第一次交換後：   27        38       65       97       76       13        49
                   ( 按照演算法的第三步從後面開始找)
進行第二次交換後：   27        38       49       97       76       13        65
                  ( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )
進行第三次交換後：   27        38       13       97       76       49        65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找)
進行第四次交換後：   27        38       13       49       76       97        65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J=4 )
此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：
27        38       13       49       76       97        65，
即所有大於49的數全部在49的後面，所有小於49的數全部在49的前面。

程式碼實現

package com.algorithm.sort;

/**
 * 快速排序
 * 
 * @author chao
 *
 */
public class QuickSort {
	/**
	 * 快速排序
	 * 
	 * @param num
	 * @param left
	 * @param right
	 */
	public static void sort(int[] num, int left, int right) {
		if (left < right) {
			int dp = partition(num, left, right);
			sort(num, left, dp - 1);
			sort(num, dp + 1, right);
		}
	}

	/**
	 * 資料分組
	 * 
	 * @param num
	 * @param left
	 * @param right
	 */
	public static int partition(int[] num, int left, int right) {
		int pivot = num[left];
		while (left < right) {
			while (left < right && num[right] >= pivot)
				right--;
			if (left < right)
				num[left++] = num[right];
			while (left < right && num[left] <= pivot)
				left++;
			if (left < right)
				num[right--] = num[left];
		}
		num[left] = pivot;
		return left;
	}

	public static void main(String[] args) {
		int[] num = { 1, 5, 3, 2 };
		sort(num, 0, num.length - 1);
		for (int i = 0; i < num.length; i++)
			System.out.print(num[i] + " ");

	}

}

複雜度分析

演算法實現程式碼github地址為我的github

後續會不斷補充，有些地方寫的可能有問題，請多指教。

歡迎掃描二維碼，關注公眾賬號