排序問題

常見的排序問題：介紹以下8種排序的代碼及性能（事件複雜度、空間複雜度、穩定排序）

（堆排序後續文章介紹）

原地排序指空間複雜爲O（1）的排序算法

①時間複雜度爲O(n²)---指數排序

冒泡排序，插入排序，選擇排序。其中插入排序在應用中較多，其他兩個偏理論，幾乎不用。

他們只適用於小規模數據的排序

②時間複雜度爲O(nlogn)---對數排序

快速排序（分區partition()函數）和歸併排序（合併Merge()函數）,都利用的分治思想和遞歸。

適用於大規模數據的排序。

應用：

1.從100萬個數據（每個數據的大小爲8K）中找到第K大元素，但是內存只有1G

2.現在你有 10 個接口訪問日誌文件，每個日誌文件大小約 300M，並按照時間戳進行排序，現要求將這10個日誌文件合併爲1個日誌文件，並按時間戳進行排序，但內存只有1G，如何解決？

③時間複雜度爲O(n)---線性排序

桶排序、計數排序、基數排序。他們對於數據的要求較高，需要數據的大小範圍遠遠小於數據的數量。

應用：

桶排序（本身桶已經排序）：有 10GB 的訂單數據，我們希望按訂單金額（假設金額都是正整數）從小到大排序，但內存只有100M，沒辦法一次性把 10GB 的數據都加載到內存中，如何解決？

計數排序（特殊的桶排序）：500萬高考考生成績的排序（分數範圍確定爲0-750，分爲750個桶）

基數排序：電話號碼11位進行排序（倒序），但要求必須是穩定排序，保證當前排序不會影響之前的排序結果。

1.冒泡排序

/**

   需求： 定義一個int類型的數組，並對數組當中的元素進行排序，最後遍歷輸出元素。
   技能： 排序算法----冒泡排序。
   版本普通版：

*/
import java.util.Arrays;
public  class  ArrayTest8{

    public static void main(String[] args){
        //1. 創建數組
             int[] arr = {56,23,88,38,99,12,78,59,100,77};
             //排序之前，遍歷數組
             System.out.println("排序之前:"+Arrays.toString(arr));
       //2.嵌套for循環
             int temp = 0; // 作用： 充當第三方變量，爲換位做準備
       //2.1 外層for循環控制循環次數
              for(int i=0;i<arr.length && flag;i++){
                  //2.2  內層for循環控制相鄰的兩個元素進行比較
                  for(int j=0;j<arr.length-1-i;j++){
                      //3.在內層for循環中，再嵌套一個if判斷語句
                      if(arr[j]>arr[j+1]){
                          //如果條件滿足，則進行換位操作
                          temp =arr[j+1];
                          arr[j+1]=arr[j];
                          arr[j]=temp;

                      }
                  }
                  //每一次循環，排序的結果
                  System.out.println("第"+(i+1)+"次循環排序的結果");
                  for(int k=0;k<arr.length;k++){
                      System.out.print(arr[k]+"\t");
                  }
              }
        //4.輸出結果
             //排序之後，遍歷數組
             System.out.println("排序之後:"+Arrays.toString(arr));

    }
}

//優化：當冒泡一定次數時，可能數組已經爲有序的，但仍在循環中，可判斷跳出循環，減少執行次數

package javase.collection;

/**

   需求： 定義一個int類型的數組，並對數組當中的元素進行排序，最後遍歷輸出元素。
   技能： 排序算法----冒泡排序。

   版本：升級版

*/
import java.util.Arrays;

public class ArrayTest04 {

    public static void main(String[] args) {
        // 1. 創建數組
        int[] arr = { 56, 23, 88, 38, 99, 12, 78, 59, 100, 77 };
        // 排序之前，遍歷數組
        System.out.println("排序之前:" + Arrays.toString(arr));
        // 2.嵌套for循環
        int temp = 0; // 作用： 充當第三方變量，爲換位做準備
        boolean flag = true; // 爲什麼此變量的值變爲false
        // 2.1 外層for循環控制循環次數
        int i = arr.length;
        while(flag) {

            flag = false;
            // 2.2 內層for循環控制相鄰的兩個元素進行比較
            for (int j = 0; j < i-1; j++) {
                // 3.在內層for循環中，再嵌套一個if判斷語句
                flag = false;
                if (arr[j] > arr[j + 1]) {
                    // 如果條件滿足，則進行換位操作
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    flag = true;
                }

                // 每一次循環，排序的結果

            }
            System.out.println("第" + (arr.length-i+1) + "次循環排序的結果");
            for (int k = 0; k < arr.length; k++) {
                System.out.print(arr[k] + "\t");
            }
            System.out.println();
            i--;

}
        // 4.輸出結果
        // 排序之後，遍歷數組
        System.out.println("排序之後:" + Arrays.toString(arr));

    }
}

 2.插入排序

package sorts;

import java.util.Arrays;

/**
 * 插入排序（插入位置，從頭至尾搜索）
 * @Author： ooooor
 */
public class InsertionSortAdd {

    public static void main(String[] args) {
        int[] data = new int[]{4, 6, 5, 3, 7, 1, 2};
        fromStartToEnd(Arrays.copyOf(data, data.length));
        System.out.println(Arrays.toString(data));
    }

    /**
     * 查詢插入位置時， 從頭至尾搜索
     * @param data
     */
    private static void fromStartToEnd(int[] data) {
        for (int i=1; i < data.length; i++) {
            int value = data[i];

            int[] tmp = new int[2];
            int change = i;
            for (int j=0; j < i; j++) {
                if(value >= data[j]) {
                    continue;
                }

                int index = j%2;
                if (change == i) {
                    tmp[Math.abs(index-1)] = data[j];
                    change = j;
                }
                tmp[index] = data[j+1];
                if (0 == index) {
                    data[j+1] = tmp[index+1];
                } else {
                    data[j+1] = tmp[index-1];
                }
            }
            data[change] = value;
        }
    }

}

3.選擇排序

package sorts;

/**
 * 冒泡排序、插入排序、選擇排序
 *
 * Author: Zheng
 */
public class Sorts {

  // 冒泡排序，a是數組，n表示數組大小
  public static void bubbleSort(int[] a, int n) {
    if (n <= 1) return;

    for (int i = 0; i < n; ++i) {
      // 提前退出標誌位
      boolean flag = false;
      for (int j = 0; j < n - i - 1; ++j) {
        if (a[j] > a[j+1]) { // 交換
          int tmp = a[j];
          a[j] = a[j+1];
          a[j+1] = tmp;
          // 此次冒泡有數據交換
          flag = true;
        }
      }
      if (!flag) break;  // 沒有數據交換，提前退出
    }
  }

  // 插入排序，a表示數組，n表示數組大小
  public static void insertionSort(int[] a, int n) {
    if (n <= 1) return;

    for (int i = 1; i < n; ++i) {
      int value = a[i];
      int j = i - 1;
      // 查找要插入的位置並移動數據
      for (; j >= 0; --j) {
        if (a[j] > value) {
          a[j+1] = a[j];
        } else {
          break;
        }
      }
      a[j+1] = value;//插入數據
    }
  }

  // 選擇排序，a表示數組，n表示數組大小
  public static void selectionSort(int[] a, int n) {
    if (n <= 1) return;

    for (int i = 0; i < n - 1; ++i) {
      // 查找最小值
      int minIndex = i;
      for (int j = i + 1; j < n; ++j) {
        if (a[j] < a[minIndex]) {
          minIndex = j;
        }
      }
      
      // 交換
      int tmp = a[i];
      a[i] = a[minIndex];
      a[minIndex] = tmp;
    }
  }

}

4.歸併排序

package sorts;

import java.util.Arrays;

/**
 * 歸併排序
 * Created by wangzheng on 2018/10/16.
 */
public class MergeSort {
	public static void main(String[] args) {
		int[] arr=new int[]{2,5,1,3,4,7,1};
		int n=arr.length;
		mergeSort(arr, n);
		System.out.println(Arrays.toString(arr));
	}

  // 歸併排序算法, a是數組，n表示數組大小
  public static void mergeSort(int[] a, int n) {
    mergeSortInternally(a, 0, n-1);
  }

  // 遞歸調用函數
  private static void mergeSortInternally(int[] a, int p, int r) {
    // 遞歸終止條件
    if (p >= r) return;

    // 取p到r之間的中間位置q,防止（p+r）的和超過int類型最大值
    int q = p + (r - p)/2;
    // 分治遞歸
    mergeSortInternally(a, p, q);
    mergeSortInternally(a, q+1, r);

    // 將A[p...q]和A[q+1...r]合併爲A[p...r]
    merge(a, p, q, r);
  }

  private static void merge(int[] a, int p, int q, int r) {
    int i = p;
    int j = q+1;
    int k = 0; // 初始化變量i, j, k
    int[] tmp = new int[r-p+1]; // 申請一個大小跟a[p...r]一樣的臨時數組
    while (i<=q && j<=r) {
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等於i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }

    // 判斷哪個子數組中有剩餘的數據
    int start = i;
    int end = q;
    if (j <= r) {
      start = j;
      end = r;
    }

    // 將剩餘的數據拷貝到臨時數組tmp
    while (start <= end) {
      tmp[k++] = a[start++];
    }

    // 將tmp中的數組拷貝回a[p...r]
    for (i = 0; i <= r-p; ++i) {
      a[p+i] = tmp[i];
    }
  }

}

5.快速排序

package sorts;

/**
 * Created by wangzheng on 2018/10/16.
 */
public class QuickSort {

  // 快速排序，a是數組，n表示數組的大小
  public static void quickSort(int[] a, int n) {
    quickSortInternally(a, 0, n-1);
  }

  // 快速排序遞歸函數，p,r爲下標
  private static void quickSortInternally(int[] a, int p, int r) {
    if (p >= r) return;

    int q = partition(a, p, r); // 獲取分區點
    quickSortInternally(a, p, q-1);
    quickSortInternally(a, q+1, r);
  }

  private static int partition(int[] a, int p, int r) {
    int pivot = a[r];
    int i = p;
    for(int j = p; j < r; ++j) {
      if (a[j] < pivot) {
        if (i == j) {
          ++i;
        } else {
          int tmp = a[i];
          a[i++] = a[j];
          a[j] = tmp;
        }
      }
    }
    //j==r
    int tmp = a[i];
    a[i] = a[r];
    a[r] = tmp;

    System.out.println("i=" + i);
    return i;
  }
}

6.桶排序與計數排序類似

// 計數排序，a 是數組，n 是數組大小。假設數組中存儲的都是非負整數。
public void countingSort(int[] a, int n) {
  if (n <= 1) return;

  // 查找數組中數據的範圍
  int max = a[0];
  for (int i = 1; i < n; ++i) {
    if (max < a[i]) {
      max = a[i];
    }
  }

  int[] c = new int[max + 1]; // 申請一個計數數組 c，下標大小 [0,max]
  for (int i = 0; i <= max; ++i) {
    c[i] = 0;
  }

  // 計算每個元素的個數，放入 c 中
  for (int i = 0; i < n; ++i) {
    c[a[i]]++;
  }

  // 依次累加
  for (int i = 1; i <= max; ++i) {
    c[i] = c[i-1] + c[i];
  }

  // 臨時數組 r，存儲排序之後的結果
  int[] r = new int[n];
  // 計算排序的關鍵步驟，有點難理解
  for (int i = n - 1; i >= 0; --i) {
    int index = c[a[i]]-1;
    r[index] = a[i];
    c[a[i]]--;
  }

  // 將結果拷貝給 a 數組
  for (int i = 0; i < n; ++i) {
    a[i] = r[i];
  }
}