05、Java 数据结构：数组排序：冒泡排序、选择排序、插入排序

最新推荐文章于 2024-10-05 15:48:11 发布
最新推荐文章于 2024-10-05 15:48:11 发布
阅读量230 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46023503/article/details/128645671
版权

数组排序：冒泡排序、选择排序、插入排序

1 冒泡排序

1.1 思想

基本思想是对所有相邻记录的关键字值进行比效，如果是逆序，则将其交换，最终达到有序化；其处理过程为：
（1）将整个待排序的记录序列划分成有序区和无序区，初始状态有序区为空，无序区包括所有待排序的记录
（2）对无序区从前向后依次将相邻记录的关键字进行比较，若逆序将其交换，从而使得顺序记录向上”飘浮”（左移），逆序记录向下“堕落”（右移）。 每经过一趟冒泡排序，都使无序区中关键字值最大的记录进入有序区，对于由 n 个记录组成的记录序列，最多经过 n-1 趟冒泡排序，就可以将这 n 个记录重新按关键字顺序排列

##1.2 代码实现

public class BubblingSort {
    public static void main(String[] args) {
        BiblomgSortUnorderArray array = new BiblomgSortUnorderArray(10);
        //插入数据
        array.insert(11);
        array.insert(2);
        array.insert(33);
        array.insert(41);
        array.insert(1);
        //显示数据
        array.display();//11 2 33 41 1
        //冒泡排序
        array.bubling();
        array.display();//1 2 11 33 41 
    }
}
class BiblomgSortUnorderArray{//无序数组类

    private long[] array;//无序数组
    private int nElement;//数组中存在的数据个数

    //构造方法，初始化 arraySize 长度的无序数组，并初始化数据个数为 0
    public BiblomgSortUnorderArray(int arraySize){
        array = new long[arraySize];
        nElement = 0;
    }

    //插入数据：直接在数组的末尾插入数据，数据个数加一
    public void insert(long data){
        array[nElement++] = data;
    }

    //寻找数据：遍历数组，返回查找到的数据的位置索引
    public int get(long data){
        for (int i = 0;i<nElement;i++){
            if (data == array[i]){
                return i;
            }
        }
        return -1;//表示没有找到
    }

    //删除数据：先查找数据，再删除数据，再将后面的所有数据前移一个位置，最后数据个数减一
    public void delete(long data){//只会删除找到的第一个目标数组
        int index = get(data);
        if (index==-1){
            System.out.println("没有该数据");
        }else {//找到数据索引后，直接将后面数据前移覆盖，不必再刻意删除
            for (int i = index;i<nElement;i++){
                array[i] = array[i+1];
            }
            nElement--;
        }
    }

    //遍历数组：读取数组的每个数据项
    public void display(){
        for(int i = 0;i<nElement;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    //实现冒泡排序
    public void bubling(){
        int inner;
        int outer;
        for (outer = nElement-1;outer>0;outer--){//外层循环，从尾到头循环
            for (inner=0;inner<outer;inner++){//内层循环，从头到 outer 循环
                if (array[inner]>array[inner+1]){//如果发现前面元素比后面元素大，交换位置
                    long n = array[inner];
                    array[inner] = array[inner+1];
                    array[inner+1] = n;
                }
            }
        }
    }
}

2 选择排序

2.1 思想

如果有N个元素需要排序，那么首先从 N 个元素中找到最小的那个元素与第0位置上的元素交换，接着从剩余的 N-1 个元素中再次找到最小的那个元素和第1位置上的元素交换，依此循环

2.2 代码实现

public class SelectSort {
    public static void main(String[] args) {
        SelectSortUnorderArray array = new SelectSortUnorderArray(10);
        //插入数据
        array.insert(11);
        array.insert(2);
        array.insert(33);
        array.insert(41);
        array.insert(1);
        //显示数据
        array.display();//11 2 33 41 1
        //选择排序
        array.selectSort();
        array.display();//1 2 11 33 41
    }
}

class SelectSortUnorderArray {//无序数组类

    private long[] array;//无序数组
    private int nElement;//数组中存在的数据个数

    //构造方法，初始化 arraySize 长度的无序数组，并初始化数据个数为 0
    public SelectSortUnorderArray(int arraySize) {
        array = new long[arraySize];
        nElement = 0;
    }

    //插入数据：直接在数组的末尾插入数据，数据个数加一
    public void insert(long data) {
        array[nElement++] = data;
    }

    //寻找数据：遍历数组，返回查找到的数据的位置索引
    public int get(long data) {
        for (int i = 0; i < nElement; i++) {
            if (data == array[i]) {
                return i;
            }
        }
        return -1;//表示没有找到
    }

    //删除数据：先查找数据，再删除数据，再将后面的所有数据前移一个位置，最后数据个数减一
    public void delete(long data) {//只会删除找到的第一个目标数组
        int index = get(data);
        if (index == -1) {
            System.out.println("没有该数据");
        } else {//找到数据索引后，直接将后面数据前移覆盖，不必再刻意删除
            for (int i = index; i < nElement; i++) {
                array[i] = array[i + 1];
            }
            nElement--;
        }
    }

    //遍历数组：读取数组的每个数据项
    public void display() {
        for (int i = 0; i < nElement; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    //实现选择排序
    public void selectSort() {
       int inner;//内边界
       int outer;//外边界
       int min;//最小值的索引
       for(outer = 0;outer<nElement-1;outer++){//外层循环，outer从0遍历到倒数第二个元素
           min = outer;//让 min 默认等于 outer
           for (inner=outer+1;inner<nElement;inner++){//内层循环，inner 从 outer+1 遍历到最后一个元素
               if(array[min]>array[inner]){//比较大小，将最小值位置索引赋值给 min
                   min = inner;
               }
           }
           long n = array[outer];//将最小值与前面的大值进行交换
           array[outer] = array[min];
           array[min] = n;
       }
    }
}

3 插入排序

3.1 思想

对于一个无序列表，拿出一个临时变量（起始为第二个元素），将其和前面元素循环比较，如果前面的元素比临时变量大，就讲前面的元素向后移动一位，如果前面的元素比临时变量小，或者已经到达的头部第一个元素，就结束循环，然后在依此循环后面所有的元素

3.2 代码实现

public class InsertSort {
    public static void main(String[] args) {
        InsertSortUnorderArray array = new InsertSortUnorderArray(10);
        //插入数据
        array.insert(11);
        array.insert(2);
        array.insert(33);
        array.insert(41);
        array.insert(1);
        //显示数据
        array.display();//11 2 33 41 1
        //插入排序
        array.insertSort();
        array.display();//1 2 11 33 41
    }
}

class InsertSortUnorderArray {//无序数组类

    private long[] array;//无序数组
    private int nElement;//数组中存在的数据个数

    //构造方法，初始化 arraySize 长度的无序数组，并初始化数据个数为 0
    public InsertSortUnorderArray(int arraySize) {
        array = new long[arraySize];
        nElement = 0;
    }

    //插入数据：直接在数组的末尾插入数据，数据个数加一
    public void insert(long data) {
        array[nElement++] = data;
    }

    //寻找数据：遍历数组，返回查找到的数据的位置索引
    public int get(long data) {
        for (int i = 0; i < nElement; i++) {
            if (data == array[i]) {
                return i;
            }
        }
        return -1;//表示没有找到
    }

    //删除数据：先查找数据，再删除数据，再将后面的所有数据前移一个位置，最后数据个数减一
    public void delete(long data) {//只会删除找到的第一个目标数组
        int index = get(data);
        if (index == -1) {
            System.out.println("没有该数据");
        } else {//找到数据索引后，直接将后面数据前移覆盖，不必再刻意删除
            for (int i = index; i < nElement; i++) {
                array[i] = array[i + 1];
            }
            nElement--;
        }
    }

    //遍历数组：读取数组的每个数据项
    public void display() {
        for (int i = 0; i < nElement; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    //实现插入排序
    public void insertSort() {
        int inner;//内边界
        int outer;//外边界
        int min;//最小值的索引
        for (outer = 0; outer < nElement - 1; outer++) {//外层循环，outer从0遍历到倒数第二个元素
            min = outer;//让 min 默认等于 outer
            for (inner = outer + 1; inner < nElement; inner++) {//内层循环，inner 从 outer+1 遍历到最后一个元素
                if (array[min] > array[inner]) {//比较大小，将最小值位置索引赋值给 min
                    min = inner;
                }
            }
            long n = array[outer];//将最小值与前面的大值进行交换
            array[outer] = array[min];
            array[min] = n;
        }
    }
}
玄天灵
关注
专栏目录
java选择排序等排序算法资源：java排序算法源代码（包括冒泡排序，选择排序，插入排序）
05-29
本资源包含了几种基本的排序算法，如冒泡排序、选择排序和插入排序，这些都是理解和学习算法的基础。 **冒泡排序**是最基础的排序算法之一，它通过重复遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把...
Java排序算法练习：1.快速排序 2.归并排序 3.插入排序 4.冒泡排序 5.选择排序 6.堆排序
08-08
这里我们将深入探讨标题和描述中提到的六种排序算法：快速排序、归并排序、插入排序、冒泡排序、选择排序以及堆排序。 1. **快速排序**：由C.A.R. Hoare在1960年提出，是一种高效的分治算法。快速排序的基本思想是...
数据结构 第九章 排序
weixin_70463877的博客
04-25 83
二叉堆的储存可以采用层次序列的储存方式，直接用一个数组保存：按从左到右，从上到下的顺序依次为二叉堆上的节点编号，如果根节点的编号为1的话，每个节点的左子节点的编号为根节点编号 ∗ 2 *\ 2 ∗ 2，右子节点的编号为根结点编号 ∗ 2 + 1 * \ 2 + 1 ∗ 2+1，每个节点的根节点的编号为自身编号 / 2。首先，将堆顶的值与数组末尾的节点交换，之后移除数组末尾的节点（在下面的样例中，移除节点通过记录节点个数的n−1n-1n−1来实现）；（一个一个的排序，一个一个的插入）
Java 实现冒泡排序法对数组进行排序
czb6816的博客
12-02 8218
冒泡排序是交换排序中的一种简单的排序方法。它的基本思想是对所有相邻记录的关键字值进行比较，如果是逆序（a[j]&gt;a[j+1]），则将其交换，最终达到有序化。  public class BubbleSort { public void sortArray() { int arr[] = {2,1,5,8,21,12}; System.out.println("冒泡排序前的结果...
Java排序：冒泡、插入、快速、选择
m0_68773367的博客
01-18 509
假设将15个数从小到大排列，相邻两个数比较，如果发现前一项比后一项大，那么这两项就互换，之后再两两相比，这样比较一轮下来，每一轮找到这15个数中的最大值，并放在最右边。再进行下一趟，直到得到升序为止。
Java数据结构和算法-3-数组-简单排序：冒泡排序/选择排序/插入排序
Anthony_tester的博客
03-10 785
前面我们介绍了线性查找和二分查找，二分查找之前，我们需要进行对数组元素排序。本篇就是介绍三个简单的排序，分别是冒泡排序，选择排序，插入排序。可以说说，面试之前，这三个排序算法都是需要复习，哪怕背下来，并且解释出代码的含义和原理。 1、冒泡排序 这里我们新建一个BubbleSort.java用来写冒泡排序，代码如下 package array; public class BubbleSor...
Java常见一维数组排序方式（插入排序，归并排序，快排）
weixin_52875110的博客
09-02 2352
冒泡排序就是重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。先找到最小元素所在位置的索引，然后将该元素与第一位上的元素进行交换。：利用Arrays封装好的函数。
java基础进阶之数组排序-可能有你不知道的哦！！
qq_19343089的博客
12-06 1835
算法，java算法，快速排序，冒泡排序，选择排序，插入排序，快速排序，归并排序
Java数组八大排序---冒泡排序、快速排序、堆排序、归并排序、插入排序、基数排序、希尔排序、选择排序
qq_52240237的博客
07-23 515
1.原理：每一次选出来一个最大值（或最小值）放到数组的最右边2.时间复杂度：O（n^2）3.代码：i
排序算法：冒泡排序、插入排序、选择排序、希尔排序
qq_55624813的博客
11-14 4253
目录 一、冒泡排序： 二、插入排序： 三、选择排序： 四、希尔排序： 一、冒泡排序： 1、算法原理： 冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系的要求。如果不满足就让它俩互换位置。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。 2、算法描述： （1）比较相邻的元素。如果第一个比第二个大，就交换它们两个； （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
【Java数据结构】常见排序详解
weixin_46913665的博客
02-28 1393
文章目录 一、排序的概念和分类 1.排序的基本概念 2.排序的稳定性 二、常见排序 1.直接插入排序 2.希尔排序 3.简单选择排序 4.堆排序 5.冒泡排序 6.快速排序 6.1.递归快速排序 6.1.1.快排优化 6.2.非递归方式实现 7.归并排序
数据结构之三大排序（冒泡&选择&插入）
weixin_46685039的博客
07-18 292
数据结构之三大排序（冒泡&选择&插入）
java数组排序
09-04
在Java编程语言中，数组排序是一项基础且重要的任务。它涉及到不同的算法，这些算法通过比较和交换元素来达到数组元素的有序状态。本篇将详细探讨几种常见的排序算法及其在Java中的实现。 首先，让我们从最简单的...
java算法题 : 数组相关问题
03-14
在Java编程语言中，数组是一种基础且重要的数据结构，它允许我们存储同类型的元素集合。在处理算法题，特别是数组相关的问题时，了解并熟练掌握数组的特性、操作以及与其相关的算法是至关重要的。本篇将深入探讨Java...
java教程-数组应用+冒泡排序+选择排序+插入排序
05-27
Java数组应用和排序算法 ...数组是一种非常重要的数据结构，它可以用来集中管理类型相同，用途相近的多个数据。排序算法是数组操作中的一种重要应用，它可以将数组中的元素排序，提高数组的可读性和可维护性。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 503
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
Indigo____的博客
10-04 336
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
数据结构-4.1.特殊矩阵的压缩存储
ADCvbV的博客
10-01 1042
1.知道一维数组的起始地址，就可以求出任意下标对应的元素所在的地址；2.注：如果数组下标从1开始，上述公式的i就要改为i-1；3.数组里的元素类型相同，因此所占空间也相同。1.注：数组的存储是连续(计算机的存储是线性的)的，针对非线性的二维数组，为了将其拉成线性结构，就有了行优先和列优先两种存储方式；2.将非线性的二维数组整成线性的好处就是可以实现随机存取；3.行优先时计算存储地址：公式中i为行，j为列4.列优先时计算存储地址：公式中i为行，j为列由于对称矩阵关于主对角线对称，因此在存储对称矩阵的数据时只需
浙大数据结构：07-图4 哈利·波特的考试
最新发布
qq_74924951的博客
10-05 854
floyd算法
Java教程：数组应用与冒泡、选择、插入排序详解
Java教程深入探讨了一维数组在编程中的关键应用和几种常见的排序算法，包括冒泡排序、选择排序和插入排序。一维数组是Java中的一种重要数据结构，它代表了一组相同类型的有序数据集合，这些数据具有统一的类型和用途...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

玄天灵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值