排序总结

关注

原创最新推荐文章于 2022-07-16 12:10:04 发布 167 阅读 AI 写同款· GEO 优化 ›

AI市场风起云涌，ai浏览器是最佳的落地项目，现在ai市场的ai浏览器竞争加剧，得ai浏览器者得天下！从场景覆盖度来看，AI 浏览器已突破 “网页浏览” 的传统边界，成为连接个人生活、工作、消费的 “超级入口”，这是其他 AI 应用难以比拟的落地优势。在个人生活场景，AI 浏览器可基于用户行为数据主动提供服务 —— 当用户浏览马拉松赛事信息时，浏览器能自动生成 “训练计划 + 装备推荐 + 能量补给方案”，并关联预订链接；在工作场景，Opera Neon 浏览器已实现 “网页内容提取 - 代码生成 - 报告撰写” 的全流程辅助，开发者可直接在浏览器内完成网站开发初稿；阅读详情

冒泡排序

比较相邻两个元素，上浮轻(小)元素或者下沉重(大)的元素
例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}

  第一趟交换过程
       6 2 1 3 8 7 0
       2 6 1 3 8 7 0
       2 1 6 3 8 7 0
       2 1 3 6 8 7 0
       2 1 3 6 8 7 0
       2 1 3 6 7 8 0
       2 1 3 6 7 0 8

第一趟排序结果-> 2 1 3 6 7 0 8

        for (int i = 0; i < arrayNum.length; i++) {
            for (int j = 0; j < arrayNum.length - 1; j++) {
                if (arrayNum[j] > arrayNum[j + 1]) {
                    int temp = arrayNum[j];
                    arrayNum[j] = arrayNum[j + 1];
                    arrayNum[j + 1] = temp;
                }
            }
        }

每一趟的排序结果
         2 1 3 6 7 0 8
         1 2 3 6 0 7 8
         1 2 3 0 6 7 8
         1 2 0 3 6 7 8
         1 0 2 3 6 7 8
         0 1 2 3 6 7 8
         0 1 2 3 6 7 8

选择排序

   寻找最大或者最小的元素置于首或尾
  例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}
  第一趟
     找到最小的元素 0 与首位置元素6 交换
        0 2 1 3 8 7 6

        for(int i = 0; i < arrayNum.length; i ++){
            int min = i;
            for(int j = i + 1; j < arrayNum.length - i; j ++){
                if(arrayNum[i] > arrayNum[j]){
                    min = j;
                }
            }
            
            if(min != i){
                int temp = arrayNum[i];
                arrayNum[i] = arrayNum[min];
                arrayNum[min] = temp;
            }
        }

  每一趟的排序结果
         0 2 1 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6

插入排序

   对于未排序的元素在已经排好序的元素里找合适的位置插入
  例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}
   第一趟
     假设位置0前元素已将排好序，位置1元素开始寻找合适的位置插入
         2 6 1 3 8 7 0

        for (int i = 1; i < arrayNum.length; i++) {
            // 已排序的位置
            int j = i - 1;

            // 本次插入元素
            int current = arrayNum[i];

            // 寻找插入的位置
            while (j >= 0 && arrayNum[j] > current) {
                arrayNum[j + 1] = arrayNum[j];
                j --;
            }
            // 将当前需要插入的元素放入合适的位置
            arrayNum[j + 1] = current;
        }

   每一趟排序结果
         2 6 1 3 8 7 0
         1 2 6 3 8 7 0
         1 2 3 6 8 7 0
         1 2 3 6 8 7 0
         1 2 3 6 7 8 0
         0 1 2 3 6 7 8

快速排序

挑选基准，跟基准 pivot比较大小分区

例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}

交换原则：右边空位，左边取值比较；左边空位，右边取值比较

选取第一个元素为基准元素pivot

   第一趟交换过程, 6为基准，L位置为空
       空(L) 2 1 3 8 7 0( R)
       空位在左，基准跟R位置元素0相比，0 < 6，元素0填入L处空位，L+1
       0 2(L) 1 3 8 7 空( R)
       空位在右，跟L位置元素2相比，2 < 6 , L+1
       0 2 1(L) 3 8 7 空( R)
       空位在右，跟L位置元素1相比，1 < 6 , L+1
       0 2 1 3(L) 8 7 空( R)
       空位在右，跟L位置元素3相比，3 < 6 , L+1
       0 2 1 3 8(L) 7 空( R)
       空位在右，跟L位置元素8相比，8 > 6 ，元素8填入R处空位，R-1
       0 2 1 3 空(L) 7 ( R) 8
       空位在左，基准跟R位置元素7相比，7 > 6，R-1
       0 2 1 3 空 (LR) 7 8
       L R重合，基准写入空位
       0 2 1 3 6 7 8

第一趟排序结果-> 0 2 1 3 6 7 8

    public static void quickSort(int[] arrayNum, int start, int end) {
        int i = start;
        int j = end;

        int pivot = arrayNum[start];
        while (i < j) {
            while (i < j && pivot <= arrayNum[j]){
                j--;
            }
            if (i < j) {
                swap(arrayNum, i, j);
            }

            while (i < j && arrayNum[i] <= pivot) {
                i++;
            }
            if (i < j) {
                swap(arrayNum, i, j);
            }
        }

        if (i - 1 > start) {
            quickSort(arrayNum, start, i - 1);
        }
        if (j + 1 < end) {
            quickSort(arrayNum, j + 1, end);
        }
    }