常見經典排序算法的java實現

public class Sort {
	// =======================選擇排序Begin========================
	void select_sort(int[] array) {

		for (int i = 0; i < array.length - 1; i++) {
			int minIndex = i;

			for (int j = i + 1; j < array.length; j++) {

				if (array[minIndex] > array[j]) {
					minIndex = j;
				}
			}

			if (minIndex != i) {
				int temp = array[minIndex];
				array[minIndex] = array[i];
				array[i] = temp;
			}
		}
	}

	// =======================選擇排序End===========================
	// =======================冒泡排序——大泡下沉Begin=============
	void bubble_sort(int[] array) {

		for (int i = array.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				int temp = 0;
				if (array[j] > array[j + 1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	// ======================冒泡排序——大泡下沉End================
	// ======================冒泡排序——小泡上浮Begin==============
	void bubbleSort(int[] array) {

		for (int i = 0; i < array.length; i++) {
			for (int j = array.length - 1; j > i; j--) {
				int temp = 0;
				if (array[j] < array[j - 1]) {
					temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
				}
			}
		}
	}

	// ======================冒泡排序——小泡上浮End================
	// ======================直接插入排序Begin======================
	void insertion_sort(int[] unsorted) {
		for (int i = 1; i < unsorted.length; i++) {
			if (unsorted[i - 1] > unsorted[i]) {
				int temp = unsorted[i];
				int j = i;
				while (j > 0 && unsorted[j - 1] > temp) {
					unsorted[j] = unsorted[j - 1];
					j--;
				}
				unsorted[j] = temp;
			}
		}
	}

	// =======================直接插入排序End======================

	// ========================快速排序1Begin======================
	int partition(int[] unsorted, int low, int high) {

		int pivot = unsorted[low];

		while (low < high) {

			while (low < high && unsorted[high] > pivot)
				high--;

			unsorted[low] = unsorted[high];

			while (low < high && unsorted[low] <= pivot)
				low++;

			unsorted[high] = unsorted[low];
		}

		unsorted[low] = pivot;

		return low;
	}

	void quick_sort(int[] unsorted, int low, int high) {

		int loc = 0;

		if (low < high) {

			loc = partition(unsorted, low, high);

			quick_sort(unsorted, low, loc - 1);

			quick_sort(unsorted, loc + 1, high);
		}
	}

	// =======================快速排序1End========================

	// =======================快速排序2Begin======================

	// 快速排序一次劃分
	int Partition(int r[], int first, int end) {
		int i = first; // 初始化
		int j = end;
		int temp;

		while (i < j) {
			while (i < j && r[i] <= r[j])
				j--; // 右側掃描
			if (i < j) {
				temp = r[i]; // 將較小記錄交換到前面
				r[i] = r[j];
				r[j] = temp;
				i++;
			}
			while (i < j && r[i] <= r[j])
				i++; // 左側掃描
			if (i < j) {
				temp = r[j];
				r[j] = r[i];
				r[i] = temp; // 將較大記錄交換到後面
				j--;
			}
		}
		return i; // i爲軸值記錄的最終位置
	}

	// 快速排序
	void QuickSort(int r[], int first, int end) {
		if (first < end) { // 遞歸結束
			int pivot = Partition(r, first, end); // 一次劃分
			QuickSort(r, first, pivot - 1); // 遞歸地對左側子序列進行快速排序
			QuickSort(r, pivot + 1, end); // 遞歸地對右側子序列進行快速排序
		}

	}

	// =======================快速排序2End========================

	// =======================堆排序1Begin========================
	// array是待調整的堆數組,i是待調整的數組元素的位置,length是數組的長度
	void HeapAdjust(int array[], int i, int nLength) {
		int nChild, nTemp;

		for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild) {

			// 子結點的位置是 父結點位置 * 2 和父節點位置*2+1 // 修改處
			nChild = 2 * i + 1;

			// 得到子結點中較大的結點
			if (nChild != nLength - 1 && array[nChild + 1] > array[nChild])
				++nChild;

			// 如果較大的子結點大於父結點那麼把較大的子結點往上移動,替換它的父結點
			if (nTemp < array[nChild]) {
				array[i] = array[nChild];
			} else // 否則退出本次循環
			{
				break;
			}
		}

		// 最後把需要調整的元素值放到合適的位置
		array[i] = nTemp;
	}

	// 堆排序算法
	void HeapSort(int array[], int length) {

		// 調整序列的前半部分元素,調整完之後第一個元素是序列的最大的元素
		for (int i = length / 2 - 1; i >= 0; --i) {
			HeapAdjust(array, i, length);
		}

		// 從最後一個元素開始對序列進行調整,不斷的縮小調整的範圍直到第一個元素4
		for (int i = length - 1; i > 0; --i) {

			// 把第一個元素和當前的最後一個元素交換,保證當前的最後一個位置的元素都是在現在的這個序列之中最大的
			int tem = array[0];
			array[0] = array[i];
			array[i] = tem;

			// 不斷縮小調整heap的範圍,每一次調整完畢保證第一個元素是當前序列的最大值
			HeapAdjust(array, 0, i);
		}
	}

	// =========================堆排序1End==============================

	// =========================堆排序2Begin============================
	void heapAdjust(int a[], int i, int n) {
		int tem;
		int min_p = 2 * i;
		if (2 * i < n) {
			min_p = 2 * i;
		}
		if (2 * i + 1 < n) {
			if (a[2 * i + 1] > a[2 * i]) {
				min_p = 2 * i + 1;
			}
		}
		if (a[min_p] > a[i]) {
			tem = a[min_p];
			a[min_p] = a[i];
			a[i] = tem;
			if (2 * min_p < n)
				heapAdjust(a, min_p, n);
		}

	}

	void Heap_sort(int a[], int n) {
		int i, tem;
		for (i = n / 2 - 1; i >= 0; i--) {
			heapAdjust(a, i, n);
		}
		for (i = 0; i < n - 1; i++) {
			tem = a[0];
			a[0] = a[n - i - 1];
			a[n - i - 1] = tem;
			heapAdjust(a, 0, n - i - 1);
		}
	}

	// ========================堆排序2End========================

	// ========================基數排序Begin=====================
	/**
	 * 基數排序 結合桶式排序，分兩種從高位到低位和從低位到高位。案例代碼爲從低位到高位 第一步：得到數組內最大位數 第二步：進行多次
	 * 桶式排序，次數爲排序最大數字的位數 例子：52,38,23,72,271 第一步：數組元素最大位數爲3,
	 * 第二步：第一次桶式排序，針對數組元素的個位：排序結果爲：271，52,72,23,38，按個位桶式排序就完成了 繼續：
	 * 第二次桶式排序，按照數組元素的十位：排序結果爲：23,38,52,271,72 繼續：
	 * 第三次桶式排序，按照數組元素的百位：排序結果爲：23,38,52,72,271 排序完成。
	 * 
	 * @author
	 * 
	 */
	void radixSort(int[] array) {
		int maxW = 0;
		int index = 0;

		// 第一步：得到數組內最大元素的位數
		for (int i = 0; i < array.length; i++) {
			if (maxW < array[i]) {
				maxW = array[i];
			}
		}

		maxW = getNumberLength(maxW);

		// 第二步：進行多次 桶式排序，次數爲排序最大數字的位數
		while (index < maxW) {
			int[] tempArray = new int[array.length];
			int[] bucketArray = new int[10];
			System.arraycopy(array, 0, tempArray, 0, array.length);
			for (int i = 0; i < array.length; i++) {
				bucketArray[getNumberIndex(index, array[i])]++;
			}

			for (int i = 1; i < bucketArray.length; i++) {
				bucketArray[i] = bucketArray[i] + bucketArray[i - 1];
			}
			for (int i = array.length - 1; i >= 0; i--) {
				array[--bucketArray[getNumberIndex(index, tempArray[i])]] = tempArray[i];
			}
			index++;
		}
	}

	int getNumberIndex(int index, int number) {
		int num = 0;
		num = (int) (number / Math.pow(10, index)) % 10;
		return num;
	}

	int getNumberLength(int number) {
		int count = 1;
		int index = 1;
		while ((number - Math.pow(10, index)) > 0) {// Math.pow(x,y)計算x的y次冪
			count++;
			index++;
		}
		return count;
	}

	// =======================基數排序End==========================

	// =======================歸併排序Begin========================
	//將有二個有序數列a[first...mid]和a[mid...last]合併。 
	void merge(int[] unsorted, int first, int mid, int last, int[] sorted) {
	int i = first, j = mid;
		int k = 0;
		while (i < mid && j < last)
			if (unsorted[i] < unsorted[j]) {
				sorted[k++] = unsorted[i++];
			} else if (unsorted[i] > unsorted[j]) {
				sorted[k++] = unsorted[j++];
			} else {
				sorted[k++] = unsorted[i++];
				sorted[k++] = unsorted[j++];
			}
		while (i < mid)
			sorted[k++] = unsorted[i++];
		while (j < last)
			sorted[k++] = unsorted[j++];

		for (int v = 0; v < k; v++)
			unsorted[first + v] = sorted[v];
	}

	void merge_sort(int[] unsorted, int first, int last, int[] sorted) {
		if (first + 1 < last) {
			int mid = (first + last) / 2;
			merge_sort(unsorted, first, mid, sorted);//左邊有序 
			merge_sort(unsorted, mid, last, sorted);//右邊有序
			merge(unsorted, first, mid, last, sorted);//再將二個有序數列合併 
		}
	}

	// =========================歸併排序End========================

	// =========================希爾排序Begin======================
	void shell_sort(int[] array) {
		int groupLen = 0;
		int len = array.length;
		for (groupLen = len / 2; groupLen > 0; groupLen /= 2) {
			for (int i = 0; i < len - groupLen; i++) {
				for (int j = i; j < len - groupLen; j += groupLen) {
					if (array[j] > array[j + groupLen]) {
						int temp = array[j];
						array[j] = array[j + groupLen];
						array[j + groupLen] = temp;
					}
				}
			}
		}
	}

	// =====================希爾排序End==========================

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Sort sort = new Sort();

		System.out
				.println("*********************選擇排序*********************");
		int[] selectArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.select_sort(selectArray);
		print(selectArray);

		System.out
				.println("*********************冒泡排序**********************");
		int[] bubbleArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.bubble_sort(bubbleArray);
		// sort.bubbleSort(bubbleArray);
		print(bubbleArray);

		System.out
				.println("*********************直接插入排序******************");
		int[] x = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.insertion_sort(x);
		print(x);

		System.out
				.println("*********************快速排序**********************");
		int[] quickArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		// sort.quick_sort(x, 0, x.length - 1);
		sort.QuickSort(quickArray, 0, quickArray.length - 1);
		print(quickArray);

		System.out
				.println("*********************堆排序************************");
		int a[] = { 71, 18, 151, 138, 160, 63, 174, 169, 79, 78 };
		sort.HeapSort(a, a.length);
		// sort.Heap_sort(a, a.length);
		print(a);

		System.out
				.println("*********************基數排序***********************");
		int[] array = new int[] { 51, 82, 23, 94, 35, 76, 117, 238, 909, 40, 11 };
		sort.radixSort(array);
		print(array);

		System.out
				.println("*********************歸併排序***********************");
		int[] mergeArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		int[] sorted = new int[mergeArray.length];
		sort.merge_sort(mergeArray, 0, mergeArray.length, sorted);
		print(mergeArray);

		System.out
				.println("*********************希爾排序***********************");
		int[] shellArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.shell_sort(shellArray);
		print(shellArray);
	}

	static void print(int[] a) {
		for (int i = 0; i < a.length; i++) {
			if (i == a.length - 1)
				System.out.println(a[i]);
			else
				System.out.print(a[i] + ",");
		}
		System.out
				.println("**********************end****************************");
	}
}

遞歸排序的示例圖：