排序算法总结

1.桶排序

public static void BucketSort(int[] nums){
        //这里需要知道数组的最大值，作为桶的个数
        int[] buckets = new int[11];
        //装桶
        for (int i = 0; i < nums.length; i++) {
            buckets[nums[i]]++;
        }
        int j = 0;
        //出桶
        for (int i = 0; i < buckets.length; i++) {
            while (buckets[i]>0)
            {
                nums[j] = i;
                j++;
                buckets[i]--;
            }
        }
        System.out.println(Arrays.toString(nums));
    }

2.冒泡排序

public static void Bubble(int[] nums){
        /*
        冒泡和选择的区别是：
        冒泡是从上到下依次确定好每个位置的数字，每次把较小的数字交换到上边
        选择是每次找到最小数字，然后放到应该的位置
         */
        //冒泡次数是数组长度，每次冒泡都确定顶部一个位置的数字
        for (int i = 0; i < nums.length-1; i++) {
            //每次都是从数组底部开始取，依次向上
            for (int j = nums.length-1; j > i ; j--) {
                if (nums[j]<nums[j-1])
                {
                    int temp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }

3.选择排序

public static void SelectionSort(int[] nums){
        //每次从当前最开始位置(每次都往下一个)开始，找到最小的数，排到上边
        for (int i = 0; i < nums.length-1; i++) {
            //记录最小数的index
            int min = i;
            for (int j = i+1; j < nums.length; j++) {
                //更新最小数index
                if (nums[j]<nums[min])
                    min = j;
            }
            //找到最小数后交换
            if (i!=min)
            {
                int temp = nums[min];
                nums[min] = nums[i];
                nums[i] = temp;
            }
        }
        System.out.println(Arrays.toString(nums));
    }

4.三数取中快排

public static void QuickSort(int[] nums,int lo,int hi){
        if (lo>=hi) return;
        //三数取中进行选择基准值
        int mid = (lo+hi)/2;
        if (nums[mid]>nums[hi])
            swap(mid,hi,nums);
        if (nums[lo]>nums[hi])
            swap(lo,hi,nums);
        if (nums[mid]>nums[lo])
            swap(lo,mid,nums);
        //现在lo位置是中间数
        int left = lo;
        int right = hi;
        while (lo<hi)
        {
            //必须从基准对面开始走，因为对面哨兵停止的位置应该和基准位置交换
            while (nums[hi]>=nums[left] && lo<hi)
                hi--;
            while (nums[lo]<=nums[left] && lo<hi)
                lo++;
            //交换不符合者
            swap(lo,hi,nums);
        }
        swap(hi,left,nums);
        QuickSort(nums,left,hi-1);
        QuickSort(nums,hi+1,right);
    }
    public static void swap(int i,int j,int[] nums){
        int temp = nums[j];
        nums[j] = nums[i];
        nums[i] = temp;
    }

 5.归并排序

/*
    思路就是将两个有序数组进行组合，通过递归得到左右排序好的数组
     */
    //组合函数
    public void combine(int[] a,int sta,int mid,int end,int[] res)
    {
        int f = sta;
        int sta2 = mid+1;
        int i = 0;
        //两个数组都没有遍历完
        while (sta<=mid&&sta2<=end)
        {
            if (a[sta]<a[sta2]) res[i++] = a[sta++];
            else res[i++] = a[sta2++];
        }
        while (sta<=mid) res[i++] = a[sta++];
        while (sta2<=end) res[i++] = a[sta2++];
        //将排序结果添加到a中，让a形成有序数组
        for (int j = 0; j < i; j++) {
            a[j+f] = res[j];
        }
    }
    public void sort(int[] a ,int sta,int end,int[] res)
    {
        //分治思想把子数组排为有序数组
        if (sta<end)
        {
            int mid = (sta+end)/2;
            sort(a,sta,mid,res);
            sort(a,mid+1,end,res);
            combine(a,sta,mid,end,res);
        }
    }
    public void mergeSort(int[] a)
    {
        int[] res = new int[a.length];
        sort(a,0,a.length-1,res);
    }

6.堆排序

public void sort(int[] nums)
    {
        //要设置一个变量记录当前堆的大小，每次取数，堆会少最后一个节点
        int l = nums.length;
        //构建大根堆，降序则构建小根堆。大根堆是一个完全二叉树，且父节点一定不小于子节点
        //数组一开始可以看成一个堆，不过需要调整。从最后一个非叶节点开始调整，调整到根节点
        //最后一个非叶节点的index是n/2-1；
        for (int i = (l/2)-1; i >=0 ; i--) {
            adjust(nums,i,l);
        }
        //开始取数
        while (l>1){
            //取数就是把最大的数（堆顶）放到最后，然后最后那个节点就脱离堆（尺寸-1）
            swap(nums,0,l-1);
            l--;
            //每次交换结束都要进行调整
            adjust(nums,0,l);
        }
    }
    public void adjust(int[] nums,int index,int size){
        /*
        输入的是待调整堆和调整范围（从index节点处开始调整，默认前边是调整好的）
         */
        //获取完全二叉树中子节点的index
        int l = index*2+1;
        int r = index*2+2;
        int max = index;
        //找到这一家庭中最大值是谁,有可能有的孩子不存在，所以要判断
        if (l<size && nums[max]<nums[l]) max = l;
        if (r<size && nums[max]<nums[r]) max = r;
        //如果需要调整，就调整
        if (max!=index)
        {
            swap(nums,max,index);
            //调整后有可能被调整的子节点会不符合规定，所以要调整孩子节点
            adjust(nums,max,size);
        }
    }
    public void swap(int[] nums,int i,int j)
    {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

 7.插入排序

public void sort(int[] nums){
        /*
        从前两个开始，排好序，以后从第三个开始后，前边的就是都排好的了，大的数往后挪，知道找到当前数的位置
         */
        if (nums.length<2) return;
        //外层代表当前数
        for (int i = 1; i < nums.length; i++) {
            int temp = nums[i];
            int j = i-1;
            while (j>=0&&temp<nums[j])
            {
                nums[j+1] = nums[j];
                j--;
            }
            nums[j+1] = temp;
        }
    }

8.希尔排序，希尔排序是在插入排序的基础上做的优化

请看大牛整理的：https://www.cnblogs.com/chengxiao/p/6104371.html