常见排序及其改进方案

news2024/11/24 21:05:00

常见排序及其改进方案

快速排序

思想：

找到一个基准，通常来说选取左边第一个元素

定义中间变量temp接收基准值

两个哨兵i,j分别从数组左端、右端进行扫描

  • (a)先从右端开始扫描：哨兵j先从右端开始扫描，确保右端元素>基准值，当发现元素<基准值则对该值进行交换（当前元素赋值给哨兵i所在位置元素），此时哨兵j停止扫描

  • (b)当哨兵j停止扫描后：哨兵i从左端开始扫描，确保左端元素<基准值，当发现元素>基准值则对该值进行交换（当前元素赋值给哨兵j所在位置元素），此时哨兵i停止扫描

此后哨兵i，j继续从当前位置向左、向右继续扫描，继续执行以上(a)(b)操作，直到哨兵i,j相遇，然后将基准值赋值给哨兵i,j所在元素的位置（基准归位），则执行完一趟扫描。以此类推，即可完成排序。

请添加图片描述

快速排序：

 public static void quickSort(int[] array,int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){
            temp = array[left];
            while (left != right){
                while (left < right && array[right] >= temp){
                    right--;
                }
                array[left] = array[right];
                while (left < right && array[left] <= temp){
                    left ++;
                }
                array[right] = array[left];
            }
            //基准归位
            array[right] = temp;
            quickSort(array,_left,left - 1);
            quickSort(array,right + 1,_right);
        }
    }

示例：

public class QuickSort {
    public static void main(String[] args) {
        quickSort(Swap.array,0,Swap.array.length - 1);
        Swap.print(Swap.array);
    }

    /**
     * 快速排序
     * 两个哨兵i,j分别从数组左端、右端进行扫描
     *
     * (a)先从右端开始扫描：哨兵j先从右端开始扫描，确保右端元素>基准值，当发现元素<基准值则对该值进行交换（当前元素赋值给哨兵i所在位置元素），此时哨兵j停止扫描
     * (b)当哨兵j停止扫描后：哨兵i从左端开始扫描，确保左端元素<基准值，当发现元素>基准值则对该值进行交换（当前元素赋值给哨兵j所在位置元素），此时哨兵i停止扫描
     *
     * 此后哨兵i，j继续从当前位置向左、向右继续扫描，继续执行以上(a)(b)操作，直到哨兵i,j相遇，然后将基准值赋值给哨兵i,j所在元素的位置（基准归位），则执行完一趟扫描。以此类推，即可完成排序。
     * @param array
     */
    public static void quickSort(int[] array,int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){
            temp = array[left];
            while (left != right){
                while (left < right && array[right] >= temp){
                    right--;
                }
                array[left] = array[right];
                while (left < right && array[left] <= temp){
                    left ++;
                }
                array[right] = array[left];
            }
            //基准归位
            array[right] = temp;
            quickSort(array,_left,left - 1);
            quickSort(array,right + 1,_right);
        }
    }
}

工具：

public class Swap {

    /**
     * 数组
     */
    static int[] array = {8,2,5,9,1,3,10,22,5,87,100,7,94,4};


    /**
     * 交换
     * @param array 数组
     * @param x 交换元素下标
     * @param y 交换元素下标
     */
    public static void swap(int[] array,int x,int y){
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }

    /**
     * 打印数组元素 遍历
     * @param array
     */
    public static void print(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(" " + array[i]);
        }
    }
}

算法集合gitee项目：算法集合
目录：src/main/java/com/torlesse/leetcode/algorithm/common/QuickSort.java在这里插入图片描述

选择排序以及改进

思想：比较选出最小的元素进行替换，每一次遍历最小元素归位
请添加图片描述
选择排序：

/**
     * 选择排序
     * 思想：每次排序选出最小值 然后进行交换
     * @param array
     */
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            //记录最小元素位置 pos
            int pos = i;
            for (int j = i; j < array.length - 1; j++) {
                if(array[pos] > array[j]){
                    pos = j;
                }
            }
            Swap.swap(array,i,pos);
        }
    }

改进：

 /**
     * 改进
     * 每一次最小 最大元素归位
     * @param array
     */
    public static void selectSort2(int[] array){
        int len = array.length - 1;
        for (int i = 0; i <= len; i++) {
            //记录最小元素位置 minPos
            int minPos = i;
            //记录最大元素位置 maxPos
            int maxPos = i;
            for (int j = i; j <= len; j++) {
                if(array[minPos] > array[j]){
                    minPos = j;
                }
                if(array[maxPos] < array[j]){
                    maxPos = j;
                }
            }
            //最小元素归位
            Swap.swap(array,i,minPos);
            //最大元素归位
            Swap.swap(array,len,maxPos);
            len --;
        }
    }

示例：

public class SelectSort {
    public static void main(String[] args) {
//        selectSort(Swap.array);
        selectSort2(Swap.array);
        Swap.print(Swap.array);
    }

    /**
     * 选择排序
     * 思想：每次排序选出最小值 然后进行交换
     * @param array
     */
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            //记录最小元素位置 pos
            int pos = i;
            for (int j = i; j < array.length - 1; j++) {
                if(array[pos] > array[j]){
                    pos = j;
                }
            }
            Swap.swap(array,i,pos);
        }
    }

    /**
     * 改进
     * 每一次最小 最大元素归位
     * @param array
     */
    public static void selectSort2(int[] array){
        int len = array.length - 1;
        for (int i = 0; i <= len; i++) {
            //记录最小元素位置 minPos
            int minPos = i;
            //记录最大元素位置 maxPos
            int maxPos = i;
            for (int j = i; j <= len; j++) {
                if(array[minPos] > array[j]){
                    minPos = j;
                }
                if(array[maxPos] < array[j]){
                    maxPos = j;
                }
            }
            //最小元素归位
            Swap.swap(array,i,minPos);
            //最大元素归位
            Swap.swap(array,len,maxPos);
            len --;
        }
    }
}

工具：

public class Swap {

    /**
     * 数组
     */
    static int[] array = {8,2,5,9,1,3,10,22,5,87,100,7,94,4};


    /**
     * 交换
     * @param array 数组
     * @param x 交换元素下标
     * @param y 交换元素下标
     */
    public static void swap(int[] array,int x,int y){
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }

    /**
     * 打印数组元素 遍历
     * @param array
     */
    public static void print(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(" " + array[i]);
        }
    }
}

算法集合gitee项目：算法集合
目录：src/main/java/com/torlesse/leetcode/algorithm/common/SelectSort.java

插入排序

思想：用后一项元素与当前项进行比较，如果后一项<当前项，交换位置，保证每一次遍历最小元素归位

请添加图片描述
插入排序：

/**
     * 插入排序
     * 用后一项元素与当前项进行比较，如果后一项<当前项，交换位置，保证每一次遍历最小元素归位
     * 此处：从小到大排序
     * @param array
     */
    public static void insertSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            //后一项元素 j = i +1;
            for (int j = i + 1; j > 0 ; j--) {
                //后一项与当前项比较
                if(array[j] < array[j - 1]){
                    Swap.swap(array,j,j-1);
                }
            }
        }
    }

改进：

 /**
     * 改进
     * 第一次遍历时直接从i=1开始，默认第0项已经归位
     * @param array
     */
    public static void insertSort2(int[] array){
        //i=1 : 默认第0项已经归位
        for (int i = 1; i < array.length; i++) {
            int j = 0;
            int current =  array[i];
            // i-1 当前项的上一项，上一项与当前项比较满足: array[j] > current
            for (j = i - 1; j >= 0 && array[j] > current ; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = current;
        }
    }

示例：

public class InsertSort {
    public static void main(String[] args) {
//        insertSort(Swap.array);
        insertSort2(Swap.array);
        Swap.print(Swap.array);
    }

    /**
     * 插入排序
     * 用后一项元素与当前项进行比较，如果后一项<当前项，交换位置，保证每一次遍历最小元素归位
     * 此处：从小到大排序
     * @param array
     */
    public static void insertSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            //后一项元素 j = i +1;
            for (int j = i + 1; j > 0 ; j--) {
                //后一项与当前项比较
                if(array[j] < array[j - 1]){
                    Swap.swap(array,j,j-1);
                }
            }
        }
    }

    /**
     * 改进
     * 第一次遍历时直接从i=1开始，默认第0项已经归位
     * @param array
     */
    public static void insertSort2(int[] array){
        //i=1 : 默认第0项已经归位
        for (int i = 1; i < array.length; i++) {
            int j = 0;
            int current =  array[i];
            // i-1 当前项的上一项，上一项与当前项比较满足: array[j] > current
            for (j = i - 1; j >= 0 && array[j] > current ; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = current;
        }
    }
}

工具:

public class Swap {

    /**
     * 数组
     */
    static int[] array = {8,2,5,9,3,10,22,1,87};


    /**
     * 交换
     * @param array 数组
     * @param x 交换元素下标
     * @param y 交换元素下标
     */
    public static void swap(int[] array,int x,int y){
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }

    /**
     * 打印数组元素 遍历
     * @param array
     */
    public static void print(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(" " + array[i]);
        }
    }
}

算法集合gitee项目：算法集合
目录：src/main/java/com/torlesse/leetcode/algorithm/common/InsertSort.java

冒泡排序

相信大学学习算法的时候都会先学习冒泡算法，时间复杂度是O（n²）
思想：遍历比较进行交换
请添加图片描述

冒泡排序

 /**
     * 冒泡算法
     */
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1; j++) {
                //从小到大排序，最大元素先归位
                if(array[j] > array[j + 1]){
                    Swap.swap(array,j,j+1);
                }
            }
        }
    }

改进1：

  /**
     * 冒泡算法改进
     * @param array
     */
    public static void bubbleSort2(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            // 改进地方, j < array.length - 1 - i 因为最大元素已经归位了
            for (int j = 0; j < array.length - 1 - i; j++) {
                //从小到大排序，最大元素先归位
                if(array[j] > array[j + 1]){
                    Swap.swap(array,j,j+1);
                }
            }
        }
    }

改进2：

 /**
     * bubbleSort2 基础上进一步改进
     * 指针的思想解决问题，上述例子是左边元素归位，现在是两头同时归位
     * @param array
     */
    public static void bubbleSort3(int[] array){
        int left = 0;
        int right = array.length - 1;

        while(left < right){
            //最大元素归位
            for (int i = left; i < right; i++){
                if(array[i] > array[i + 1]){
                    Swap.swap(array,i+1,i);
                }
            }
            right --;
            //最小元素归位
            for (int i = right; i > left; i--) {
                if(array[i] < array[i - 1]){
                    Swap.swap(array,i,i-1);
                }
            }
            left ++;
        }
    }

示例：

public class BubbleSort {

    public static void main(String[] args) {
//        bubbleSort(Swap.array);
//        bubbleSort2(Swap.array);
        bubbleSort3(Swap.array);
        Swap.print(Swap.array);
    }

    /**
     * 冒泡算法
     */
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1; j++) {
                //从小到大排序，最大元素先归位
                if(array[j] > array[j + 1]){
                    Swap.swap(array,j,j+1);
                }
            }
        }
    }

    /**
     * 冒泡算法改进
     * @param array
     */
    public static void bubbleSort2(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            // 改进地方, j < array.length - 1 - i 因为最大元素已经归位了
            for (int j = 0; j < array.length - 1 - i; j++) {
                //从小到大排序，最大元素先归位
                if(array[j] > array[j + 1]){
                    Swap.swap(array,j,j+1);
                }
            }
        }
    }

    /**
     * bubbleSort2 基础上进一步改进
     * 指针的思想解决问题，上述例子是左边元素归位，现在是两头同时归位
     * @param array
     */
    public static void bubbleSort3(int[] array){
        int left = 0;
        int right = array.length - 1;

        while(left < right){
            //最大元素归位
            for (int i = left; i < right; i++){
                if(array[i] > array[i + 1]){
                    Swap.swap(array,i+1,i);
                }
            }
            right --;
            //最小元素归位
            for (int i = right; i > left; i--) {
                if(array[i] < array[i - 1]){
                    Swap.swap(array,i,i-1);
                }
            }
            left ++;
        }
    }
}

工具：

public class Swap {

    /**
     * 数组
     */
    static int[] array = {8,2,5,9,3,10,22,1,87};


    /**
     * 交换
     * @param array 数组
     * @param x 交换元素下标
     * @param y 交换元素下标
     */
    public static void swap(int[] array,int x,int y){
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }

    /**
     * 打印数组元素 遍历
     * @param array
     */
    public static void print(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(" " + array[i]);
        }
    }
}

算法集合gitee项目：算法集合
目录：src/main/java/com/torlesse/leetcode/algorithm/common/BubbleSort.java

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/685115.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Collapse折叠面板（antd-design组件库）展示所有配置选项和onChange的作用

Collapse折叠面板（antd-design组件库）展示所有配置选项和onChange的作用

1.Collapse折叠面板 可以折叠/展开的内容区域。 2.何时使用 对复杂区域进行分组和隐藏&#xff0c;保持页面的整洁。 手风琴 是一种特殊的折叠面板&#xff0c;只允许单个内容区域展开。 组件代码来自&#xff1a; 分页 Pagination - Ant Design 3.本地验证前的准备 参考文章【…
阅读更多...
Jmeter(二) - 从入门到精通 - 创建测试计划（Test Plan）（详解教程）

Jmeter(二) - 从入门到精通 - 创建测试计划（Test Plan）（详解教程）

1.简介 上一篇文章已经教你把JMeter的测试环境搭建起来了&#xff0c;那么这一篇我们就将JMeter启动起来&#xff0c;一睹其芳容&#xff0c;首先我给大家介绍一下如何来创建一个测试计划&#xff08;Test Plan&#xff09;。 2.创建一个测试计划&#xff08;Test Plan&#x…
阅读更多...
前端实现pdf，图片，word文件预览

前端实现pdf，图片，word文件预览

前端实现文件预览功能 需求&#xff1a;实现一个在线预览pdf、excel、word、图片等文件的功能。 介绍&#xff1a;支持pdf、xlsx、docx、jpg、png、jpeg。 以下使用Vue3代码实现所有功能&#xff0c;建议以下的预览文件标签可以在外层包裹一层弹窗。 图片预览 iframe标签能够将…
阅读更多...
Learning to cluster in order to transfer across domains and tasks (ICLR 2018)

Learning to cluster in order to transfer across domains and tasks (ICLR 2018)

Learning to cluster in order to transfer across domains and tasks (ICLR 2018) 摘要 这篇论文提出一个进行跨域/任务的迁移学除了习任务&#xff0c;并将其作为一个学习聚类的问题。除了特征&#xff0c;我们还可以迁移相似度信息&#xff0c;并且这是足以学习一个相似度…
阅读更多...
Git的常用命令,及还原文件的指定版本，及分支管理

Git的常用命令,及还原文件的指定版本，及分支管理

一.git 常用命令 1.创建一个空的Git仓库或重新初始化一个现有仓库 git init 2.执行 clone 命令默认会拉取远程仓库的所有内容 git clone 3.显示版本库和暂存区的状态 git status 4.将该文件添加到暂存区 git add . 5.将git add 之后文件在暂存区之后的提交 git commit -m 提…
阅读更多...
【Java高级语法】（十七）Stream流式编程：释放流式编程的效率与优雅，狂肝万字只为全面讲透Stream流！~

【Java高级语法】（十七）Stream流式编程：释放流式编程的效率与优雅，狂肝万字只为全面讲透Stream流！~

Java高级语法详解之Stream流 1️⃣ 概念及特征2️⃣ 优势和缺点3️⃣ 使用3.1 语法3.2 常用API详解3.3 案例 4️⃣ 应用场景5️⃣ 使用技巧6️⃣ 并行流 ParallelStream&#x1f33e; 总结 1️⃣ 概念及特征 Java的Stream流是在Java 8中引入的一种用于处理集合数据的功能强大且…
阅读更多...
chatgpt赋能python：PythonGUI编程简介

chatgpt赋能python：PythonGUI编程简介

Python GUI编程简介 Python是一款功能强大的开源编程语言&#xff0c;在很多领域都有广泛的应用。与其他编程语言相比&#xff0c;Python具有易于学习、易于阅读和易于维护等优点&#xff0c;因此成为许多程序员选择的首选语言之一。Python还提供了许多各种类型的GUI库&#x…
阅读更多...
HHU云计算期末复习（上）Google、Amazon AWS、Azure

HHU云计算期末复习（上）Google、Amazon AWS、Azure

文章目录 第一章 概论第二章 Google 云计算2.1 Google文件系统&#xff08;GFS&#xff09;2.2 MapReduce和Hadoop2.3 分布式锁服务Chubby2.4 分布式结构化数据表Bigtable存储形式主服务器子表Bigtable 相关优化技术 2.5 分布式存储系统MegastoreMegastoreACID语义基本架构核心…
阅读更多...
圆和矩形是否有重叠

圆和矩形是否有重叠

&#x1f388; 算法并不一定都是很难的题目&#xff0c;也有很多只是一些代码技巧&#xff0c;多进行一些算法题目的练习&#xff0c;可以帮助我们开阔解题思路&#xff0c;提升我们的逻辑思维能力&#xff0c;也可以将一些算法思维结合到业务代码的编写思考中。简而言之&#…
阅读更多...
Android设计模式—桥接模式

Android设计模式—桥接模式

1.桥接模式 桥接模式是一种结构型设计模式&#xff0c;它通过将抽象部分与实现部分分离来解耦。它使用接口作为桥梁&#xff0c;将一个抽象类与其实现类的代码独立开来&#xff0c;从而使它们可以各自独立地变化。桥接模式的核心思想是“组合优于继承”。 简单来讲&#xff0…
阅读更多...
RecyclerView性能优化之异步预加载

RecyclerView性能优化之异步预加载

RecyclerView性能优化之异步预加载 前言 首先需要强调的是&#xff0c;这篇文章是对我之前写的《浅谈RecyclerView的性能优化》文章的补充&#xff0c;建议大家先读完这篇文章后再来看这篇文章&#xff0c;味道更佳。 当时由于篇幅的原因&#xff0c;并没有深入展开讲解&…
阅读更多...
【TCP/IP】广播 - 定义、原理及编程实现

【TCP/IP】广播 - 定义、原理及编程实现

目录 广播 广播的原理及形式 广播的编程与实现 套接字选项设置 发送者 接收者 拓展资料 广播 广播(Broadcast)是指封包在计算机网络中传输时&#xff0c;目的地址为网络中所有设备的一种传输方式。这里所说的“所有设备”也被限定在一个范围之中&#xff0c;这个范围被称…
阅读更多...
Android 13(T) - binder阅读（4）- 使用ServiceManager注册服务2

Android 13(T) - binder阅读（4）- 使用ServiceManager注册服务2

上一篇笔记我们看到了binder_transaction&#xff0c;这个方法很长&#xff0c;这一篇我们将把这个方法拆分开来看binder_transaction做了什么&#xff0c;从而学习binder是如何跨进程通信的。 1 binder_transaction static void binder_transaction(struct binder_proc *proc…
阅读更多...
Java 面试知识点合集

Java 面试知识点合集

一、基础篇 1.1 java基础 1.面向对象的特征&#xff1a;封装、继承、多态 (1).封装&#xff1a;属性能够描述事物的特征&#xff0c;方法能够描述事物的动作。封装就是把同一类事物的共性&#xff08;包括属性和方法&#xff09;归到同一类中&#xff0c;方便使用。 封装的…
阅读更多...
音视频处理工具FFmpeg与Java结合的简单使用

音视频处理工具FFmpeg与Java结合的简单使用

一、什么是FFmpeg FFmpeg是一套可以用来记录、转换数字音频、视频&#xff0c;并能将其转化为流的开源计算机程序。采用LGPL或GPL许可证。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec&#xff0c;为了保证高可移植性和编解…
阅读更多...
chatgpt赋能python：Python编写n!——让阶乘计算变得更简单

chatgpt赋能python：Python编写n!——让阶乘计算变得更简单

Python编写n!——让阶乘计算变得更简单 阶乘是高中数学中常见的运算&#xff0c;它的含义是从1到n的所有正整数相乘&#xff0c;用叹号表示为n!。例如&#xff0c;5! 1 2 3 4 5 120。在计算机编程中&#xff0c;我们常常需要计算阶乘。而Python作为一门便捷易用的编程语…
阅读更多...
chatgpt赋能python：Python编程自动化办公–提升工作效率的利器

chatgpt赋能python：Python编程自动化办公–提升工作效率的利器

Python编程自动化办公 – 提升工作效率的利器 越来越多企业对协作和业务流程的优化提高了要求&#xff0c;自动化办公就是其中之一&#xff0c;而Python编程能够帮助我们实现高效自动化办公。Python是一种多用途&#xff0c;高效的编程语言&#xff0c;被广泛应用于应用程序开…
阅读更多...
UE4/5动画系列（3.通过后期处理动画蓝图的头部朝向Actor，两种方法：1.通过动画层接口的look at方法。2.通过control rig的方法）

UE4/5动画系列（3.通过后期处理动画蓝图的头部朝向Actor，两种方法：1.通过动画层接口的look at方法。2.通过control rig的方法）

目录 蓝图 点积dot Yaw判断 后期处理动画蓝图 动画层接口 ControlRig: 蓝图 首先我们创建一个actor类&#xff0c;这个actor类是我们要看的东西&#xff0c;actor在哪&#xff0c;我们的动物就要看到哪里&#xff08;同样&#xff0c;这个我们也是做一个父类&#xff0…
阅读更多...
chatgpt赋能python：Python程序员的秘密武器：给不及格成绩加分

chatgpt赋能python：Python程序员的秘密武器：给不及格成绩加分

Python程序员的秘密武器&#xff1a;给不及格成绩加分 Python是一个语法简洁、易学易用的编程语言&#xff0c;已经成为了很多程序员的首选语言。在学校中&#xff0c;很多学生选择学习Python作为他们的编程课程。然而&#xff0c;有时候即便是刻苦学习&#xff0c;踏实地完成…
阅读更多...
3D定制化开发工具HOOPS如何满足EDA设计需求？（上）

3D定制化开发工具HOOPS如何满足EDA设计需求？（上）

HOOPS SDK 是由 Tech Soft 3D 公司开发和提供的一款软件开发工具包。HOOPS SDK 为开发者提供了强大的3D图形渲染和交互功能&#xff0c;用于构建高性能的工程、设计和制造应用程序。其主要功能包括&#xff1a;3D 图形渲染、交互性、数据管理、算法和分析、可定制性等。 HOOPS…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023