排序

1、插入排序

public class TestSort{
	public static void insertSort(int[] array){
        for(int i=0; i<array.length; i++){
            int temp = array[i];
            int j=i-1;
            for(; j>=0; j--){
            //拿j的值和tmp的值比,大于则temp与前面得值挨个比
                if(array[j]>temp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = temp;
        }

2、希尔排序

public class Test{
    public static  void shellSort(int[] array){
        int[] drr = {5, 3, 1};//先进行分割5个一分割、3个一分割，1就是在进行插入排序
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }


    public static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >=0; j = j - gap) {
                if (array[j] > tmp) {//稳定排序
                    array[j + gap] = array[j];
                } else {
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }

}

3、选择排序

public class Test {
    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[j] < array[i]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
}

4、冒泡排序

public class Tesr{
    public static void bubbleSort1(int[] array){
        boolean flg = false;
        for(int i = 0; i<array.length-1; i++){
            flg = false;
            for(int j = 0; i<array.length-i-1; j++){
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] =array[j+1];
                    array[j+1] = temp;
                    flg = true;
                }
            }
            if(!flg){
                break;
            }
        }
    }
}

5、快速排序

//取基线
 public static int partion(int[] array,int low,int high) {//找基准
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high]>= tmp) {
                high--;
           }
                array[low] = array[high];
          
            while(low<high&&array[low]<=tmp){
                low++;
            }
                array[high] = array[low];
        }
        array[low]=tmp;//low=high时出来，tmp值放进去
        return low;
        }
       
    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);
        }
    }

6、归并排序

//归并排序
public static void merge(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 i = 0;
        while (s1 <= mid && s2 <= high) {
            if(array[s1] <= array[s2]) {
                tmp[i++] = array[s1++];
            }else {
                tmp[i++] = array[s2++];
            }
        }
        //判断两个归并段 中 是否还有归并段有数据
        while (s1 <= mid) {//如果s1还剩有数据则继续往tmp里面放
            tmp[i++] = array[s1++];
        }
        while (s2 <= high) {//如果s2里面还有数据，就往tmp里面放。
            tmp[i++] = array[s2++];
        }
        //两个归并段 归并结束-》tmp[]
        for (int j = 0; j < tmp.length; j++) {//把tmp里面的元素拷贝到array数据里面。
            array[low+j] = tmp[j];
        }
    }
    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);
        //合并
        merge(array,low,mid,high);
    }

7、桶排序

public class Test {
    public static void main(String[] args) {
        int[] a = {16,24,37,12,33,28,83,2,10,1};
        System.out.println("未排序序列:" + Arrays.toString(a));
        bucketSort(a,10);
    }
    /**
     *  
     * @param a 需要排序的数组
     * @param max 数组中的最大值
     */
    public static void bucketSort(int[] a,int max){
        int[] count=new int[max+1];//创建一个长度为max的数组
        // 遍历数组a
        for (int i = 0; i < a.length; i++) {
            // 如果数组a的值 作为的count的 下标，每次出现一次 count数组的值+1
            //表示cout[a[i]]++桶中a[i]这个值的个数
            count[a[i]]++;
        }
        // 将桶中的数字倒出
        System.out.print("桶排序后的序列:");
        for (int i = 0; i < count.length; i++) {
            while(count[i]>0){
                System.out.print(i +" ");
                count[i]--;
            }
        }
    }
}

堆排序

//堆排序
public void headSort(){
    int end=this.usedSize-1;
    while(end>0){
        int tem=elem[0];
         elem[0]=elem[end];
        elem[end]=tem;
        adjustDown(0,end);//传入长度
        end--;
    }

//向上调整
    public void adjustUp(int child) {//向上调整
        int parent = (child-1)/2;
        while (child > 0) {
            if(this.elem[child] > this.elem[parent]) {
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                child = parent;
                parent = (child-1)/2;
            }else {
                break;
            }
        }
    }

图解

希尔排序

归并排序