七大排序

1.直接插入排序

原理: 整个区间被分为有序区间和无序区间两部分,每次选择无序区间的第一个元素,在有序区间内选择适合的位置插入

//直接插入排序
public static void insertSort(int[] array){
    for(int i = 1;i<array.length;i++){
       int tmp = array[i];
       int j = i-1;
       for(;j>=0;j--){
           if(array[j+1]<array[j]){
               array[j]= array[j+1];
           }else {
               break;
           }
       }
       array[j+1] = tmp;
    }
}

折半插入排序是对插入排序的优化:在有序区间选择数据应该插入的位置时,因为区间的有序性,可以利用折半查找的思想

//折半插入排序
public static void bsInsertSort(int[] array){
    for(int i = 0;i < array.length;i++){
        int v = array[i];
        int left = 0;
        int right = i;
        while (left < right){
            int m = (left+right)/2;
            if(v >= array[m]){
                left = m+1;
            }else {
                right = m;
            }
        }
        for(int j = i;j > left;j--){
            array[j] = array[j-1];
        }
        array[left] = v;
    }
}

2.希尔排序

原理: 先选定一个整数,把待排序文件中所有记录分成n个组,所有距离为n的记录分在同一组内,并对每一组内的记录进行排序,重复上述分组和排序的工作,当到达n=1时所有记录在同一组内排序

1. 希尔排序是对直接插入排序的优化
2. 当gap>=1时都是预排序,目的是让数组更接近于有序,当gap==1时数组已经接近有序了,然后进行排序.

//希尔排序
public static void shell(int[] array,int gap){
    for(int i = gap;i < array.length;i += 1){
        int tmp = array[i];
        int j = i-gap;
        for(;j >= 0;j--){
        if(array[j] > tmp){
              array[j+gap] = array[j];            
        }else {
            break;
        }
    }
    array[j+gap] = tmp;
}
}
public static void shellSort(int[] array){
   int[] drr = {5,3,23,5,2};
    for(int i = 0;i<drr.length;i++){
        shell(array,drr[i]);
    }
    }

3.选择排序

原理:每一次从无序区间选出最大(或最小)的元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完.

  //选择排序
public static void selectSort(int[] array){
   for(int i = 0;i<array.length;i++){
       for(int j = i+1;j<array.length;j++){
           if(array[i] > array[j]){
               int tmp = array[i];
               array[i] = array[j];
               array[j] = tmp;
           }
       }
   }
}

4.堆排序

原理:

public class Heap {
    public int[] elem;
    public int usedSize;
    
    public Heap(){
    this.elem = new int[20];
    this.usedSize = 0;
}
//一次调整,每次调整这棵树的根节点下标向下调整
public void adjustDown(int root, int len){
    int parent = root;
    int child = 2*parent+1;
    while(child<len){
        //判断是否有右孩子,如果有,谁大?
        if(child+1 < len && elem[child+1] > elem[child]){
            child = child+1;
        }
        if(elem[child]>elem[parent]){
            int temp = elem[child];
            elem[child] = elem[parent];
            elem[parent] = temp;
            parent = child;
            child = 2*parent+1;
        }
        else break;
    }
}
//建堆
public void createHeap(int[] array){
    for(int i = 0;i<array.length;i++){
        this.elem[i] = array[i];
        this.usedSize++;
    }
    for(int i = (this.usedSize-1-1)/2;i>=0;i--){
        adjustDown(i,this.usedSize);
    }
}
public void heapSort() {
    int end = usedSize - 1;
    while (end > 0) {
            int temp = this.elem[0];
            this.elem[0] = this.elem[end];
            this.elem[end] = temp;
            //向下调整
            //end->adjustDown->len小于
            adjustDown(0,end);
            end--;
        }
    }

5.冒泡排序

原理:在无序区间通过相邻数的比较,将最大的数冒泡到无序区间的最后,持续这个过程,直到数组整体有序.

//冒泡排序
public static void bubbleSort(int[] array){
    for(int i = 0;i<array.length-1;i++){
        boolean flag = true;//设置一个标志,如果为true说明没有发生交换,直接退出
        for(int j = 0;j<array.length-i-1;j++){
            if(array[j] > array[j+1]){
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                flag = false;
            }
        }
        if(flag){
            break;
        }
    }
}

6.快速排序

原理:在待排序的n个记录中任取一个记录(通常取第一个记录),把该记录放入适当位置后,数据序列被此记录划分成两部分.所有关键字比该记录关键字小的记录放置在前一部分,所有比它大的记录放置在后一部分,并把该记录排在这两部分的中间(称为该记录归位),这个过程称作一趟快速排序.

//快排
public static int partion(int[] array,int low,int high) {
    int tmp = array[low];
    while (low < high) {
        while (low < high && array[high] >= tmp) {
            high--;
        }
        if(low >= high) {
            break;
        }else {
            array[low] = array[high];
        }

        while (low < high && array[low] <= tmp) {
            low++;
        }
        if(low >= high) {
            break;
        }else {
            array[high] = array[low];
        }
    }
    array[low] = tmp;
    return low;
}

public static void swap(int[] array,int i,int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

public static void threeNumMid(int[] array,int low,int high) {
    //array[low]     array[high]    array[mid]    2   7   5
    //array[mid] <= array[low] <= array[high]
    int mid = (low+high)/2;
    if(array[mid] > array[low]) {
        swap(array,low,mid);//  7   2     5
    }
    if(array[mid] > array[high]) {
        swap(array,high,mid);//  5   2    7
    }
    if(array[low] > array[high]) {
        swap(array,low,high);// 5   2    7
    }
}
public static void quick(int[] array,int low,int high) {
    int par = partion(array,low,high);
    if(par > low+1) {
        quick(array,low,par-1);
    }
    if(par < high-1) {
        quick(array,par+1,high);
    }
}

public static void quickSort1(int[] array) {
    quick(array,0,array.length-1);
}

7.归并排序

原理:将已有的子序列合并,得到完全有序的序列,即先使每个子序列有序,再使子序列段间有序.

 //归并排序
//时间复杂度O(nlog(n))
//空间复杂度O(n)
public static void mergeSort(int[] array,int low,int high){
    if(low == high){
        return;
    }
    int mid = (low+high)/2;
    mergeSort(array,low,mid);
    mergeSort(array,mid+1,high);
    //合并
    marge(array,low,mid,high);
}

private static void marge(int[] array, int low, int mid,int high) {
    int s1 = low;
    int s2 = mid+1;
    int len = high-low+1;
    int[] tmp = new int[len];
    int index = 0;
    while (s1 <= mid && s2<=high){
        if(array[s1] <= array[s2]) {
            tmp[index++] = array[s1++];
        }else {
            tmp[index++] = array[s2++];

        }
    }
    //判断两个归并段中是否还有归并段数据
    while (s1 <= mid){
        tmp[index++] = array[s1++];
    }
    while (s2 <= high){
        tmp[index++] = array[s2++];
    }
    for(int j = 0;j<tmp.length;j++){
        array[low+j] = tmp[j];
    }
}

public static void main(String[] args) {
    Random random = new Random();
    int[] array = new int[100000];
    for (int i = 0; i < array.length; i++) {
        array[i] =random.nextInt(100000) ;
    }
    mergeSort(array,0,array.length-1);
    System.out.println(Arrays.toString(array));
}