Lecture--9 Sorting

1/排序算法：冒泡排序bubble sort，插入排序 insertion sort，选择排序 selection sort，快速排序 quick sort，归并排序 merge sort;堆排序 heap sort---基于排序

桶排序bucket sort  一种特殊情况下的排序。

2/实现

1）冒泡排序bubble sort：从位置0开始，一次比较到length - 0，前面大交换;再从位置1开始，依次类推。

 public void bubbleSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
          for (int j = 1; j < nums.length - i; j++) {
              if (num[j - 1] > nums[j]) {
                  swap(nums, j - 1, j);
              }
          }
      }
 }

 public void swap(int[] nums, int i , int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
 }

冒泡排序有一个优化算法，就是在一个排好序的数组，一轮比较没有swap，则是排好序的，那么直接返回

  1 public void bubbleSort(int[] nums) {
  2    for (int i = 0; i < nums.length; i++) {
            boolean isSwap = false;
  3        for (int j = 1; j < nums.length - i; j++) {
  4             if (num[j - 1] > nums[j]) {
  5                  swap(nums, j - 1, j);
                      isSwap = true;
  6              }
  7          }
              if (!isSwap) {
                 return;
              }
  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 }

2）插入排序insertion sort：先把前i个数字排好序，然后再把前i+1个数字排好序。

 public void insertSort(int[] nums) {
     for (int i = 1; i < nums.length; i++) {
         for (int j = i; j > 0; j --) {
             if (nums[j - 1] > nums[j ]) {
                 swap(nums, j - 1; j);
             }
         }
     }
 }

 public void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
 }

3)选择排序selection sort：先从N里面选出最小的一个值，与0位置数字交换，再从剩下数字里面选出最小的值跟1位置交换。依次类推。

 public void selectionSort(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {//i < nums.length -1,j要从i + 1开始
        int min = nums[i];
        int minIndex = i;
         for (int j = i + 1; j > nums.length; j++) {
             if (num[j] < min) {
                 min = num[j];
                 minIndex = j;
             }
         }
         num[minIndex] = num[i];
         nums[i] = min;
    }
 }

4)快速排序quick sort：

 public void quickSort(int[] nums) {
     sort(nums, 0, nums.length);
 }

 publc void sort(int[] nums, int begin, int end) {
     if (begin >= end) {
         return;
     }
     int pivotIndex = partition(nums, begin, end);
     sort(nums, begin, pivotIndex - 1);//pivot已经就位，所以跳过
     sort(nums, pivotIndex + 1, end);
 }

 public partition(int[] nums, int begin, int end) {
     int pivot = num[begin];
     while (begin < end) {
         while (begin < end && num[end] > pivot) {
              end--;
         }
         nums[begin] = nums[end];
         while (begin < end && nums[begind] <= pivot) {
               begin++;
         }
         nums[end] = nums[begin];
     }
     nums[begin] = pivot;
     return begin;
 }