Java排序：冒泡排序、快速排序、堆排序

冒泡排序：
 一趟排序：將第一個記錄和第二個記錄進行比較，如果第一個比第二個大就兩個記錄交換，直到第n-1個記錄和第n個記錄比較爲止。
  之後的排序對前n-1個記錄進行同樣操作。

  時間複雜度爲O(n^2)

每一趟排序就是把最大的數放到最後面。

快速排序：
 一趟交換：設兩個指針low和high，設樞軸記錄爲pivotkey，從high所指的位置向前搜索找到第一個關鍵詞小於pivotkey的記錄和樞軸記錄相互交換，
 從low所值位置向後搜索，找到第一個關鍵字大於pivotkey的記錄和樞軸記錄交換。直到low=high。

 時間複雜度爲O(nlogn)，當初始記錄爲有序或基本有序時時間複雜度蛻變成冒泡排序，時間複雜度爲O(n)

把數組切分成兩個部分，一邊比pivotkey大，一邊比pivotkey小。用遞歸把兩個部分再分別排序。

堆排序：
* 在輸出堆頂的最小值之後，使得剩餘n-1個元素的序列重新建成一個堆，則達到n個元素中的此校元素。反覆執行。
* 在最壞的情況下時間複雜度也爲O(nlogn)
* 對記錄數較少的文件不值得體長，對n較大的文件還是很有效的

構建一個大頂堆
* 先選一個關鍵字爲最大的記錄並於序列中最後一個記錄交換，然後對序列中前n-1記錄進行篩選，重新調整爲一個大頂堆
* 對於使用數組表示二叉樹還需要再進行復習

/**
	 * 冒泡排序
	 * 一趟排序：將第一個記錄和第二個記錄進行比較，如果第一個比第二個大就兩個記錄交換，直到第n-1個記錄和第n個記錄比較爲止。
	 * 之後的排序對前n-1個記錄進行同樣操作。
	 * 時間複雜度爲O(n^2)
	 * @param nums
	 */
	public static void BubbleSrot(int[] nums) {
		//控制排序的趟數
		for (int i = 0; i < nums.length - 1; i++) {
			//控制每一趟排序多少次
			for (int j = 0; j < nums.length - 1 - i; j++) {
				if (nums[j] > nums[j + 1]) {
					int temp = nums[j + 1];
					nums[j + 1] = nums[j];
					nums[j] = temp;
				}
			}
		}
	}
	/**
	 * 快速排序
	 * 一趟交換：設兩個指針low和high，設樞軸記錄爲pivotkey，從high所指的位置向前搜索找到第一個關鍵詞小於pivotkey的記錄和樞軸記錄相互交換，
	 * 從low所值位置向後搜索，找到第一個關鍵字大於pivotkey的記錄和樞軸記錄交換。直到low=high。
	 * 時間複雜度爲O(nlogn)，當初始記錄爲有序或基本有序時時間複雜度蛻變成冒泡排序，時間複雜度爲O(n)
	 * @param nums
	 */
	public static void QuickSort(int[] nums) {
		QuickSort(nums, 0, nums.length - 1);
	}

	private static void QuickSort(int[] nums, int low, int high) {
		int begin = low, end = high;
		// 一趟交換
		// 將數組中第一個做爲樞軸記錄
		int pivotkey = nums[begin];
		while (begin < end) {
			// 比樞軸記錄小的數值移動到低端
			while (begin < end && nums[end] >= pivotkey) {
				--end;
			}
			nums[begin] = nums[end];
			// 比樞軸記錄大的數值移動到高端
			while (begin < end && nums[begin] <= pivotkey) {
				++begin;
			}
			nums[end] = nums[begin];
		}
		// 將樞軸記錄補充到low的位置上
		nums[begin] = pivotkey;
		// 一趟交換結束

		// 遞歸
		// 遞歸排序左邊
		if (low < end) {
			QuickSort(nums, low, end - 1);
		}
		// 遞歸排序右邊
		if (begin < high) {
			QuickSort(nums, begin + 1, high);
		}
	}
	/**
	 * 堆排序
	 * 在輸出堆頂的最小值之後，使得剩餘n-1個元素的序列重新建成一個堆，則達到n個元素中的此校元素。反覆執行。
	 * 在最壞的情況下時間複雜度也爲O(nlogn)
	 * 對記錄數較少的文件不值得體長，對n較大的文件還是很有效的
	 * @param nums
	 */
	public static void HeapSort(int[] nums){
		for(int i = nums.length/2;i>=0;--i){
			HeapAdjust(nums,i,nums.length);
		}
		for(int i = nums.length-1;i>=0;--i){
			int temp = nums[i];
			nums[i] = nums[0];
			nums[0] = temp;
			HeapAdjust(nums,0,i-1);
		}
	}
	/**
	 * 構建一個大頂堆
	 * 先選一個關鍵字爲最大的記錄並於序列中最後一個記錄交換，然後對序列中前n-1記錄進行篩選，重新調整爲一個大頂堆
	 * 對於使用數組表示二叉樹還需要再進行復習
	 * @param nums
	 * @param s
	 * @param len
	 */
	private static void HeapAdjust(int[] nums ,int s ,int len){
		System.out.println(Arrays.toString(nums));
		int r = nums[s];
		for(int j = 2 * s;j<len;j*=2){
			if(j<len&&nums[j]<nums[j+1]){
				++j;
			}
			if(r>=nums[j]) break;
			nums[s] = nums[j];
			s = j;
		}
		nums[s]=r;
	}