1/排序算法：冒泡排序bubble sort，插入排序 insertion sort，選擇排序 selection sort，快速排序 quick sort，歸並排序 merge sort;堆排序 heap sort---基於排序

桶排序bucket sort 一種特殊情況下的排序。

2/實現

1）冒泡排序bubble sort：從位置0開始，一次比較到length - 0，前面大交換;再從位置1開始，依次類推。

 1 public void bubbleSort(int[] nums) {
 2        for (int i = 0; i < nums.length; i++) {
 3
 
          for (int j = 1; j < nums.length - i; j++) {
 4              if (num[j - 1] > nums[j]) {
 5                  swap(nums, j - 1, j);
 6              }
 7          }
 8      }
 9 }
10 
11 public void swap(int[] nums, int i , int j) {
12    int temp = nums[i];
13    nums[i] = nums[j];
14    nums[j] = temp;
 
15 }

冒泡排序有一個優化算法，就是在一個排好序的數組，一輪比較沒有swap，則是排好序的，那麽直接返回

 1  1 public void bubbleSort(int[] nums) {
 2  2    for (int i = 0; i < nums.length; i++) {
 3            boolean isSwap = false;
 4  3        for (int j = 1; j < nums.length - i; j++) {
 5  4             if (num[j - 1] > nums[j]) {
 6  5                  swap(nums, j - 1, j);
 
 7                      isSwap = true;
 8  6              }
 9  7          }
10              if (!isSwap) {
11                 return;
12              }
13  8      }
14  9 }
15 10 
16 11 public void swap(int[] nums, int i , int j) {
17 12    int temp = nums[i];
18 13    nums[i] = nums[j];
19 14    nums[j] = temp;
20 15 }

2）插入排序insertion sort：先把前i個數字排好序，然後再把前i+1個數字排好序。

 1 public void insertSort(int[] nums) {
 2     for (int i = 1; i < nums.length; i++) {
 3         for (int j = i; j > 0; j --) {
 4             if (nums[j - 1] > nums[j ]) {
 5                 swap(nums, j - 1; j);
 6             }
 7         }
 8     }
 9 }
10 
11 public void swap(int[] nums, int i, int j) {
12    int temp = nums[i];
13    nums[i] = nums[j];
14    nums[j] = temp;
15 }

3)選擇排序selection sort：先從N裏面選出最小的一個值，與0位置數字交換，再從剩下數字裏面選出最小的值跟1位置交換。依次類推。

 1 public void selectionSort(int[] nums) {
 2    for (int i = 0; i < nums.length - 1; i++) {//i < nums.length -1,j要從i + 1開始
 3        int min = nums[i];
 4        int minIndex = i;
 5         for (int j = i + 1; j > nums.length; j++) {
 6             if (num[j] < min) {
 7                 min = num[j];
 8                 minIndex = j;
 9             }
10         }
11         num[minIndex] = num[i];
12         nums[i] = min;
13    }
14 }

4)快速排序quick sort：

 1 public void quickSort(int[] nums) {
 2     sort(nums, 0, nums.length);
 3 }
 4 
 5 publc void sort(int[] nums, int begin, int end) {
 6     if (begin >= end) {
 7         return;
 8     }
 9     int pivotIndex = partition(nums, begin, end);
10     sort(nums, begin, pivotIndex - 1);//pivot已經就位，所以跳過
11     sort(nums, pivotIndex + 1, end);
12 }
13 
14 public partition(int[] nums, int begin, int end) {
15     int pivot = num[begin];
16     while (begin < end) {
17         while (begin < end && num[end] > pivot) {
18              end--;
19         }
20         nums[begin] = nums[end];
21         while (begin < end && nums[begind] <= pivot) {
22               begin++;
23         }
24         nums[end] = nums[begin];
25     }
26     nums[begin] = pivot;
27     return begin;
28 }        

Lecture--9 Sorting