十大排序算法

已于 2023-11-30 21:12:02 修改
阅读量23 收藏
点赞数
文章标签： java 算法 排序算法
于 2023-11-30 21:10:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64734128/article/details/134721785
版权

十大排序算法

1.冒泡排序

1.1.1 普通版本

public class BubbleSort1 {
    public static void bubbleSort1(int[] arr){
        if(arr.length < 2)
            return;
        for(int i = arr.length - 1;i > 0;i--){
            for(int j = 0;j < i;j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        bubbleSort1(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
}

1.1.2 优化版本

public class BubbleSort1OptimizedVersion {
    public static void bubbleSort1OptimizedVersion(int[] arr){
        if(arr.length < 2)
            return;
        //用于判断剩余未排序的数字是否有序
        boolean flag = true;
        for(int i = arr.length - 1;i > 0;i--){
            for(int j = 0;j < i;j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            //这一趟未发生交换，说明剩余数据已经有序
            if(flag)
                return;
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        bubbleSort1OptimizedVersion(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
}

1.2.1 递归版本

public class BubbleSort2 {
    public static void bubbleSort2(int[] arr,int length){
        if(length < 2)
            return;
        for(int i = 0;i < length-1;i++){
            if(arr[i] > arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        bubbleSort2(arr,length - 1);
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        bubbleSort2(arr,arr.length);
        for(int n:arr)
            System.out.print(n+" ");
    }
}

1.2.2 优化版本

public class BubbleSort2OptimizedVersion {
    public static void bubbleSort2OptimizedVersion(int[] arr,int length){
        if(length < 2)
            return;
        boolean flag = true;
        for(int i = 0;i < length-1;i++){
            if(arr[i] > arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
                flag = false;
            }
        }
        if(flag)
            return;
        bubbleSort2OptimizedVersion(arr,length - 1);
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        bubbleSort2OptimizedVersion(arr,arr.length);
        for(int n:arr)
            System.out.print(n+" ");
    }
}

2.选择排序

2.1.1 普通版本

public class SelectSort1 {
    public static void selectSort1(int[] arr){
        if(arr.length < 2)
            return;
        for(int i = 0;i < arr.length - 1;i++){
            int index = i;
            for(int j = i + 1;j < arr.length;j++){
                if(arr[j] < arr[index]){
                    index = j;
                }
            }
            if(index != i){
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        selectSort1(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
}

2.1.2 优化版本（一次找出最大和最小值）

public class SelectSort1OptimizedVersion {

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        bubbleSort1OptimizedVersion(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
    public static void bubbleSort1OptimizedVersion(int[] arr){
        if(arr.length < 2)
            return;
        int left = 0,right = arr.length - 1;
        while(left < right){
            int minpos = left,maxpos = left;
            for(int i = left;i <= right;i++){
                if(arr[i] < arr[minpos])
                    minpos = i;
                if(arr[i] > arr[maxpos])
                    maxpos = i;
            }
            if(minpos != left){
                int temp = arr[left];
                arr[left] = arr[minpos];
                arr[minpos] = temp;
            }
            //防止最大值位置在left，前一步吧最小值换到left，下一步会把最小值当作最大值换到最右边
            if(maxpos == left){
                maxpos = minpos;
            }
            if(maxpos != right){
                int temp = arr[right];
                arr[right] = arr[maxpos];
                arr[maxpos] = temp;
            }
            left++;
            right--;
        }
    }
}

2.2.1 递归版本

public class SelectSort2 {
    public static void selectSort2(int[] arr,int start){
        if(start >= arr.length - 1)
            return;
        int index = start;
        for(int i = start + 1;i < arr.length;i++){
            if(arr[i] < arr[index]){
                index = i;
            }
        }
        if(index != start){
            int temp = arr[start];
            arr[start] = arr[index];
            arr[index] = temp;
        }
        selectSort2(arr,start + 1);
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        selectSort2(arr,0);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
}

2.2.2 递归优化版本

public class SelectSort2OptimizedVersion {

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        SelectSort2OptimizedVersion(arr,0,arr.length-1);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
    public static void SelectSort2OptimizedVersion(int[] arr,int left,int right) {
        if (left > right)
            return;
        int minpos = left, maxpos = left;
        for (int i = left; i <= right; i++) {
            if (arr[i] < arr[minpos]) {
                minpos = i;
            }
            if (arr[i] > arr[maxpos]) {
                maxpos = i;
            }
        }
        if (minpos != left) {
            int temp = arr[left];
            arr[left] = arr[minpos];
            arr[minpos] = temp;
        }
        //防止最大值位置在left，前一步吧最小值换到left，下一步会把最小值当作最大值换到最右边
        if (maxpos == left) {
            maxpos = minpos;
        }
        if (maxpos != right) {
            int temp = arr[right];
            arr[right] = arr[maxpos];
            arr[maxpos] = temp;
        }
        SelectSort2OptimizedVersion(arr, left + 1, right - 1);
    }
}

3 插入排序

public class InsertSort {

    public static void main(String[] args) {
        int[] arr = new int[]{23,4,1,-5,-9,45,2,45,78,-14,0};
        insertSort(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
    public static void insertSort(int[] arr){
        for(int i = 0;i < arr.length - 1;i++){
            int temp = arr[i+1];
            int j = i;
            for(;j >= 0;j--){
                if(temp < arr[j]){
                    arr[j+1] = arr[j];
                }
                else{
                    break;
                }
            }
            arr[j+1] = temp;
        }
    }
}

4 希尔排序

public class ShellSort {
    //步长确定后在每个小组内进行插入排序
    public static void groupSort(int[] arr,int step,int start){
        for(int i = start + step;i < arr.length;i = i + step){
            int temp = arr[i];
            int j = i - step;
            for(;j >=0;j = j - step){
                if(arr[j] > temp){
                    arr[j+step] = arr[j];
                }
                else{
                    break;
                }
            }
            arr[j+step] = temp;
        }
    }

    public static void shellSort(int[] arr){
        int step = arr.length/2;
        for(;step > 0;step = step/2){
            for(int i = 0;i < step;i++){
                groupSort(arr,step,i);
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
        shellSort(arr);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
}

5 快速排序

5.1 快速排序—前后指针法

public class QuickSort_FrontRearPointer {

    public static void main(String[] args) {
        int[] arr = new int[]{21,32,35,7,-90,-46,12,56,86,442,2,31,122,-2,0,0,0};
        quickSort(arr,0,arr.length - 1);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }
    public static void quickSort(int[] arr,int start,int end){
        if(start >= end)
            return;
        int pre = start,cur = pre + 1;
        int key = start;
        while(cur <= end){
            if(arr[cur] < arr[key]){
                pre++;
                int temp = arr[cur];
                arr[cur] = arr[pre];
                arr[pre] = temp;
            }
            cur++;
        }
        int temp = arr[pre];
        arr[pre] = arr[key];
        arr[key] = temp;
        quickSort(arr,start,pre - 1);
        quickSort(arr,pre + 1,end);
    }
}

5.2 快速排序—左右指针法

public class QuickSort_LeftRightPointer {

    public static void main(String[] args) {
        int[] arr = new int[]{-99,23,4,1,-5,-9,45,2,45,78,-14,0};
        quickSort(arr,0,arr.length - 1);
        for(int n:arr){
            System.out.print(n+" ");
        }
    }

    //选取最左边的值为key，右边的end先走；反之亦然
    public static void quickSort(int[] arr,int start,int end){
        if(start >= end)
            return;
        int left = start,right = end;
        //左边为key，end先动
        int key = left;
        while(left < right){
            while(arr[right] >= arr[key] && right > left){
                right--;
            }
            while(arr[left] <= arr[key] && left < right){
                left++;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        int temp = arr[key];
        arr[key] = arr[left];
        arr[left] = temp;
        key = left;
        quickSort(arr,start,key - 1);
        quickSort(arr,key + 1,end);
    }
}
ww15212334231
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常用十大排序算法
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大排序算法（一）
qq_44819554的博客
01-27 868
十大排序算法包括了递归、分治、二分、双指针等常见的解题方法，想要提高算法能力，排序算法必须得精通，能够自己独立写出程序。
php代码-十大排序算法
07-14
这个压缩包“php代码-十大排序算法”显然是一个包含PHP实现的十种常见排序算法的资源包。下面我们将详细讨论这十个排序算法以及它们在PHP中的应用。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序...
C语言实现十大排序算法.rar
11-21
本资源“C语言实现十大排序算法.rar”提供了一组C语言编写的排序算法实现，涵盖了常见的排序方法。接下来，我们将详细探讨这十大排序算法及其在C语言中的实现。 1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的...
经典的十大排序算法实现
10-24
本资源提供了经典的十大排序算法的C++实现，这对于初学者理解和掌握数据结构基础至关重要。下面我们将详细探讨这十大排序算法及其原理。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的交换排序，通过重复遍历...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 559
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 6820
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 7236
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 4880
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2969
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 498
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
死锁及其产生条件
秋夫人
08-26 2161
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 388
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
JVM 内存参数
iOS逆向与安全
08-29 1232
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
SpringBoot SSM vue在线作业考试系统
最新发布
yinjl123456的博客
08-30 251
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
十大排序算法详解与实现
本文档总结了经典的十大排序算法，包括冒泡排序、选择排序、插入排序、壳排序、归并排序、快速排序、堆排序、拓扑排序、锦标赛排序和基数排序，并提供了冒泡排序和选择排序的代码示例。此外，还提到了二分法和二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值