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;
}