Java排序

一、冒泡排序:

//冒泡排序：
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {90, 69, 6, 66, 55};

        //一、冒泡排序概述： 拿着相邻两个元素进行比较如果前边大就交换
        // (也可以后边大就交换-降序)(第j位和第j+1位比较<j不用等于最后一个元素的下标4>)
        // 比较一轮可以找出最大的数，比较第二轮可以找到第二大的数，4个数经过3轮比较就可
        //以排好序(4个数经过3轮比较，给3个数排好序<把大的往后交换>，剩下的那个就是最小的)

        //二、和插入排序版本2比较：
        //A.冒泡排序是不用管后边排好顺序的， 版本2这种
        //插入排序是不用管后边还未插入的数(比如第一次的,1,4)
        //B.不过过程和代码都比较相似(有些像倒着写的冒泡排序)：
        //冒泡排序的if条件不能合并到循环条件中，插入排序的if条件可以合并到循环条件中


//        //{90, 69, 6, 66, 55}
//        //1.求数组中的最大值: 拿着相邻两个元素进行比较如果前边大就交换
//        //经过j=0,j=1,j=2,j=3四次交换，最后把90交换到最后成了 69,6,66,55,90
//        for (int j = 0; j < 4; j++) {
//            if(arr[j]>arr[j+1]){
//                int t=arr[j];
//                arr[j]=arr[j+1];
//                arr[j+1]=t;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
//
//        //[69, 6, 66, 55,| 90]//上一轮已经给90找好位置了
//        //2.求69, 6, 66, 55中的最大值: 拿着相邻两个元素(第j位和第j+1位比较)进行比较
//        //如果前边大就交换(但是排除第4位的90,j最大取2)
//        //经过j=0,j=1,j=2三次交换，最后把69交换到90前边了，最后成了 6,66,55,69,90
//        for (int j = 0; j < 3; j++) {
//            if(arr[j]>arr[j+1]){
//                int t=arr[j];
//                arr[j]=arr[j+1];
//                arr[j+1]=t;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
//
//
//        //[6, 66, 55, |69, 90]//上两轮已经给69,90找好位置了
//        //3.求6, 66, 55中的最大值: 拿着相邻两个元素(第j位和第j+1位比较)进行比较
//        //如果前边大就交换(但是排除第3位的69和第4位的90,j最大取1)
//        //经过j=0,j=1 两次交换，最后把66交换到69前边了，最后成了 6,55,66,69,90
//        //注意：这里j=0时用6和66比较发现不需要交换，此时还不能结束比较(不能结束循环)
//        //因为还要拿66和55比较，所以不能把arr[j]>arr[j+1]合并到循环条件中。
//        for (int j = 0; j < 2; j++) {
//            if(arr[j]>arr[j+1]){
//                int t=arr[j];
//                arr[j]=arr[j+1];
//                arr[j+1]=t;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
//
//
//        //[6, 55, |66, 69, 90]//上三轮已经给66,69,90找好位置了
//        //4.求6, 55中的最大值: 拿着相邻两个元素(第j位和第j+1位比较)进行比较
//        //如果前边大就交换(但是排除第2位的66第3位的69和第4位的90,j最大取0)
//        //经过j=0 一次交换，没有交换，最终6, 55, 66, 69, 90就是升序排列的结果
//        for (int j = 0; j < 1; j++) {//如果要降序排列就把arr[j]>arr[j+1]
//            if(arr[j]>arr[j+1]){     //改成arr[j]<arr[j+1]//把小的往后交换
//                int t=arr[j];
//                arr[j]=arr[j+1];
//                arr[j+1]=t;
//            }
//        }
//        System.out.println(Arrays.toString(arr));


        //最终经过4轮比较对数组升序排序了
        //(第零轮比较了4次，第一轮比较了3次，第二轮比较了2次，第三轮比较了1次，)
        //冒泡排序最终代码：
        for(int i=0;i<4;i++) { //i=0 j=4    i=1 j=3   i=2 j=2    i=3 j=1
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));//

    }
}

二、插入排序：

版本1：

public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {90, 69, 6, 66, 55};

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 99);
        }
        System.out.println(Arrays.toString(arr));

/*        //  {90,|69,6,66,55};
        //在第一部分90给69找合适位置(如果后边的69小，就把前边的90 往后复制变成90，90，
        //然后把小的69插入到合适位置<90原本的位置>，变成69,90)
        int i1,j1,t1=arr[1];
        for(j1=0;j1>=0&&arr[j1]>t1;j1--){
            arr[j1+1]=arr[j1];
        }
        arr[j1+1]=t1;



        //  {69,90|,6,66,55};
        //在第一部分69,90给6找合适位置(如果后边的6小，就把前边的69和90 往后复制，先复制90
        //变成69,90，90; 再复制69变成69,69,90;
        // 最后把小的6插入到合适位置<69原本的位置>，变成6,69,90)
        int i2,j2,t2=arr[2];
        for(j2=1;j2>=0&&arr[j2]>t2;j2--){
            arr[j2+1]=arr[j2];
        }
        arr[j2+1]=t2;


        //  [6, 69, 90|, 66, 55]
        //在第一部分6, 69, 90给66找合适位置(如果后边的66小，就把前边的69和90 往后复制，先
        //复制90变成6,69,90，90; 再复制69变成6,69,69,90;
        //最后把小的66插入到合适位置<69原本的位置>，变成6,66,69,90)
        int i3,j3,t3=arr[3];
        for(j3=2;j3>=0&&arr[j3]>t3;j3--){
            arr[j3+1]=arr[j3];
        }
        arr[j3+1]=t3;



        //  [6, 66, 69, 90|,55]
        //在第一部分6, 66, 69, 90给55找合适位置(如果后边的55小，就把前边的66,69和90 往后复制，
        //先复制90变成6,66,69,90,90; 再复制69变成6,66,69,69,90;
        //再复制66变成6,66,66,69,90;最后把小的55插入到合适位置<66原本的位置>，变成
        //6,55,66,69,90)
        int i4,j4,t4=arr[4];//在5行代码外边再增加一个外层for训啊还，来控制"t2=arr[4]" 中
        //方括号中的4 和  "j3=3"中的3的改变 实现将四个循环总结为一个循环
        for(j4=3;j4>=0&&arr[j4]>t4;j4--){//如下边的循环
            arr[j4+1]=arr[j4];
        }
        arr[j4+1]=t4;*/


        //插入排序最终代码
        for (int i = 1; i < arr.length; i++) {
            int j, t = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > t; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = t;
        }
        System.out.println(Arrays.toString(arr));
    }
}

版本2：

//插入排序
public class InsertSortDemo {
    public static void main(String[] args) {
        //int [] a={9,3,1,4};
        int [] a={1,9,4,5};



        //一、过程概述：
        //把数组分为两部分，前半部分是排好序的，后半部分是待排序的。
        //拿着后半部分的每个数去前半部分中找到合适位置插入(和前半部分的每个数比较，
        //如果比前半部分被比较的数小就交换)

        //二、和插入排序版本2比较：
        //A.冒泡排序是不用管后边排好顺序的， 版本2这种
        //插入排序是不用管后边还未插入的数(比如第一次的,1,4)
        //B.不过过程和代码都比较相似(有些像倒着写的冒泡排序)：
        //冒泡排序的if条件不能合并到循环条件中，插入排序的if条件可以合并到循环条件中
        

//        //  {1|,9,4,5}
//        //1.在第一部分1给9找合适位置插入(如果后边的9小，就和前边的1交换)
//        for(int j=1;j>=1;j--) {
//            if(a[j]<a[j-1]) {
//                int t = a[j];
//                a[j] = a[j - 1];
//                a[j - 1] = t;
//            }
//        }
//        System.out.println(Arrays.toString(a));
//
//
//        //  {1, 9|, 4, 5}
//        //2.在第一部分1,9给4找合适位置插入(如果后边的4小，就和前边的数交换，变成1,4,9
//        for(int j=2;j>=1;j--) {
//            if(a[j]<a[j-1]) {
//                int t = a[j];
//                a[j] = a[j - 1];
//                a[j - 1] = t;
//            }
//        }
//        System.out.println(Arrays.toString(a));
//
//
//
//        //  {1,4,9|,5}
//        //3.在第一部分1,4,9给5找合适位置(如果后边的5小，就和前边的数交换，变成1,4,5,9
//        //因为5和9比较发现需要交换(把5插入到9前边)变成1,4,5,9，然后拿5和4比较发现不需要
//        //交换此时就可以结束比较了(把a[j]<a[j-1]合并到循环条件中来终止循环的执行)
//        //(因为每次是把小的往前放，既然5比4大不能放到4的前边，那肯定也不能放到1的前边了
//        //<因为4的前边都比4小>)
//      /*for(int j=3;j>=1;j--) {
//            if(a[j]<a[j-1]) {
//                int t = a[j];
//                a[j] = a[j - 1];
//                a[j - 1] = t;
//            }
//        }
//        System.out.println(Arrays.toString(a));*/
//        //把a[j]<a[j-1]合并到循环条件中之后的代码
//        for(int j=3; j>=1 && a[j]<a[j-1]; j--) {
//                int t = a[j];
//                a[j] = a[j - 1];
//                a[j - 1] = t;
//        }
//        System.out.println(Arrays.toString(a));



        //插入排序最终代码
        for (int i = 1; i < a.length; i++) {
            for(int j=i; j>=1 && a[j]<a[j-1]; j--) {
                int t = a[j];
                a[j] = a[j - 1];
                a[j - 1] = t;
            }
        }
        System.out.println(Arrays.toString(a));

    }
}

选择排序，快速排序，希尔排序，堆排序等其他排序方式自己找资料学习

-------------------------------------------------

zhaoyq-2022-03-08 14:25