基于比较的排序

1、插入排序 (折半插排)
减治算法排序
每次从无序区间选择第一个数，插入到有序区间的合适位置
2 3 4 5 9 1768
1 2 3 4 5 9 768
1 2 3 4 5 7 9 68
一共需要多少次插入 size-1
想清楚有序区间 无序区间
插入过程：每次把无序区间的第一个数进行插入 在有序区间内遍历
1）找到合适的位置
2）搬移原有数据 为该数据腾位
时间复杂度 逆序（O（n）^2）
正序（O（n））
越接近有序执行效率越高
空间复杂度 O（1）
稳定性：稳定

public static void inserSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            /**
             * 有序区间[0,i]
             * 无序区间[i+1,length-1]
             * 待插入的数据为array[i+1]
             * 插入过程在有序区间内查找
             */
               int key=array[i+1];
               int j;
               //查找
               for(j=i;j>=0;j--){
                  //加=保证稳定性
                   if(key>=array[j]){
                       break;
                   }
               }
               //j+1放到key位置
            for(int k=i;k>j;k--){
                array[k+1]=array[k];
            }
            array[j+1]=key;
        }
    }

2、希尔排序
建立在插排之前 分组（预排序）
分组数目
size=10；gap=size
gap=gap/3+1
前提：利用插入排序，数字组越接近有序，时间效率越高
在插入排序之前做预排序（分组插排），是数组尽可能接近有序
如何分组问题：
动态分组：gap=gap/3+1 gap=gap/2
时间复杂度
最好O（n） 平均O（n^1.3-1.4） 最坏（O（n^2））
时间复杂度 O(1)
稳定性：不稳定，相同的数被分到不同的组里，无法保证
public static void inserSortGap(int[] array,int gap) {
for (int i = 0; i < array.length - gap; i++) {
int key = array[i + gap];
int j;

        for (j = i; j >= 0 && key < array[j]; j -= gap) {
            if (key < array[j]) {
                array[j + gap] = array[j];
            }
            array[j + gap] = key;
        }
    }
}
public static void shellSort(int[]array){
    int gap=array.length;
    while(true) {
        gap =gap/3+1;
        inserSortGap(array, gap);
        if(gap==1){
            return ;
        }
    }
}

`3、选择排序（直接选择排序、堆排序）
减治算法 n-1
每次遍历无序遍历（直接遍历，利用堆） 找到无序区间最大的数
把最大的数放到无序区间的最后边
一直选择n-1 次 数据完全有序
时间复杂度 O（n^2）
空间复杂度 O（1）
稳定性 不稳定

public static void selectSort(int[] array){
        //每次选最大的数
        for(int i=0;i<array.length;i++){
            //无序区间[0,array.length-i)
            //有序区间
            int max=0;
            int j;
            for(j=1;j<array.length-i;i++){
                if(array[j]>array[max]){
                    max=j;
                }
            }
            swap(array,max,j);
        }
    }

4、堆排序
时间复杂度 O（n*log(n)）
空间复杂度 O（1）
稳定性 不稳定

``public static void heapSort(int[] array){
createHeap(array,array.length);
for(int i=0;i<array.length-1;i++){
//无序[0,array.length-i)
swap(array,0,array.length-i);
Heapify(array,array.length-i,0);

     }
}
//建堆
public static void createHeap(int[]array,int size){
    for(int i=(size-2)/2;i>=0;i--){
        Heapify(array,size,i);
    }
}
//向下调整
public static void Heapify(int[]array,int size,int index){
   while(true){
       int left=2*index-1;
       if(left>size){
           return;
       }
       int max=left;
       if(left+1<size&&array[left]<array[left+1]){
             max=left+1;
       }
       if(array[max]>array[index]){return;}
       swap(array,index,max);
   }
}

5、冒泡排序
时间复杂度 最好情况（O(n)） 最坏/平均（O（n^2））
空间复杂度（O(1）
稳定性： 稳定
区分低配选择排序和冒泡排序

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

重点：快速排序
分治算法
步骤：
1、在整个排序区间内 确定一个基准值
2、遍历整个待排序区间，将所有数据和基准值比较，最终达到
比基准值小的（可包含等于） 在基准值左边 递归
大 右 (partition-分割)
3、用同样的策略处理左右两个小的待排序区间，直到
1）小区间没有数据了size0
2）小区间已经有序了size1

public static void quickSortf(int[]array){
        Stack<Integer>stack=new Stack<>();
        stack.push(array.length);
        stack.push(0);

        while(!stack.empty()){
            int left=stack.pop();
            int right=stack.pop();
            if(left>=right){
                continue;
            }
            int privotindex=partition(array,left,right);
        }
    }

暂时先记录这几种排序
19 9.7