瞬間學會數據結構常用排序算法

本文是在學習中的總結，歡迎轉載但請註明出處：http://blog.csdn.net/pistolove/article/details/40625351

下面是用JAVA代碼實現的數據結構中的7種基本排序算法，希望對你有所幫助。

（1）直接插入排序

	/** 直接插入排序 **/
	/** 數組是引用類型，元素值將被改變 **/
	public static void insertSort(int[] table) {
		/** n-1趟掃描 **/
		for (int i = 1; i < table.length; i++) {
			/** 每趟將table[i]插入到前面已排序的序列中 **/
			int temp = table[i], j;
			/** 將前面較大元素向後移動 **/
			for (j = i - 1; j > -1 && temp < table[j]; j--) {
				table[j + 1] = table[j];
			}
			/** temp值到達插入位置 **/
			table[j + 1] = temp;
		}
	}

（2）希爾排序

<span style="white-space:pre">	</span>/** 希爾排序 **/
	public static void shellSort(int[] table) {
		/** 控制增量，增量減半，若干趟掃描 **/
		for (int delta = table.length / 2; delta > 0; delta /= 2) {
			/** 一趟中若干組，每個元素在自己所屬組內進行直接插入排序 **/
			for (int i = delta; i < table.length; i++) {
				/** 當前待插入元素 **/
				int temp = table[i];
				/** 相距delta遠 **/
				int j = i - delta;
				/** 一組中前面較大的元素向後移動 **/
				/** 繼續與前面的元素比較 **/
				while (j >= 0 && temp < table[j]) {
					table[j + delta] = table[j];
					j -= delta;
				}
				/** 插入元素位置 **/
				table[j + delta] = temp;
			}
		}
	}

（3）冒泡排序

<span style="white-space:pre">	</span>/** 冒泡排序 **/
	public static void bubbleSort(int[] table) {
		/** 是否交換的標記 **/
		boolean exchange = true;
		/** 有交換時再進行下一趟，最多n-1趟 **/
		for (int i = 1; i < table.length && exchange; i++) {
			/** 假定元素未交換 **/
			exchange = false;
			/** 一次比較、交換 **/
			for (int j = 0; j < table.length - i; j++) {
				/** 反序時，交換 **/
				if (table[j] > table[j + 1]) {
					int temp = table[j];
					table[j] = table[j + 1];
					table[j + 1] = temp;
					/** 有交換 **/
					exchange = true;
				}
			}
		}
	}

（4）快速排序

<span style="white-space:pre">	</span>/** 快速排序 **/
	public static void quickSort(int[] table) {
		quickSort(table, 0, table.length - 1);
	}

	/** 一趟快速排序，遞歸算法 **/
	private static void quickSort(int[] table, int low, int high) { // low、high指定序列的下界和上界
		/** 序列有效 **/
		if (low < high) {
			int i = low, j = high;
			/** 第一個值作爲基準值 **/
			int vot = table[i];
			/** 一趟排序 **/
			while (i != j) {
				/** 從後向前尋找較小值 **/
				while (i < j && vot <= table[j])
					j--;
				if (i < j) {
					/** 較小元素向前移動 **/
					table[i] = table[j];
					i++;
				}
				/** 從前向後尋找較大值 **/
				while (i < j && table[i] < vot)
					i++;
				if (i < j) {
					/** 較大元素向後移動 **/
					table[j] = table[i];
					j--;
				}
			}
			/** 基準值的最終位置 **/
			table[i] = vot;
			/** 前端子序列再排序 **/
			quickSort(table, low, j - 1);
			/** 後端子序列再排序 **/
			quickSort(table, i + 1, high);
		}
	}

（5）直接選擇排序

<span style="white-space:pre">	</span>/** 直接選擇排序 **/
	public static void selectSort(int[] table) {
		/** n-1趟排序 **/
		for (int i = 0; i < table.length - 1; i++) {
			/** 每趟在從table[i]開始的子序列中尋找最小元素 **/
			/** 設第i個數據元素最小 **/
			int min = i;
			/** 在子序列中查找最小值 **/
			for (int j = i + 1; j < table.length; j++)
				if (table[j] < table[min])
					/** 記住最小元素下標 **/
					min = j;
			/** 將本趟最小元素交換到前邊 **/
			if (min != i) {
				int temp = table[i];
				table[i] = table[min];
				table[min] = temp;
			}
		}
	}

（6）堆排序

<span style="white-space:pre">	</span>/** 堆排序 **/
	public static void heapSort(int[] table) {
		int n = table.length;
		/** 創建最小堆 **/
		for (int j = n / 2 - 1; j >= 0; j--)
			sift(table, j, n - 1);
		/** 每趟將最小值交換到後面，再調整成堆 **/
		for (int j = n - 1; j > 0; j--) {
			int temp = table[0];
			table[0] = table[j];
			table[j] = temp;
			sift(table, 0, j - 1);
		}
	}

	/** 將以low爲根的子樹調整成最小堆 **/
	private static void sift(int[] table, int low, int high) {
		/** low、high是序列下界和上界 **/
		/** 子樹的根 **/
		int i = low;
		/** j爲i結點的左孩子 **/
		int j = 2 * i + 1;
		/** 獲得第i個元素的值 **/
		int temp = table[i];
		/** 沿較小值孩子結點向下篩選 **/
		while (j <= high) {
			/** 數組元素比較（改成<爲最大堆） **/
			if (j < high && table[j] > table[j + 1])
				/** j爲左右孩子的較小者 **/
				j++;
			/** 若父母結點值較大（改成<爲最大堆） **/
			if (temp > table[j]) {
				/** 孩子結點中的較小值上移 **/
				table[i] = table[j];
				/** i、j向下一層 **/
				i = j;
				j = 2 * i + 1;
			} else
				j = high + 1;
		}
		/** 當前子樹的原根值調整後的位置 **/
		table[i] = temp;
	}

（7）歸併排序

<span style="white-space:pre">	</span>/** 歸併排序 **/
	public static void mergeSort(int[] X) {
		/** 已排序的子序列長度，初值爲1 **/
		int n = 1;
		/** Y數組長度同X數組 **/
		int[] Y = new int[X.length];
		do {
			/** 一趟歸併，將X數組中各子序列歸併到Y中 **/
			mergepass(X, Y, n);
			/** 子序列長度加倍 **/
			n *= 2;

			if (n < X.length) {
				/** 將Y數組中各子序列再歸併到X中 **/
				mergepass(Y, X, n);
				n *= 2;
			}
		} while (n < X.length);
	}

	/** 一趟歸併 **/
	private static void mergepass(int[] X, int[] Y, int n) {
		int i = 0;
		while (i < X.length - 2 * n + 1) {
			merge(X, Y, i, i + n, n);
			i += 2 * n;
		}
		if (i + n < X.length)
			/** 再一次歸併 **/
			merge(X, Y, i, i + n, n);
		else
			/** 將X剩餘元素複製到Y中 **/
			for (int j = i; j < X.length; j++)
				Y[j] = X[j];
	}

	/** 一次歸併 **/
	private static void merge(int[] X, int[] Y, int m, int r, int n) {
		int i = m, j = r, k = m;
		/** 將X中兩個相鄰子序列歸併到Y中 **/
		while (i < r && j < r + n && j < X.length)
			/** 較小值複製到Y中 **/
			if (X[i] < X[j])
				Y[k++] = X[i++];
			else
				Y[k++] = X[j++];
		/** 將前一個子序列剩餘元素複製到Y中 **/
		while (i < r)
			Y[k++] = X[i++];
		/** 將後一個子序列剩餘元素複製到Y中 **/
		while (j < r + n && j < X.length)
			Y[k++] = X[j++];
	}