数组的排序方法

简单选择排序:基本思想如下
    在要排序的数组中,选择出最小(或者最大)的一
    个数与第一个位置的数交换;然后在剩下的数当
    中再找最小(或最大)的与第二个位置的数交换
    依次类推,直到第n-1个元素(倒数第二个)和第
    n个元素(最后一个数)比较为止。

    简单选择排序

第一个元素先不动,剩下的元素中找最小值,再与第一位比较,小于第一位就交换

之后第二位不动,后面的找最小值,再比较交换,以此类推
          原始数据 {4,5,2,3,1}
          找出最小1  与4交换  {1,5,2,3,4}
          找出最小2  与5交换  {1,2,5,3,4}
          找出最小3  与5交换  {1,2,3,5,4}
          找出最小4  与5交换  {1,2,3,4,5}

//简单排序[4,5,2,3,1]

        int[] arr = {4,5,2,3,1};
        /*简单选择排序
          原始数据 {4,5,2,3,1}
          找出最小1  与4交换  {1,5,2,3,4}
          找出最小2  与5交换  {1,2,5,3,4}
          找出最小3  与5交换  {1,2,3,5,4}
          找出最小4  与5交换  {1,2,3,4,5}
        */
        for(int i=0;i<arr.length-1;i++){
            int index =i;//假设i最小值的下标
            boolean f = false;//定义一个标记
            for(int j=i+1;j<arr.length;j++){
                if(arr[index]>arr[j]){ 
                    index = j;//同时记录下标
                    f = true;//改变标记
                }
            }
            if(f){//查看标记,标记更改,说明需要交换
                int t = arr[i];
                arr[i] = arr[index];
                arr[index] = t;
                /*这样节省了一个空间,少定义了一个新的变量
                arr[i]=arr[i]+arr[index];
                arr[index] = arr[i]-arr[index]
                arr[i] = arr[i] -arr[index];
                */

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

数组的排序:
冒泡排序的基本思想:
   在要排序的数组中,对当前还未排好序的范围
   内的全部数,自上而下(自左到右)对相邻的两
   个数依次进行比较和调整,让较大的往下沉(
   或向右移),较小的往上冒(或向左移)。即:
   每当两相邻的数比较后他们的顺序与排序要求
   相反时,就将他们互换。

冒泡排序的每一步详情
          第一轮:找最大值
          4>5  false  {4,5,2,3,1}
          5>2  true   {4,2,5,3,1}
          5>3  true   {4,2,3,5,1}
          5>1  true   {4,2,3,1,5}--排出5
          第二轮:找第二大
          4>2  true   {2,4,3,1,5}
          4>3  true   {2,3,4,1,5}
          4>1  true   {2,3,1,4,5}--排出4
          第三轮:找第三大
          2>3  false  {2,3,1,4,5}
          3>1  true   {2,1,3,4,5}--排出3
          第四轮:找第四大
          2>1  true   {1,2,3,4,5}--排出2 

        /*冒泡排序[6,3,1,2,5,4]*/

         int[] arr1 = {6,3,1,2,5,4};
        /* 要求数组里的元素 按照从小到大排序*/
        for(int i=0;i<arr1.length-1;i++){
            System.out.println("第"+(i+1)+"轮");
            for(int j=0;j<arr1.length-1-i;j++){
                if(arr1[j]>arr1[j+1]){
                    int t = arr1[j];
                    arr1[j] = arr1[j+1];
                    arr1[j+1] = t;
                }
                System.out.println(Arrays.toString(arr1));
            }

冒泡排序的改进:
    对冒泡排序的常见的改进方法是 加入一个标志性的
    变量,用于标志某一轮排序过程中是否有数据交换,
    如果没有进行数据交换,则说明数据已经按照要求
    排列好,可立即结束排序,避免不必要的比较过程。

        /*冒泡排序[6,3,1,2,5,4]*/

         int[] arr1 = {6,3,1,2,5,4};
        /* 要求数组里的元素 按照从小到大排序*/
        for(int i=0;i<arr1.length-1;i++){
            System.out.println("第"+(i+1)+"轮");
            boolean f = true;//每一轮都定义一个开关
            for(int j=0;j<arr1.length-1-i;j++){
                if(arr1[j]>arr1[j+1]){
                    int t = arr1[j];
                    arr1[j] = arr1[j+1];
                    arr1[j+1] = t;
                    f = false;//发生交换,修改开关的状态
                }
                System.out.println(Arrays.toString(arr1));
            }
            //此轮结束,查看开关的状态
            if(f){
                //开关状态没变,说明已经完成了排序
                // 所以,不用继续下一轮了。
                break;
            }
        }

工具类Arrays里的排序方法:
   Arrays.sort(数组名):对基本数据类型的数组
            与引用类型的数组都可排序,底层定义了排序的规则。

        int[] arr1 = {5,3,2,4,1};
        System.out.println(Arrays.toString(arr1));

猜你喜欢

转载自blog.csdn.net/qq_38787854/article/details/81274099