Java数据结构第二十期：解构排序算法的艺术与科学(二)

news2025/3/10 8:50:57

专栏：Java数据结构秘籍

个人主页：手握风云

目录

一、常见排序算法的实现

1.1. 直接选择排序

1.2. 堆排序

1.3. 冒泡排序

1.4. 快速排序

一、常见排序算法的实现

1.1. 直接选择排序

        每⼀次从待排序的数据元素中选出最小的⼀个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。第一轮，先让j下标遍历出数组中最小的元素，再利用MinIndex存放最小的下标，利用最小值与i下标的元素进行交换；第二轮，依然让j下标遍历出待排序中最小的元素，再利用MinIndex存放最小的下标，利用最小值与i下标的元素进行交换……知道i走到最后一个元素，这样就能保证i之前的元素全部是有序的。

import java.util.Random;

public class Sort {
    public void SelectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int MinIndex = i;
            for (int j = i+1; j < array.length; j++) {
                if(array[MinIndex] > array[j]){
                    MinIndex = j;
                }
            }
            swap(array,MinIndex,i);
        }
    }

    private void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

    public void DisOrder(int[] array) {
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(100);
        }
    }
}
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] array = new int[6];
        Sort sort = new Sort();
        sort.DisOrder(array);
        System.out.println("排序前：" + Arrays.toString(array));

        sort.SelectSort(array);
        System.out.println("排序后："+Arrays.toString(array));
    }
}

        直接选择排序是不稳定的。空间上，没有使用额外的空间，空间复杂度为O(n) =1。时间上，

        直接选择排序还有另外一种思路。与上面的方法不同的是，我们需要两个值MinIndex接收最小值下标和MaxIndex来接收最大值下标，再额外定义两个指针left和right。这种选择排序的思路是从首尾找，起始两个值接收下标都为0，利用i去遍历数组，找出最大值与最小值下标，再让left下标的值与MinIndex下标的值交换，right下标的值与MaxIndex下标的值交换。接着再让left向左移动，right向右移动，直到相遇，循环结束

        完整代码实现：

import java.util.Random;

public class Sort {
    public void DisOrder(int[] array) {
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(100);
        }
    }

    public void SelectSort(int[] array) {
        int left = 0, right = array.length - 1;
        while (left < right) {
            int MinIndex = left, MaxIndex = left;
            for (int i = left + 1; i <= right; i++) {
                if (array[i] < array[MinIndex]) {
                    MinIndex = i;
                }
                if (array[i] > array[MaxIndex]) {
                    MaxIndex = i;
                }
            }
            swap(array, MinIndex, left);
            swap(array, MaxIndex, right);
            left++;
            right--;
        }
    }

    private void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前：" + Arrays.toString(array));
        sort.SelectSort(array);
        System.out.println("排序后：" + Arrays.toString(array));
    }
}

        但我们一运行，就会发现，排序出现了问题，这是因为，如果最大值或最小值本身就在首尾，那么一交换，最大值或最小值就会跑掉，，所以我们还需要判断一下。

import java.util.Random;

public class Sort {
    public void DisOrder(int[] array) {
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(100);
        }
    }

    public void SelectSort(int[] array) {
        int left = 0, right = array.length - 1;
        while (left < right) {
            int MinIndex = left, MaxIndex = left;
            for (int i = left + 1; i <= right; i++) {
                if (array[i] < array[MinIndex]) {
                    MinIndex = i;
                }
                if (array[i] > array[MaxIndex]) {
                    MaxIndex = i;
                }
            }
            swap(array, MinIndex, left);
            /*if (left == MaxIndex) {
                MaxIndex = MinIndex;
            }*/
            swap(array, MaxIndex, right);
            left++;
            right--;
        }
    }

    private void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前：" + Arrays.toString(array));
        sort.SelectSort(array);
        System.out.println("排序后：" + Arrays.toString(array));
    }
}

1.2. 堆排序

        堆排序是指利⽤堆积树这种数据结构所设计的⼀种排序算法，它是选择排序的⼀ 种，通过堆来进⾏选择数据。需要注意的是排升序要建大堆，排降序建小堆。

import java.util.Random;

public class Sort {
    public void HeapSort(int[] array) {
        CreateHeap(array);
        int end = array.length - 1;
        while(end > 0){
            swap(array,0,end);
            ShiftDown(array,0,end);
            end--;
        }
    }

    private void CreateHeap(int[] array) {
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            ShiftDown(array, parent, array.length);
        }
    }

    private void ShiftDown(int[] array, int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
            if (child + 1 < length && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array,parent,child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

    private void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

    public void DisOrder(int[] array){
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(1,100);
        }
    }
}
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前："+ Arrays.toString(array));
        sort.HeapSort(array);
        System.out.println("排序前："+ Arrays.toString(array));
    }
}

        堆排序使⽤堆来选数，效率就⾼了很多。但堆排序是不稳定的，时间复杂度为O(n)=nlogn，空间复杂度为O(n)=1。

1.3. 冒泡排序

        定义下标j，比较array[j]与array[j+1]的值，如果array[j] > array[j+1]，则交换两数的位置。我们还可以进行一个优化，如果数组本身就是有序，或者没有走完所有的趟数就已经有序，那么后面就不用再比较了。

import java.util.Random;

public class Sort {
    public void DisOrder(int[] array) {
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(1, 100);
        }
    }

    public void BubbleSort(int[] array) {
        //表示交换的趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]){
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(!flg){
                break;
            }
        }
    }

    private void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前："+Arrays.toString(array));
        sort.BubbleSort(array);
        System.out.println("排序后："+Arrays.toString(array));
    }
}

        冒泡排序是稳定的。时间复杂度：O(n)=n^{2}，空间复杂度：O(n)=1。

1.4. 快速排序

        快速排序是Hoare于1962年提出的⼀种⼆叉树结构的交换排序⽅法，其基本思想为：任取待排序元素 序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列。

        我们需要定义两个指针left和right，假设以6作为基准值，left向左移动，遇到比6大的数停下；right向右移动，遇到比6小的数停下，然后交换两个元素。当两个指针相遇时，再与基准值进行交换。这样就能保证6左边都是比6小的数，6右边都是比6大的数。按照这个过程再次进行，，构成递归的条件，直到分离出只含一个值的子序列。这样就构成了如下图所示的二叉树结构。

public class Sort {

    public void QuickSort(int[] array){

    }

    public void Quick(int[] array,int start,int end){
        if(start >= end){//如果结点的右子树为空，就不用遍历右边
            return;
        }
        int par = partition(array,start,end);
        Quick(array,start,par-1);
        Quick(array,par+1,end);
        //当start==end时，递归条件结束
    }

    private int partition(int[] array, int left, int right) {
        return -1;
    }
}

        我们接下来要思考的问题是如何写partition这个方法。无论是递归左边还是右边，与上面的过程都是一样的。只要left下标的值比基准值小，left右移；只要right下标的值比基准值大，right右移。这里我们还需要注意里层的while循环，指针不能越界。

    private int partition(int[] array, int left, int right) {
        int i = left;
        int tmp = array[left];
        while(left < right){
            while(left < right && array[right] >= tmp){
                right--;
            }
            while(left < right && array[left] <= tmp){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);
        return left;
    }

        完整代码实现：

import java.util.Random;

public class Sort {
    public void DisOrder(int[] array){
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(1,40);
        }
    }

    public void QuickSort(int[] array){
        Quick(array,0,array.length-1);
    }

    public void Quick(int[] array,int start,int end){
        if(start >= end){//如果结点的右子树为空，就不用遍历右边
            return;
        }
        int par = partition(array,start,end);
        Quick(array,start,par-1);
        Quick(array,par+1,end);
        //当start==end时，递归条件结束
    }

    private int partition(int[] array, int left, int right) {
        int i = left;
        int tmp = array[left];
        while(left < right){
            while(left < right && array[right] >= tmp){
                right--;
            }
            while(left < right && array[left] <= tmp){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);
        return left;
    }

    private void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前："+Arrays.toString(array));
        sort.QuickSort(array);
        System.out.println("排序后："+Arrays.toString(array));
    }
}

        这里解释一下为什么先让right移动，防止越过某些值。这里我们还需要注意，>=或<=的等号不能省略，如果left和right的值与基准值相等，那么就不会进入内层的while循环，导致外层的while循环陷入死循环。

        快速排序是不稳定的。快速排序的时间复杂度通常是指最好情况下，因为我们经常对快速排序进行优化。

        快速排序还有一种做法——挖坑法。与上面的方法类似，我们依然是以6为基准值，把6存进tmp中，right向左移动，遇到比6小的数，把6之前的位置填上；left向右移动，遇到比6大的数，把5之前的位置填上……我们只需要对上面的代码进行修改就可以。

import java.util.Random;

public class Sort {
    public void DisOrder(int[] array){
        Random ran = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = ran.nextInt(1,40);
        }
    }

    public void QuickSort(int[] array){
        Quick(array,0,array.length-1);
    }

    public void Quick(int[] array,int start,int end){
        if(start >= end){//如果结点的右子树为空，就不用遍历右边
            return;
        }
        int par = partition(array,start,end);
        Quick(array,start,par-1);
        Quick(array,par+1,end);
        //当start==end时，递归条件结束
    }

    private int partition(int[] array, int left, int right) {
        int i = left;
        int tmp = array[left];
        while(left < right){
            while(left < right && array[right] >= tmp){
                right--;
            }
            array[left] = array[right];
            while(left < right && array[left] <= tmp){
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

}

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] array = new int[6];
        sort.DisOrder(array);
        System.out.println("排序前："+ Arrays.toString(array));
        sort.QuickSort(array);
        System.out.println("排序后："+ Arrays.toString(array));
    }
}

        我们接下来思考一下快排的优化。我们先来看第一种三数取中法。我们找出start和end的中位数，让二叉树的形状尽量不要出现单分支的情况。那我们怎么再这段区间里面去找中位数呢？我们可以通过下标来找

    private static int midNum(int[] array, int left, int right) {
        int mid = (left+right)/2;
        if(array[left] < array[right]) {
            if(array[mid] < array[left]) {
                return left;
            }else if(array[mid] > array[right]) {
                return right;
            }else {
                return mid;
            }
        }else {
            if(array[mid] > array[left]) {
                return left;
            }else if(array[mid] < array[right]) {
                return right;
            }else {
                return mid;
            }
        }
    }

        第二种，递归到⼩的⼦区间时，可以考虑使⽤插⼊排序。

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

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

相关文章

【算法day5】最长回文子串——马拉车算法

【算法day5】最长回文子串——马拉车算法

最长回文子串 给你一个字符串 s&#xff0c;找到 s 中最长的 回文 子串。 https://leetcode.cn/problems/longest-palindromic-substring/description/ 算法思路&#xff1a; class Solution { public:string longestPalindrome(string s) {int s_len s.size();string tmp …
阅读更多...
《如何排查Linux系统平均负载过高》

《如何排查Linux系统平均负载过高》

【系统平均负载导读】何为系统平均负载&#xff1f;假设一台云服务主机&#xff0c;突然之间响应用户请求的时间变长了&#xff0c;那么这个时候应该如何去排查&#xff1f;带着这个问题&#xff0c;我们对“平均负载”展开深入的探讨和研究。 何为Linux系统的平均负载&#xf…
阅读更多...
基于DeepSeek实现PDF嵌入SVG图片无损放大

基于DeepSeek实现PDF嵌入SVG图片无损放大

1. PDF中效果图 2. 询问Deepseek进行代码书写&#xff0c;不断优化后结果 /*** SVG工具类&#xff0c;用于生成价格趋势的SVG图表*/ public class SvgUtils {// SVG画布尺寸private static final int WIDTH 800;private static final int HEIGHT 500;private static final i…
阅读更多...
整型的不同类型和溢出

整型的不同类型和溢出

一、整数的不同类型 不同编程语言中的整数类型主要通过以下两个维度区分&#xff1a; 1. 存储大小 字节数&#xff1a;决定整数能表示的范围&#xff08;如 1字节8位&#xff09;。 常见类型&#xff1a; byte&#xff08;1字节&#xff09;、short&#xff08;2字节&#x…
阅读更多...
使用express创建服务器保存数据到mysql

使用express创建服务器保存数据到mysql

创建数据库和表结构 CREATE DATABASE collect;USE collect;CREATE TABLE info (id int(11) NOT NULL AUTO_INCREMENT,create_date bigint(20) DEFAULT NULL COMMENT 时间,type varchar(20) DEFAULT NULL COMMENT 数据分类,text_value text COMMENT 内容,PRIMARY KEY (id) ) EN…
阅读更多...
小程序 wxml 语法 —— 41列表渲染 - 进阶用法

小程序 wxml 语法 —— 41列表渲染 - 进阶用法

这一节讲解列表渲染的两个进阶用法&#xff1a; 如果需要对默认的变量名和下标进行修改&#xff0c;可以使用 wx:for-item 和 wx:for-item&#xff1a; 使用 wx:for-item 可以指定数组当前元素的变量名使用 wx:for-index 可以指定数组当前下标的变量名 将 wx:for 用在 标签上&…
阅读更多...
python语言总结（持续更新）

python语言总结（持续更新）

本文主要是总结各函数&#xff0c;简单的函数不会给予示例&#xff0c;如果在平日遇到一些新类型将会添加 基础知识 输入与输出 print([要输出的内容])输出函数 input([提示内容]如果输入提示内容会在交互界面显示&#xff0c;用以提示用户)输入函数 注释 # 单行注释符&…
阅读更多...
FPGA学习篇——Verilog学习5（reg，wire区分及模块例化）

FPGA学习篇——Verilog学习5（reg，wire区分及模块例化）

1 何时用reg&#xff0c;何时用wire&#xff1f; 这个我找了一些网上的各种资料&#xff0c;大概说一下自己的理解&#xff0c;可能还不太到位... wire相当于一根线&#xff0c;是实时传输的那种&#xff0c;而reg是一个寄存器&#xff0c;是可以存储数据的&#xff0c;需要立…
阅读更多...
Redis 数据持久化之AOF

Redis 数据持久化之AOF

AOF&#xff08;Append Only File&#xff09; 以日志的形式来记录每个写操作&#xff0c;将Redis执行过的所有写指令记录下来&#xff08;读操作不记录&#xff09;&#xff0c;只许追加文件但不可以改写文件&#xff0c;redis启动之初会读取该文件重新构建数据&#xff0c;换…
阅读更多...
【芯片验证】verificationguide上的74道SystemVerilog面试题

【芯片验证】verificationguide上的74道SystemVerilog面试题

诧异啊，像我这种没事在网上各处捡东西吃的人为什么之前一直没有用过verificationguide这个网站呢？总不能是大家都已经看过就留下我不知道吧。前几天在论坛上和朋友谈论验证面试题时才搜到这个网站的，感觉挺有意思： .: Verification Guide :.​verificationguide.com/https…
阅读更多...
Java后端高频面经——计算机网络

Java后端高频面经——计算机网络

TCP/IP四层模型&#xff1f;输入一个网址后发生了什么&#xff0c;以百度为例&#xff1f;&#xff08;美团&#xff09; &#xff08;1&#xff09;四层模型 应用层&#xff1a;支持 HTTP、SMTP 等最终用户进程传输层&#xff1a;处理主机到主机的通信&#xff08;TCP、UDP&am…
阅读更多...
面试题（二）--Object中的常见方法

面试题（二）--Object中的常见方法

Object Java的Object是所有Java类的父类&#xff0c;所有的Java类直接或者间接的继承了Object类&#xff0c;Object类位于java.lang包中&#xff08;编译时自动导入&#xff09;&#xff0c;主要提供了11种方法。 /*** native 方法&#xff0c;用于返回当前运行时对象的 Class…
阅读更多...
运行OpenManus项目（使用Conda）

运行OpenManus项目（使用Conda）

部署本项目需要具备一定的基础&#xff1a;Linux基础、需要安装好Anaconda/Miniforge&#xff08;Python可以不装好&#xff0c;直接新建虚拟环境的时候装好即可&#xff09;&#xff0c;如果不装Anaconda或者Miniforge&#xff0c;只装过Python&#xff0c;需要确保Python是3.…
阅读更多...
设备管理系统功能与.NET+VUE（IVIEW）技术实现

设备管理系统功能与.NET+VUE（IVIEW）技术实现

在现代工业和商业环境中&#xff0c;设备管理系统&#xff08;Equipment Management System&#xff0c;简称EMS&#xff09;是确保设备高效运行和维护的关键工具。本文采用多租户设计的设备管理系统&#xff0c;基于.NET后端和VUE前端&#xff08;使用IVIEW UI框架&#xff09…
阅读更多...
数据类设计_图片类设计之2_无规则图类设计(前端架构基础)

数据类设计_图片类设计之2_无规则图类设计(前端架构基础)

前言 学的东西多了,要想办法用出来.C和C是偏向底层的语言,直接与数据打交道.尝试做一些和数据方面相关的内容 引入 接续上一篇数据类设计_图片类设计之1_矩阵类设计(前端架构基础)-CSDN博客,讨论非规则图类型的设计 无规则图的简单定义 前面的矩阵类,有明显的特征:长,宽,行和…
阅读更多...
aws(学习笔记第三十二课) 深入使用cdk(API Gateway + event bridge)

aws(学习笔记第三十二课) 深入使用cdk(API Gateway + event bridge)

文章目录 aws(学习笔记第三十二课) 深入使用cdk学习内容&#xff1a;1. 使用aws API Gatewaylambda1.1. 以前的练习1.2. 使用cdk创建API Gateway lambda1.3. 确认cdk创建API Gateway lambda 2. 使用event bridge练习producer和consumer2.1. 代码链接2.2. 开始练习2.3. 代码部…
阅读更多...
计算机视觉算法实战——老虎个体识别（主页有源码）

计算机视觉算法实战——老虎个体识别（主页有源码）

✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连✨ ​ ​​​ 1. 领域介绍 老虎个体识别是计算机视觉中的一个重要应用领域&#xff0c;旨在通过分析老虎的独特条纹图案&#xff0c;自动识别和区…
阅读更多...
Qt添加MySql数据库驱动

Qt添加MySql数据库驱动

文章目录 一. 安装MySql二.编译mysql动态链接库 Qt版本&#xff1a;5.14.2 MySql版本&#xff1a;8.0.41 一. 安装MySql 参考这里进行安装&#xff1a;https://blog.csdn.net/qq_30150579/article/details/146042922 将mysql安装目录里的bin&#xff0c;include和lib拷贝出来…
阅读更多...
蓝桥杯备考：图论初解

蓝桥杯备考：图论初解

1&#xff1a;图的定义 我们学了线性表和树的结构&#xff0c;那什么是图呢&#xff1f; 线性表是一个串一个是一对一的结构 树是一对多的&#xff0c;每个结点可以有多个孩子&#xff0c;但只能有一个父亲 而我们今天学的图&#xff01;就是多对多的结构了 V表示的是图的顶点集…
阅读更多...
【每日学点HarmonyOS Next知识】输入框自动获取焦点、JS桥实现方式、Popup设置全屏蒙版、鼠标事件适配、Web跨域

【每日学点HarmonyOS Next知识】输入框自动获取焦点、JS桥实现方式、Popup设置全屏蒙版、鼠标事件适配、Web跨域

1、HarmonyOS TextInput或TextArea如何自动获取焦点&#xff1f; 可以使用 focusControl.requestFocus 对需要获取焦点的组件设置焦点&#xff0c;具体可以参考文档&#xff1a; https://developer.huawei.com/consumer/cn/doc/harmonyos-references-V5/ts-universal-attribut…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023