数据结构与算法--排序（java版）

已于 2022-09-19 09:54:51 修改
阅读量256 收藏 1
点赞数
文章标签： java 算法 数据结构
于 2022-09-19 09:47:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46389413/article/details/126926715
版权

数据结构与算法–排序（java版）

一、冒泡排序

构造方法：
Bubblle( ):创建Bubble对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内的元素进行排序
2.private static void boolean greater(Comparable v,Comparable w):
判断v是否大于w
3.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j处的值

代码实现

public class Bubble {

    public static void sort(Comparable[] a){
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                //比较索引j和索引j+1的值
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }

    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

测试

import java.util.Arrays;

public class BubbleTest {
    public static void main(String[] args) {
       Integer[] arr={4,5,6,1,2,3};
       Bubble.sort(arr);

        System.out.println(Arrays.toString(arr));

    }
}

排序结果展示

初始数组为{4,5,6,1,2,3}
排序后的结果如下：
图片:在这里插入图片描述

二、选择排序

构造方法：
Selection( ):创建Selection对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内元素进行排序
2.private static void greater(Comparable v, Comparable w):
判断v是否大于w
3.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j的值

代码实现

public class Selection {

    public static void sort(Comparable[] a){
        for(int i=0;i<a.length-1;i++){
            //定义一个变量，记录最小元素所在索引，默认为参与选择排序的第一个元素所在位置
            int minIndex=i;
            for (int j=i+1;j<a.length;j++){
                //需要比较最小索引minIndex处的值和索引处的值；
                if(greater(a[minIndex],a[j])){
                    minIndex=j;
                }
            }
            //交换最小元素所在索引minIndex处的值和索引i处的值
            exch(a,i,minIndex);
        }
    }

    public static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    public static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

}

测试

import java.util.Arrays;

public class SelectionTest {
    public static void main(String[] args) {
        Integer[] a={4,6,8,7,9,2,10,1};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

排序结果展示

初始数组为{4,6,8,7,9,2,10,1}
排序后的结果如下：
图片:在这里插入图片描述

三、插入排序

构造方法：
Insertion( ):创建insertion对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内元素进行排序
2.private static void greater(Comparable v, Comparable w):
判断v是否大于w
3.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j的值

代码实现

public class Insertion {
    //插入排序
    public static void sort(Comparable[] a){
        for (int i=1;i<a.length;i++){
            for (int j=i;j>0;j--){
                //比较索引j处的值和索引j-1处的值，如果索引j-1处的值比索引j处的值大，则交换数据。
                if(greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else {
                    break;
                }
            }
        }
    }

    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

}

测试

import java.util.Arrays;

public class InsertionTest {
    public static void main(String[] args) {
        Integer[] a={4,3,2,10,12,1,5,6};

        Insertion.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

排序结果展示

初始数组为{4,3,2,10,12,1,5,6}
排序后的结果如下：
图片:在这里插入图片描述

四、希尔排序

构造方法：
Shell( ):创建Shell对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内元素进行排序
2.private static void greater(Comparable v, Comparable w):
判断v是否大于w
3.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j的值

代码实现

public class Shell {

    public static void sort(Comparable[] a){
        //根据数组a的长度确定增长量h的值
        int h=1;
        while (h<a.length/2){
            h=2*h+1;
        }
        while (h>=1){
            //排序
            //找到代插入的元素
            for (int i=h;i<a.length;i++){
                for (int j=i;j>=h;j-=h){
                    //待插入的元素是a[j],比较a[j]和a[j-h]
                    if(greater(a[j-h],a[j])){
                        //交换元素
                        exch(a,j-h,j);
                    }else {
                        //待插入元素元素已经找到了正确的位置
                        break;
                    }
                }
            }
            //把待插入的元素插到有序数列中
            //减小h的值
            h=h/2;
        }
    }
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

测试

import java.util.Arrays;

public class ShellTest {
    public static void main(String[] args) {
        Integer[] a={9,1,2,5,7,4,8,6,3,5};
        Shell.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

五、归并排序

构造方法：
Merge( ):创建Merge对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内元素进行排序
2.private static void sort(Comparable[ ] a,int lo,int hi):
对数组a中从索引o到索引hi之间的元素进行排序
==3.private static void merge(Comparable[ ] a,int lo,int mid,int hi): ==
从索引lo到索引mid为一个子组，从索引mid+1到索引hi为另一个子组，把数组a中的两个子组的数据合并成一个有序的组。
4.private static void greater(Comparable v, Comparable w):
判断v是否大于w
5.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j的值

代码实现

public class Merge {

    private static Comparable[] assist;

    //归并排序
    public static void sort(Comparable[] a){
        //初始化辅助数组assist
        assist=new Comparable[a.length];
        //定义一个lo变量和hi变量，分别记录数组中最小的索引和最大的索引
        int lo=0;
        int hi=a.length-1;
        //调用sort重载方法完成数组a中，从索引lo到索引hi的元素的排序
        sort(a,lo,hi);
    }

    private static void sort(Comparable[] a,int lo,int hi){
        //做安全性校验
        if(hi<=lo){
            return;
        }
        //对lo和hi之间的数据进行分组，分为两个组
        int mid=lo+(hi-lo)/2;
        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        //再把两个组中的数据进行归并
        merge(a,lo,mid,hi);
    }

    private static void merge(Comparable[] a,int lo,int mid,int hi){
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;
        //遍历移动p1指针和p2指针，比较对应索引处的值，找出最小的那个，放到辅助数组的对应索引处
        while(p1<=mid && p2<=hi){
            //比较对于索引处的值
            if(less(a[p1],a[p2])){
                assist[i++]=a[p2++];
            }else {
                assist[i++]=a[p1++];
            }
        }
        //遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while ((p2<=hi)){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原数组中
        for(int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }
    }

    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

}

测试

import java.util.Arrays;

public class MergeTest {
    public static void main(String[] args) {
        Integer[] a={8,4,5,7,1,3,6,2};
        Merge.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

排序结果展示

初始数组为{8,4,5,7,1,3,6,2}
排序后的结果如下：
图片:
在这里插入图片描述

六、快速排序

构造方法：
Quick( ):创建Quick对象
成员方法：
1.public static void sort(Comparable[ ] a):
对数组内元素进行排序
2.private static void sort(Comparable[ ] a,int lo,int hi):
对数组a中从索引o到索引hi之间的元素进行排序
3.private static int partition(Comparable[ ] a,int lo,int hi):
对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界限对应的索引
4.private static void greater(Comparable v, Comparable w):
判断v是否大于w
5.private static void exch(Comparable[ ] a,int i,int j):
交换a数组中，索引i和索引j的值

代码实现

public class Quick {
    public static void sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }

    private static void sort(Comparable[] a,int lo,int hi){
        //安全性校验
        if(hi<=lo){
            return;
        }
        //需要对数组中lo索引和hi索引处的元素进行分组（左子组和右子组）
        int partition=partition(a,lo,hi);//返回的是分组的分界值所在的索引，分界值位置变换后的索引
        //让左子组有序
        sort(a,lo,partition-1);
        //让有子组有序
        sort(a,partition+1,hi);
    }

    public static int partition(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key=a[lo];
        //定义两个指针，分别指向待切分元素的最小索引和最大索引处的下一个位置
        int left=lo;
        int right=hi+1;
        //切分
        while (true){
            //先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
            while (less(key,a[--right])){
                if(right==lo){
                    break;
                }
            }
            //在从左往右扫描，移动left指针，找到一个比分界值小的元素，停止
            while (less(a[++left],key)){
                if(left==hi){
                    break;
                }
            }
            //判断left>=right，如果是，则证明元素扫描完毕，结束循环；如果不是交换元素即可
            if (left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        //交换分界值
        exch(a,lo,right);
        return right;
    }

    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

测试

import java.util.Arrays;

public class QuickTest {
    public static void main(String[] args) {
        Integer[] a={6,1,2,7,9,3,4,5,8};
        Quick.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

排序结果展示

初始数组为{6,1,2,7,9,3,4,5,8}
排序后的结果如下：
图片:
在这里插入图片描述

爱学习的小琰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
数据结构八大排序——java代码实现
Weeeex的博客
05-30 187
数据结构八大排序java实现
关于数据结构的几种常见排序算法（java代码实现）
weixin_45984640的博客
09-23 213
【代码】关于数据结构的几种常见排序算法（java代码实现）
JAVA实现数据结构7种排序算法代码
Ealiser的博客
03-18 1560
共总结了冒泡排序、选择排序、插入排序、快速排序、基数排序、归并排序、堆排序，全部使用Java实现。 /** * @author Ealiser * @data 2022/3/18 - 9:49 * 排序集合 */ public class Sort { // 公共方法：转换数组内两个数字的位置 public static void swap(int[] a, int i, int j){ int temp; temp = a[i];
数据结构与算法——Java实现排序算法（一）
weixin_51351637的博客
12-18 445
将一组数据，依指定的顺序进行排列的过程。将需要处理的所有数据都加载到内部储存器中进行排序数据量过大，无法全部加载到内存，需要借助外部存储进行排序。先加载一部分排序，完成之后再加载一部分排序合并。常见的排序算法。
【数据结构与算法】之交换排序java代码实现
秋雨绵绵
11-17 820
前言 今天开始给大家分享数据结构与算法当中十分重要的排序算法，所谓排序，就是将数据元素按指定关键字大小进行升序降序等重新排序，排序是线性表，二叉树等数据结构的一种基本运算，排序它可以提高我们查找的效率，那么接下来就让我们一起进入排序的世界吧 目录 一、交换排序的思想 交换排序的思想：比较两个元素的大小，如果反序，即未按照一定规则进行排序，例如升序，则交换。交换排序有两种算法，一是冒泡排序，二是快速排序。 二、冒泡排序 2.1冒泡排序算法描述 ...
数据结构与算法-学习笔记 Java 版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构与算法-二叉树的排序
最新发布
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
数据结构和算法-Java版.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
JS中数据结构与算法---排序算法(Sort Algorithm)实例详解
10-16
排序也称排序算法 (Sort Algorithm)，排序是将 一组数据 ， 依指定的顺序 进行 排列的过程 。这篇文章主要介绍了数据结构与算法---排序算法(Sort Algorithm),需要的朋友可以参考下
一文搞定十大经典排序算法
matinal 當冬夜漸暖 。公众号：matinal
12-21 475
更多内容关注公众号：SAP Technical 一、排序算法概述 1、定义 将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。 2、分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次...
Java成员变量、局部变量的默认值和初始化
07-24 9898
转载：https://blog.csdn.net/qq_24644517/article/details/82288493 package deep; public class DefaultValue { // 实例成员变量 private boolean bool; private byte b; private short s; private ...
Java中boolean型变量的默认值问题
wushijuewu
03-26 2万+
1、首先分析Java中的三种不同变量的区别，如下表所示 概念 默认值 其他 类变量 也叫静态变量，是类中独立于方法之外的变量 用static修饰 有默认初始值，系统自动初始化。 如boolean默认为false. 可以被public，protect，private，static等修饰符修饰...
Java并发编程之volatile关键字详解
Flychuer的专栏
12-05 411
volatile是Java语言提供的一个关键字，可用来修饰变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。 volatile的使用与Java内存模型（JMM）有很大关系，不熟悉JMM的，请查看：Java并发编程之Java内存模型 注：下文中提到的本地内
JAVA第一/二章（下）
自深深处
09-07 300
class Day01 {//2017/9/1 /* 第一章： 1.类加载：JVM将class文件加载入内存 2.Java基本单元是类，每个Java源文件可以包含多个类，但只有一个public类，此类名与项目名相同（建议一个源文件里写一个class文件） 3.包是类的集合（文件夹），同包修饰符 4.class修饰权限只有两种修饰符：空、
【Java基础知识 8】Java 基本数据类型
学Java，找哪吒
11-08 6420
Java基础教程系列（入门篇），打造精品专栏。
private static与public static的用法及区别（Java）
热门推荐
Max
05-03 4万+
其实，理解这两者的区别并不难，因为（public、private）和static这两种修饰符的作用本就不同，所以要理解两个的区别，其实就是这两种修饰符效果累加起来之后的区别。 static：静态修饰符，被static修饰的变量和方法类似于全局变量和全局方法，可以在不创建对象时调用，当然也可以在创建对象之后调用。常见的可以用于工具类的工具方法中等，譬如：Math类中的绝大多数方法都是静态方法，他们
private static 与 public static的区别
骑士人生
09-25 4万+
 一家之言，不足之处，还望海涵。 static: 静态成员,不能实例化，在你运行的时候他自己在内存中开辟了块空间,不用new, 有点像全局变量static是静态的意思，public或private与其他成员一样     1、访问static成员，用类而不是实例化的对象；     2、static方法只能访问static属性；     3、static成员可以保留其值------
Java基础（private中对于boolean类型的Getter特殊情况练习）
Money_bagZ的博客
04-22 1588
对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。 例如： package 类和对象; public class Demo05 { public static void main(String[] args) { Student stu = new Student(); stu.setName("鹿晗"); ...
数据结构与算法 - 排序
09-14
排序是计算机科学中常见的操作，它将一组元素按照特定的顺序重新排列。排序算法的目标通常是将元素按照升序或降序排列。 常见的排序算法有很多种...在实际应用中，根据数据规模和性能要求选择合适的排序算法非常重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的小琰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值