冒泡排序/对查询出来的list集合的某一字段进行排序

目录

1.冒泡排序的思想：

2.代码实现

3.实现结果

4.对查询出来的list集合的某一字段进行排序

---

1.冒泡排序的思想：

             冒泡拍寻是最为出名的排序算法之一，总共又八大paixu 冒泡排序的代码是：两层循环，外层冒泡轮数，里层依次比较 时间复杂度为O(n2) 

   1.比较相邻的两个元素，如果第一个元素大于第二个元素，就交换位置
    2.对每一对相邻的元素再做同样的比较，从最开始的一对到结尾的一对完成全部的比较。最后一个元素肯定最大的
    3.对剩下的元素重复第二步操作，直到只有一个元素为止

优化想法1：如果原数组中存在相同的数字就不需要比较了 那么可以少比较一次

2.代码实现

public class MaoPaoPaiXu {
    /*
        冒泡拍寻是最为出名的排序算法之一，总共又八大paixu
        冒泡排序的代码是：两层循环，外层冒泡轮数，里层依次比较
        时间复杂度为O(n2)
        如何优化呢？
            优化想法1：如果原数组中存在相同的数字就不需要比较了
           那么可以少比较一次
     */
    public static void main(String[] args) {
        int[] a = {12,15,46,15,69,35,25,36};
        int[] b = sort(a);
        System.out.println("排序前"+Arrays.toString(a));
    }
    public static int[] sort(int[] arr){
        /*
            1、比较数组中相邻的两个元素，如果二者有大小则交换
            2、每一次比较，都会比较出最大或者最小，那么下一轮可以少比较一次
            3、依次循环，直到结束
         */
        //用来存放数据元素的临时变量
        int tempMap = 0;
        //for循环遍历  外层循环 判断一个数据总共要比较大小多少次
        for(int i = 0;i<arr.length-1;i++){
            boolean flag = false;//通过标志控制循环
            //System.out.println("外层循环"+i);
            //内层循环 判断上一次比较完还需要比较多少次
            for(int j = 0;j<arr.length-1-i;j++){
               // System.out.println("内层循环" + j);
                //比较数据元素的大小 如果后一个数比前一个数大则交换位置
                if(arr[j+1]>arr[j]){
                    //进行交换
                    tempMap= arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=tempMap;
                    flag = true;//当两个元素进行比较，那么两个元素不相同为真
                }
            }
            System.out.println("第"+i+"次"+Arrays.toString(arr));
            if(flag==false){//如果两个元素相同就不会进行上面的比较
                break;//结束本次循环
            }
        }
        return arr;
    }
}

3.实现结果

4.对查询出来的list集合的某一字段进行排序

//查询所有公司名称
 List<Map> gsList = sxjtByGsNameService.queryGsList();
//创建一个新的gsMapList 集合
   List<Map> gsMapList = new ArrayList<>();
//对查询出的所有公司进行遍历
        for(int i=0;i<gsList.size();i++){
            Map map1 = gsList.get(i);
            params.setGs_name((String) gsList.get(i).get("gs_name"));
            Map map = sxjtByGsNameService.getGsXtyxZhiBiao(params);
//添加到gsMapList 集合
            gsMapList.add(map);
        }
//创建一个临时变量tempMap 用于交换元素的位置
Map tempMap = null;
//使用两层循环嵌套遍历gsMapList列表。
//外部循环控制比较的轮数，内部循环进行相邻元素的比较和交换。
       for(int z =0;z<gsMapList.size();z++){
            int rank = 1;
          for(int j=0;j<gsMapList.size()-1-z;j++){
              tempMap = gsMapList.get(j);
                //在内部循环中，首先通过get方法获取当前元素和下一个元素的"zongfenzhi"属性值，并将其转化为double类型
                double zfz = Double.valueOf(String.valueOf(gsMapList.get(j).get("zongfenzhi")) );
              double zfz1 = Double.valueOf(String.valueOf(gsMapList.get(j+1).get("zongfenzhi")) );
                //如果小于
              if (zfz < zfz1){
                 gsMapList.get(j+1).put("rank",rank); //将下一个元素的"rank"属性设为当前轮数加1
                gsMapList.set(j,gsMapList.get(j+1));//更新列表中的元素顺序，将当前元素设置为列表中下一个位置的元素
                tempMap.put("rank",rank+1);//将当前元素的"rank"属性设为当前轮数
                gsMapList.set(j+1,tempMap);//将临时变量tempMap放置到列表中下一个位置
             }else{//否则将当前元素和下一个元素的"rank"属性分别设为当前轮数和当前轮数加1
                gsMapList.get(j).put("rank",rank);
                gsMapList.get(j+1).put("rank",rank+1);
                }
                rank = rank+1;//每完成一轮内部循环，更新rank的值为当前轮数加1
            }
        }

该段代码是对一个包含"zongfenzhi"属性的列表进行排序，并为每个元素添加一个"rank"属性。

具体步骤如下：

1. 创建一个临时变量tempMap，用于交换元素的位置。

2. 使用两层循环嵌套遍历gsMapList列表。外部循环控制比较的轮数，内部循环进行相邻元素的比较和交换。

3. 在内部循环中，首先通过get方法获取当前元素和下一个元素的"zongfenzhi"属性值，并将其转化为double类型。

4. 如果当前元素的"zongfenzhi"小于下一个元素的"zongfenzhi"，则执行以下操作：

   a. 将下一个元素的"rank"属性设为当前轮数加1，即gsMapList.get(j+1).put("rank", rank)。

   b. 更新列表中的元素顺序，将当前元素设置为列表中下一个位置的元素，即gsMapList.set(j, gsMapList.get(j+1))。

   c. 将当前元素的"rank"属性设为当前轮数，即tempMap.put("rank", rank)。

   d. 将临时变量tempMap放置到列表中下一个位置，即gsMapList.set(j+1, tempMap)。

5. 否则（当前元素不小于下一个元素），将当前元素和下一个元素的"rank"属性分别设为当前轮数和当前轮数加1，即gsMapList.get(j).put("rank", rank)和gsMapList.get(j+1).put("rank", rank+1)。

6. 每完成一轮内部循环，更新rank的值为当前轮数加1。

7. 返回排序后的gsMapList列表。

这段代码采用的是冒泡排序算法，在每次内部循环中，通过比较相邻元素的大小并交换位置，将较大（或较小）的元素逐渐“冒泡”到最右侧（或最左侧），从而实现排序。同时，将每个元素所在的位置作为"rank"属性的值，以表示其排名。排序结果为按照"zongfenzhi"属性从大到小的顺序，并为每个元素添加了对应的"rank"属性。

没有一个冬天不可逾越，没有一个春天不会来临。最慢的步伐不是跬步，而是徘徊，最快的脚步不是冲刺，而是坚持~