排序算法（java）

1：插入排序

1.1：插入排序

public class charupaixu {
    /**
     * 注意点：数组 num[i++] 需要注意会不会出现数组越界的问题
     * 直接插入排序，其实就是，把我需要插入的数据抽出来，这样我就可以
     * 有一个空位，让比较的数值
     * 她们有空间移动位置，最后，把要换的值，换为我们抽空的数据
     * @param args
     */
    public static void main(String[] args) {
        int []num={4,6,2,3,1,8};
        int len=num.length;
        sort(num,len);
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void sort(int[] num, int len) {
       for(int i=1;i<len;i++)
       {
           int get=num[i];
           int j=i-1;
           while(j>=0 && get<num[j])
           {
               num[j+1]=num[j];
               j--;
           }
           num[j+1]=get;
       }
    }
}

1.2：希尔排序

public class xierpaixu {
    /**
     * 这个希尔排序大概的内容就是先让他变得有序
     * 最后的步长为1时，进行一次全面的插入排序
     * @param args
     */
    public static void main(String[] args) {
        int []num={4,6,2,3,1,8};
        int len=num.length;
        sort(num,len);
        System.out.println("排序后的结果");
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void sort(int[] num, int len) {
        int temp=0;
        int j=0;
        for(int increment=len/2;increment>0;increment/=2)
        {
            System.out.println("increment:"+increment);
            for(int i=increment;i<len;i++)
            {
                temp=num[i];
                for(j=i-increment;j>=0;j-=increment)
                {
                    if(temp<num[j]) {
                        num[j+increment]=num[j];
                    }else {
                        break;
                    }
                }
                num[j+increment]=temp;
            }
            for(int i=0;i<len;i++)
            {
                System.out.println(num[i]+" ");
            }
        }
    }

}

2：选择排序

2.1：简单选择排序

public class xuanzepaixu {
    public static void main(String[] args) {
        /**
         * 选择排序，其实就是每一次挑选出最小的那个数值，
         * 然后，在指定的位置上，两两交换位置
         */
        int []num={4,6,2,3,1,8};
        int len=num.length;
        sort(num,len);
        System.out.println("排序后的结果");
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void sort(int[] num, int len) {
        for(int i=0;i<len-1;i++)
        {
            int min=i;
            for(int j=i+1;j<len;j++)
            {
                if(num[min]>num[j])
                {
                    min=j;
                }
            }
            int temp=num[i];
            num[i]=num[min];
            num[min]=temp;
        }
    }
}

2.2：堆排序

3：交换排序

3.1：冒泡排序

public class maopaopaixu {
    public static void main(String[] args) {
        /**
         * 冒泡排序也就是每轮两两比较并且交换，
         * 一轮下来，也就是说，最终最值在一侧边缘
         */
        int []num={4,6,2,3,1,8};
        int len=num.length;
        sort(num,len);
        System.out.println("排序后的结果");
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void sort(int[] num, int len) {
        for(int i=len-2;i>=0;i--)
        {
            for(int j=0;j<=i;j++)
            {
                if(num[j]>num[j+1])
                {
                    int temp=num[j];
                    num[j]=num[j+1];
                    num[j+1]=temp;
                }
            }
        }
    }
}

3.2：快速排序

3.2.1：基准数法

public class kuaipai {
    public static void main(String[] args) {
        /**
         * 快排中的基准数法：
         * 其实就是，随便找一个数，让他的左边的数小于他，右边的数大于他
         * 因此，我们就得想办法了，让他先从右边开始遍历，找到一个小于基准数，停止，
         * 再从左边找到比基准数大的值，然后让她们左右互换位置，重复这个操作，
         * 当i与j碰面时，交换结束，此时把碰面的那个值和基准数交换位置，递归这个重复的操作
         */
        int []num={4,6,2,3,1,8};
        int len=num.length;
        quickSort(num,0,len-1);
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void quickSort(int[] num, int low, int high) {
        int i,j,temp,t;
        if(low>high)
        {
            return;
        }
        i=low;
        j=high;
        temp=num[low];
        while(i<j)
        {
            while (temp<=num[j] && i<j)
            {
                j--;
            }
            while (temp>=num[i] && i<j)
            {
                i++;
            }
            if(i<j)
            {
                t=num[j];
                num[j]=num[i];
                num[i]=t;
            }
        }
        num[low]=num[i];
        num[i]=temp;
        quickSort(num,low,j-1);
        quickSort(num,j+1,high);
    }

}

3.2.2：三数取中法

public class kuaipai2 {
    public static void main(String[] args) {
        /**
         * 三数取中法
         */
        int []num={4,6,2,3,1,8};
        int len=num.length;
        quickSort(num,0,len-1);
        Arrays.stream(num).forEach(System.out::println);
    }

    private static void quickSort(int[] num, int left, int right) {
        if(left<right)
        {
            //获取枢纽值，并将其放在当前待处理序列末端
            dealPivot(num,left,right);
            int pivot=right-1;
            int i=left;
            int j=right-1;
            while (true)
            {
                while (num[++i]<num[pivot]){

                }
                while (j>left &&num[j--]>num[pivot])
                {

                }
                if(i<j)
                {
                    swap(num,i,j);
                }else {
                    break;
                }
            }
            if(i<right)
            {
                swap(num,i,right-1);
            }
            quickSort(num,left,i-1);
            quickSort(num,i+1,right);
        }
    }

    private static void dealPivot(int[] num, int left, int right) {
        int mid=(left+right)/2;
        if(num[left]>num[mid])
        {
            swap(num,left,mid);
        }
        if(num[left]>num[right])
        {
            swap(num,left,right);
        }
        if(num[right]<num[mid])
        {
            swap(num,right,mid);
        }
        swap(num,right-1,mid);
    }

    private static void swap(int[] num, int left, int right) {
        int temp=num[left];
        num[left]=num[right];
        num[right]=temp;
    }

}

4：归并排序

5：基数排序