javaSE基础知识——day13 八种排序冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、基数排序

最新推荐文章于 2022-10-14 19:15:23 发布

@李小白

最新推荐文章于 2022-10-14 19:15:23 发布

阅读量128

点赞数

本文链接：https://blog.csdn.net/lalaMarry/article/details/95801444

版权

冒泡排序

冒泡排序：元素两两比较，大的往后放，经过一轮比较后，那么最大的元素就会出现在最后面。

案例：

import java.util.Arrays;

public class ArraySortDemo {
    public static void main(String[] args) {
        //冒泡排序：元素两两比较，大的往后放，经过一轮比较后，那么最大的元素就会出现在最后面。
        //定义原始数组
        
        int[] arr = {24, 69, 80, 57, 13,1,4,6,-1};
        //tuiDao(arr);

        for (int j = 0; j <arr.length-1; j++) {
            for (int i = 0; i < arr.length - 1-j; i++) {
                //比较大小，把大的往后放
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }

            }
        }


        System.out.println(Arrays.toString(arr));

        
    }

    private static void tuiDao(int[] arr) {
        //第一轮比较4次
        for (int i = 0; i < arr.length-1; i++) {
            //比较大小，把大的往后放
            if(arr[i]>arr[i+1]){
                int t=arr[i];
                arr[i]=arr[i+1];
                arr[i + 1]=t;
            }

        }
        //第二轮比较3次
        for (int i = 0; i < arr.length - 1-1; i++) {
            //比较大小，把大的往后放
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }

        }
        //第三比较2次
        for (int i = 0; i < arr.length - 1 - 1-1; i++) {
            //比较大小，把大的往后放
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }

        }

        //第四轮比较
        for (int i = 0; i < arr.length - 1 - 1 - 1-1; i++) {
            //比较大小，把大的往后放
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }

        }
    }
}

选择排序

每次拿一个元素，跟他后面的元素，挨个去比，小的往前放，经过一轮比较后，那么最小元素就会放在最前面去

案例：

import java.util.Arrays;
public class ArraySortDemo2 {
    public static void main(String[] args) {
        //选择排序：每次拿一个元素，跟他后面的元素，挨个去比，小的往前放，经过一轮比较后，那么最小元素就会放在最前面去
        int[] arr = {24, 69, 80, 57, 13, 4, 6, 90, -1};
        //  tuiDao(arr);
        for (int index = 0; index < arr.length - 1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                    swapValue(arr, index, i);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    private static void tuiDao(int[] arr) {
        //第一轮比较
        int index = 0; //先拿第一个元素 跟后面的元素挨个去比
        for (int i = 1; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                swapValue(arr, index, i);
            }

        }

        //第二轮比较
        index = 1; //先拿第一个元素 跟后面的元素挨个去比
        for (int i = 1 + index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                swapValue(arr, index, i);
            }

        }

        //第三轮
        index = 2; //先拿第一个元素 跟后面的元素挨个去比
        for (int i = 1 + index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                swapValue(arr, index, i);
            }

        }

        //第三轮
        index = 3; //先拿第一个元素 跟后面的元素挨个去比
        for (int i = 1 + index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                swapValue(arr, index, i);
            }

        }
    }

    //值交换的方法
    private static void swapValue(int[] arr, int j, int i) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }


}

插入排序

直接插入排序：将后面的元素，插入之前的一个有序列表，使之仍然保持有序

案例：

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //直接插入排序：将后面的元素，插入之前的一个有序列表，使之仍然保持有序
        int[] arr = {2, 1, 0, 6, 9, 0, 10, 100, 20, 10, -1, 3, 6, 100, 200, 150};
        //  sortDemo1(arr);
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    swapValue(arr, j, j - 1);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }


    //值交换的方法
    private static void swapValue(int[] arr, int j, int i) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    private static void sortDemo1(int[] arr) {
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            //里层就是循环让当前元素和上一个有序列表中的每个元素，比较，进行位置交换，使之仍保持有序
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
    }
}

希尔排序

希尔排序，是对直接插入排序的一种改进，他的思想选择一个合适的增量，然后经过一轮插入排序后，就会让数组大致有序
然后不断的缩小增量，进行插入排序，直到增量为1 整个排序结束

案例：

import java.util.Arrays;
public class ArryDemo2 {
    public static void main(String[] args) {
        //希尔排序，是对直接插入排序的一种改进，他的思想选择一个合适的增量，然后经过一轮插入排序后，就会让数组大致有序
        //然后不断的缩小增量，进行插入排序，直到增量为1 整个排序结束
        int[] arr = {46, 55, 13, 42, 17, 94, 5, 70, 10, 30, 56, 1, 0, 20, 1, 5, -1};

        shellSort(arr);


        //其实我们的直接插入排序，就是增量为1的希尔排序

        //int h = 1;
        //for (int i = h; i < arr.length; i++) {
        //    for (int j = i; j > h - 1; j -= h) {
        //        if (arr[j] < arr[j - h]) {
        //            swapValue(arr, j, j - h);
        //        }
        //    }
        //}
        System.out.println(Arrays.toString(arr));
    }

    private static void shellSort(int[] arr) {
        //定义增量为4
       /* int h=4;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j-=h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }

        h = 2;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }

        h = 1;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }*/
        //间隔选为4 不是很合理
       /* for (int h = 4; h>0; h/=2) {
            for (int i = h; i < arr.length; i++) {

                for (int j = i; j > h - 1; j -= h) {

                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }*/
        //间隔得选取合理 ：一般第一次的增量我们选取数组长度的一半
       /* for (int h = arr.length/2; h > 0; h /= 2) {
            for (int i = h; i < arr.length; i++) {

                for (int j = i; j > h - 1; j -= h) {

                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
*/
        //克努特序列
        //int h=1;
        //h=3*h+1; // 1,4,13,40,121,364


        //我要选择一个合适的增量 使用克努特序列来选

        int jianGe = 1;
        while (jianGe <= arr.length / 3) {
            jianGe = 3 * jianGe + 1;
        }

        for (int h = jianGe; h > 0; h = (h - 1) / 3) {
            for (int i = h; i < arr.length; i++) {

                for (int j = i; j > h - 1; j -= h) {

                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }

    }

    //值交换的方法
    private static void swapValue(int[] arr, int j, int i) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

}

归并排序

案例：

import java.util.Arrays;
public class ArrayDemo3 {
    public static void main(String[] args) {

        int[] arr = {2, 10, 1, 0, 100, 3, 5, -1, 200, 109, 30, 1009, 109, 109, -100};

        //int[] arr={1,3,5,7,9,0,2,4,8,10};
        //归并排序
        //分
        chaiFen(arr, 0, arr.length - 1);

        //归
        // mergerSort(arr,0,(arr.length/2)-1,arr.length-1);

        System.out.println(Arrays.toString(arr));

    }

    private static void chaiFen(int[] arr, int startIndex, int endIndex) {
        //计算中间索引
        int centerIndex = (startIndex + endIndex) / 2;
        //递归来拆
        if (startIndex < endIndex) {
            //拆分左边
            chaiFen(arr, startIndex, centerIndex);
            //拆分右边
            chaiFen(arr, centerIndex + 1, endIndex);
            //归并
            mergerSort(arr, startIndex, centerIndex, endIndex);
        }
    }


    /**
     * @param arr         要归并的数组
     * @param startIndex  起始索引
     * @param centerIndex 中间索引
     * @param endIndex    结束索引
     */
    private static void mergerSort(int[] arr, int startIndex, int centerIndex, int endIndex) {
        //定义一个临时数组
        int[] tempArray = new int[endIndex - startIndex + 1];
        //定义临时数组的起始索引
        int index = 0;
        //定义左边数组的起始索引
        int i = startIndex;
        //定义右边数组的起始索引
        int j = centerIndex + 1;
        //循环比较左右两边数组的元素，往临时数组里面方法
        while (i <= centerIndex && j <= endIndex) {
            //进来比较
            if (arr[i] <= arr[j]) {
                tempArray[index] = arr[i];
                i++; //记得递增索引
            } else {
                tempArray[index] = arr[j];
                j++;//记得递增索引
            }

            index++; //临时数组的索引

        }

        //处理左边剩余元素

        while (i <= centerIndex) {
            tempArray[index] = arr[i];
            i++; //记得递增索引
            index++;
        }

        //处理右边剩余元素


        while (j <= endIndex) {
            tempArray[index] = arr[j];
            j++; //记得递增索引
            index++;
        }

        //这个时候我们的临时数组里面的元素已经排序好了

        //  System.out.println(Arrays.toString(tempArray));
        //遍历临时数组，将临时数组中的元素，放到原数组里面去
        for (int k = 0; k < tempArray.length; k++) {
            arr[k + startIndex] = tempArray[k];
        }


    }
}

快速排序

案例：

import java.util.Arrays;
public class MyTest {
    public static void main(String[] args) {
        int[] arr = {2, 1, 0, 6, 9, 0, 10, 100, 20, 10, -1, 3, 6, 100, 200, 150};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

import java.time.Instant;
public class QuickSortUtils {

    private QuickSortUtils() {
    }

    /**
     *
     * @param arr 要排序的数组
     * @param startIndex 开始索引
     * @param endIndex 结束索引
     */
    public static void quickSort(int[] arr,int startIndex,int endIndex){
        if(startIndex<endIndex){
            //找到基准数的索引
            int index=getIndex(arr,startIndex,endIndex);
            //对左右两边进行递归调用

            quickSort(arr,startIndex,index);
            quickSort(arr,index+1,endIndex);

        }
    }

    //
    //将基准数挖出形成第一个坑。
    //由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    //由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    //再重复执行2，3两步骤。


    //挖坑填数
    private static int getIndex(int[] arr, int startIndex, int endIndex) {
        //定义三个变量
        int i=startIndex;
        int j=endIndex;
        //定义基准数
        int x=arr[i];
        while (i<j){
           //1. 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i<j&&arr[j]>=x){
                j--;

            }
            //填坑
            if(i<j){
                arr[i]=arr[j];
                i++;//顺便让i增一下
            }
            //2,由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中
            while (i<j&&arr[i]<x){

                i++;
            }

            //填坑
            if (i < j) {
                arr[j] = arr[i];
                j--; //顺便让j减一下
            }


        }
        //以上循环完毕之后，将基准数填到最后一个坑里面去
        arr[i]=x;

        return i;
    }
}

基数排序
案例：

import java.util.Arrays;
public class 基数排序算法 {
    public static void main(String[] args) {
        int[] arr = {1, 9, 8, 12, 23, 28, 32, 42, 102, 100, 259};
        sortArray(arr);
        System.out.println(Arrays.toString(arr));

    }

    private static void sortArray(int[] arr) {
        //定义一个二维数组
        int[][] tempArr = new int[10][arr.length];//里面的一维数组的长度最大就和待排序的数组长度一样
        //定义一个统计的一维数组,可以统计二维数组每个桶中放了多少数字
        int[] counts = new int[10];//长度和二维数组长度保持一样
        //获取数组中最大的数
        int max = getMax(arr);
        //计算数组中最大的数的有几位,这就是我们需要比较的轮次
        int len = String.valueOf(max).length();
        for (int i = 0, n = 1; i < len; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                //获取每个位上的数字
                int ys = arr[j] / n % 10;
                //我们找一个二维数组,数组中放10个桶,这个桶就是一位数组
               // counts[ys]++ 意思是,二维数组的桶中放一个数字,那么统计数组对于的位置就统计一下
                tempArr[ys][counts[ys]++] = arr[j];
            }
            //我们遍历统计数组,取出二维数组中的元素,放回原数组
            int index = 0;
            for (int k = 0; k < counts.length; k++) {
                if (counts[k] != 0) {
                    for (int h = 0; h < counts[k]; h++) {
                        arr[index] = tempArr[k][h];
                        index++;
                    }
                    //情况一轮过后统计的个数
                    counts[k] = 0;
                }
            }
        }


    }

    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        return max;
    }
}

import java.util.Arrays;
import java.util.SortedMap;
import static java.util.Arrays.sort;
public class ArrayDemo2 {
    public static void main(String[] args) {
        //基数排序
        int[] arr = {21,31,444,23,33,47,1000,900,124,987,0,100,0};
        //int max=getMax(arr);
        sortArr(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void sortArr(int[] arr) {
        //最大数有几位,我们就排几轮
        int max = getMax(arr);
        int len = String.valueOf(max).length();
        //len=2;
        //定义一个二维数组,长度为10
        int[][] tempArr = new int[10][arr.length];
        //再定义一个数组,长度和二维数组的长度一样,用于记录二维数组中的每一个桶位存了几个数字
        int[] counts = new int[10];

        for (int i = 0, n = 1; i < len; i++, n *= 10) {
            //循环遍历,取每个位上的数字
            for (int j = 0; j < arr.length; j++) {
                //取每个位上的数字
                int ys = arr[j] / n % 10;
                //int count=counts[ys];
                tempArr[ys][counts[ys]]=arr[j];
                counts[ys]++;
               // count++;//二维数组中的一维数组放了要一个数,就在统计数组对应的位置统计一下
               // counts[ys] = count; //将累加后的值,赋值给统计数组
            }
            //取出每个桶中的元素,放入原来的数组
            int index=0;
            for (int k = 0; k < counts.length; k++) {
               //取出统计数组在每个位置上统计的个数
                if(counts[k]!=0){
                    for (int h = 0; h < counts[k]; h++) {
                        arr[index]=tempArr[k][h];
                        index++;
                    }
                    counts[k] = 0; //一趟完成后,把统计的个数清0
                }

            }
        }
        //for (int i = 0; i < tempArr.length; i++) {
        //    System.out.println(Arrays.toString(tempArr[i]));
        //}


    }

    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

@李小白

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
javaSE基础知识——day13 八种排序冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、基数排序

冒泡排序冒泡排序：元素两两比较，大的往后放，经过一轮比较后，那么最大的元素就会出现在最后面。案例：import java.util.Arrays;public class ArraySortDemo { public static void main(String[] args) { //冒泡排序：元素两两比较，大的往后放，经过一轮比较后，那么最大的元素就会出现在...
复制链接

扫一扫