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]

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]

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
     
      =nums[left] && lo
     

 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]

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

 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

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

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