排序问题

常见的排序问题：介绍以下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];
  }
}