八种排序

最新推荐文章于 2024-10-15 09:23:24 发布
最新推荐文章于 2024-10-15 09:23:24 发布
阅读量187 收藏 2
点赞数
分类专栏： 算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuxudong12138/article/details/99698008
版权

八种排序方法

冒泡排序

冒泡排序的思路：
冒泡需要两个for循环：外面的for循环表示需要循环的次数，为数组的长度，里层的for循环是来选择数组中的最大值。
比如第一个循环后，最大的数就被排到数组的最后面，第二个循环后，第二大的数就被选出来排到后面。。。。等等，完成排序。

代码

package com.wuxudong.sort;

import java.util.Arrays;

//冒泡排序
public class BubbleSort {

    public static void main(String[] args) {
        //定义数组
        int [] arr=new int []{1,3,2,45,3,24,25};

        //定义排序方法
        bubbleSort(arr);

        //输出数组
        System.out.println(Arrays.toString(arr));

    }

    private static void bubbleSort(int[] arr) {

        for (int i = 0; i <arr.length ; i++) {
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

        }

    }

}

快速排序

思路：选择一个标准值，将数组中比标准数大的排到数组的后面，比标准数小的排到数组的前面，然后利用递归完成排序。

举个例子：对于这样一个数组我们选取3为标准值，并取两个指针用于遍历
start表示数组开始排序的位置，end表示数组结束排序的位置。

			//定义两个位置点，高和低
            int low=start;
            int high=end;

            //定义标准点
            int stard=arr[low];

在这里插入图片描述

  1. 判断arr[high]=6>3
    这时候满足条件，无需交换数的位置。并把high的指针往前移动一格
while (low<high&&stard<=arr[high]){
                    high=high-1;
 }

在这里插入图片描述
2. 判断arr[high]❤️
这是不满足条件，需要把3替换成2.

 arr[low]=arr[high];

在这里插入图片描述
3. 移动low指针 判断arr[low]=5>3,不满足条件将high指针的2替换成5
在这里插入图片描述

			 while (low<high&&arr[low]<=stard){
                    low++;
                }
                arr[high]=arr[low];

然后，high指针向前移一步。判断arr[high]=1<3,不满足条件
在这里插入图片描述
移动low指针，判断arr[low]=8>3不满足条件,arr[high]=arr[low]
在这里插入图片描述
移动high指针，判断arr[high]=5>3满足条件。再移动high指针arr[high]=9>3，满足条件。在移动指针arr[high]=8>3，满足条件。此时low==high，循环结束。并将标准值赋值给arr[low]
在这里插入图片描述

 arr[low]=stard;

至此，我们可以看出整个数组被分为两部分，比3小的和比3大的。
在这里插入图片描述
这时，我们调用递归，分别对这两部分进行排序

			 //递归
            quickSort(arr,start,low);
            quickSort(arr,low+1,end);

递归结束的条件是start<end

整个代码

package com.wuxudong.sort;

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {

        int [] arr=new int []{4,3,2,45,3,24,25};

        //启用排序方法
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    private static void quickSort(int[] arr, int start, int end) {
        if(start<end){
            //定义两个位置点，高和低
            int low=start;
            int high=end;

            //定义标准店
            int stard=arr[low];

            //循环
            while (low<high){

                while (low<high&&stard<=arr[high]){
                    high=high-1;

                }
                arr[low]=arr[high];

                while (low<high&&arr[low]<=stard){
                    low++;
                }
                arr[high]=arr[low];

            }
            arr[low]=stard;

            //递归
            quickSort(arr,start,low);
            quickSort(arr,low+1,end);

        }



    }

}

插入排序

package com.wuxudong.sort;

import java.util.Arrays;

public class InsertSort {

    public static void main(String[] args) {
        //定义数组
        int [] arr=new int []{3,3,2,45,3,24,34,67,1,25};

        insertSort(arr);

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

    private static void insertSort(int[] arr) {

        for (int i = 1; i < arr.length; i++) {
            //如果后面一个数比前面的数小就需要交换位置
            if(arr[i]<arr[i-1]){
                //存储当前数的临时变量
                int temp=arr[i];

                int j=0;


                for (j=i-1;j>=0&&temp<arr[j];j--){
                    //如果前一个数比临时变量大，则需要往后移一个位置
                    arr[j+1]=arr[j];
                }
                //如果前面的数比临时变量小，则循环结束，将临时值赋值给前面数的后面一个位置
                arr[j+1]=temp;

            }

        }

    }


}

希尔排序

希尔排序是对插入排序的优化，因为在插入排序中较小的数再后面的话，需要交换很多次，才能将它移动数组前面，较大的数也是同理，因此，希尔排序通过定义步长来进行分组插入排序，可以先将较小的数快速的放到前面，较大的数快速的放到后面。

package com.wuxudong.sort;


import java.util.Arrays;

//希尔排序
public class ShellSort {

    public static void main(String[] args) {
        int [] arr=new int []{3,3,2,45,3,24,34,67,1,25};

        shellSort(arr);

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

    private static void shellSort(int[] arr) {

        //遍历所有步长
        for (int d=arr.length/2;d>0;d=d/2){
            //对分组后的数组进行插入排序
            for (int i = d; i <arr.length ; i++) {

                for (int j=i-d;j>=0;j=j-d){

                    if(arr[j]>arr[j+d]){
                        int temp=arr[j];
                        arr[j]=arr[j+d];
                        arr[j+d]=temp;
                    }
                }

            }

        }
    }

}

选择排序

思路与冒泡相同，冒泡选的是最大的，选择选的是最小的

package com.wuxudong.sort;

import java.util.Arrays;

public class SelectSort {

    public static void main(String[] args) {
        int [] arr=new int [] {3,3,2,45,3,24,34,67,1,25};

        selectSort(arr);

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

    private static void selectSort(int[] arr) {

        for (int i=0;i<arr.length;i++){
            int minIndex=i;

            for (int j=i+1;j<arr.length;j++){
                //找出最小的数
                if (arr[j]<arr[minIndex]){
                    minIndex=j;
                }

            }

            if(i!=minIndex){
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;

            }

        }
    }


}

归并排序

归并排序里利用了归并的思想，即将两个排序好的数组按大小归并到一个数组中。利用递归的思想，将数组差分成不可再分两个数，这两个数可以看作两个排好序的数组，进行归并，最后将递归将其它的数进行归并，完成排序。

package com.wuxudong.sort;


import java.util.Arrays;

//归并排序
public class MergeSort{

    public static void main(String[] args) {
        int [] arr=new int[]{3,3,2,45,3,24,34,67,1,25};

        mergeSort(arr,0,arr.length-1);

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

    private static void mergeSort(int[] arr, int low, int high) {
        if(low<high){
            int middle=(low+high)/2;
            mergeSort(arr,low,middle);
            mergeSort(arr,middle+1,high);
            merge(arr,low,middle,high);
        }


    }

    //归并方法

    /**
     *
     * @param arr 传入的数组
     * @param low 第一个数组开始的下标
     * @param middle 第一个数组结束的下标
     * @param high  第二个数组结束的下标
     */
    public static void merge(int [] arr,int low,int middle,int high){
        //新建一个临时数组，用来存储归并后的数组
        int [] temp=new int [high-low+1];

        //记录第一个数组中需要遍历的下标
        int i=low;

        //记录第二个数组中需要遍历的下标
        int j=middle+1;

        //临时数组的下标
        int index=0;

        //遍历两个数组取出最小的数字，放入临时数组中
        while (i<=middle&&j<=high){
            if(arr[i]<=arr[j]){
                //第一个数组中的值小
                temp[index]=arr[i];
                i++;
            }else {
                //第一个数组中的值大
                temp[index]=arr[j];
                j++;
            }
            index++;

        }

        //将剩余的数添加到临时数组中
        if(i>middle) {
            //第一个数组遍历完了
            while (j <= high) {
                temp[index] = arr[j];
                j++;
                index++;
            }
        }


        if (j>high) {
            //第二个数组遍历完了
            while (i <= middle) {
                temp[index] = arr[i];
                i++;
                index++;
            }
        }

        //将临时数组的值赋值给原数组
        for (int k = 0; k <temp.length ; k++) {
            arr[k+low]=temp[k];
        }

    }

}

基数排序

基数排序的思想比较简单，实际上就是按照先较个位，再比较十位等等的思想来进行排序。
举个例子
在这里插入图片描述
对于这样一个数组，我们先找出其中的最大值798，并判断它是几位数，是几位数我们就要循环几次。

第一次循环：将个位数是几的数放到对应几的数组中
在这里插入图片描述
然后将数组里的这些数依次按照存入的顺序取出来

在这里插入图片描述
第二次循环：将十位数是几的数放到对应几的数组中
在这里插入图片描述
然后再依次取出来
在这里插入图片描述
第三次循环：将百位数是几的数放到对应几的数组中

在这里插入图片描述
最后，依次取出来完成排序
在这里插入图片描述

代码:

package com.wuxudong.sort;

import java.util.Arrays;

//基数排序
public class RadixSort {

    public static void main(String[] args) {
        int [] arr=new int [] {23,6,189,45,9,287,56,1,798,35,65,652,5};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void radixSort(int [] arr){

        int maxValue=Integer.MIN_VALUE;
        //第一步：找出数组中最大的数字
        for (int i=0;i<arr.length;i++){
            if(arr[i]>maxValue){
                maxValue=arr[i];
            }
        }

        //得到最大数是几位数
        int num=(maxValue+"").length();

        //定义二维数组存储变量值
        int [][] temp=new int[10][arr.length];

        //定义一个数组来表示存入数组的个数
        int [] counts=new int [10];


        //循环遍历，循环的次数，n用来取个位，十位，百位。
        for (int i = 0,n=1; i < num; i++,n=n*10) {

            //循环遍历数组
            for (int j=0;j<arr.length;j++){
                int ys=arr[j]/n%10;
                temp[ys][counts[ys]]=arr[j];
                counts[ys]++;

            }

            //定义一个变量表示原数组的下标
            int index=0;
            //取出对应的元素
            for (int k=0;k<10;k++){
                if(counts[k]!=0){
                    for (int l=0;l<counts[k];l++){
                        arr[index]=temp[k][l];
                        index++;
                    }

                    //将数量置为0，留着给下个循环使用
                    counts[k]=0;

                }

            }

        }




    }

}

堆排序

利用了二叉树的数据结构。任何一个数组都可以表示为一个唯一的完全二叉树，任何一个完全二叉树都可以表示为一个数组。我们将数组表示为一个二叉树，然后对把这个二叉树转成大顶堆（即父节点大于子节点），这样根节点就是数组中最大的数，我们在将二叉树的最后一个叶子节点和根节点进行交换，在转为大顶堆，这个第二大的数也找出来了，依次循环，完成排序。

package com.wuxudong.sort;

import java.util.Arrays;

//堆排序
public class HeapSort {

    public static void main(String[] args) {
        int [] arr=new int []{9,6,8,7,0,1,10,4,2};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void heapSort(int [] arr){
        //开始的位置是最后一个非叶子节点，即最后一个节点的父节点
        int start=(arr.length-1)/2;
        //调整大顶堆
        for (int i=start;i>=0;i--){
            maxHeap(arr,arr.length,i);
        }

        //先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
        for (int i = arr.length-1; i>0 ; i--) {
            int temp=arr[0];
            arr[0]=arr[i];
            arr[i]=temp;
            maxHeap(arr,i,0);
        }


    }

    //将数组转为大顶堆
    public static void maxHeap(int [] arr,int size,int index){

        //左节点
        int leftNode=2*index+1;

        //右节点
        int rightNode=2*index+2;

        //定义最大的节点
        int max=index;

        if(leftNode<size&&arr[leftNode]>arr[max]){
            max=leftNode;
        }
        if (rightNode<size&&arr[rightNode]>arr[max]){
            max=rightNode;
        }

        //交换位置
        if(max!=index){
            int temp=arr[index];
            arr[index]=arr[max];
            arr[max]=temp;

            //交换位置后,可能会破坏之前排好的堆，所以，之前排好的堆需要重新调整
            maxHeap(arr,size,max);

        }




    }
}
我是吴尼玛
关注
专栏目录
八种排序算法原理及Java实现( 冒泡排序+快速排序直接插入排序+希尔排序+选择排序+归并排序+基数排序)
06-21
八种排序算法原理及Java实现 排序算法是计算机科学中一种重要的算法，用于对数据进行排序。八种排序算法原理及Java实现是排序算法中的一种，包括冒泡排序、快速排序、直接插入排序、希尔排序、选择排序、归并排序和...
八种排序源码实现.zip
06-14
这个名为“八种排序源码实现.zip”的压缩包包含了一些经典的排序算法在C语言中的实现。让我们逐一探讨这八种排序算法及其原理。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的排序方法，通过重复遍历待排序的...
SSTable详解
跨链技术践行者
12-06 1493
前记 几年前在读Google的BigTable论文的时候，当时并没有理解论文里面表达的思想，因而囫囵吞枣，并没有注意到SSTable的概念。再后来开始关注HBase的设计和源码后，开始对BigTable传递的思想慢慢的清晰起来，但是因为事情太多，没有安排出时间重读BigTable的论文。在项目里，我因为自己在学HBase，开始主推HBase，而另一个同事则因为对Cassandra比较感冒，因而他...
【番杰的问答笔记】寻找输入的最大值和最小值
JIE15164031299的博客
11-22 1653
1. 问题 从键盘输入8个数用数组保存,找出其中的最大值和最小值,并分别输出相应的位置(下标)，下面的程序没报错，但是运行不成功。 #include<stdio.h> int main() { int a[8]; int b,max,min,c,d; for(b=0;b<8;b++) scanf("input：%d",&a[b]); max=a[0]; min=a[0];
你必须要知道的8种基本排序方法
weixin_33769125的博客
07-29 558
1.选择排序 定义：首先，选出数组中最小的元素，将它与数组中第一个元素交换。然后找出次小的元素，并将它与数组中第二个元素交换。按照这种方法一直进行下去，直到整个数组排完序。 交换次数：N-1 缺点：运行时间对文件已有序的部分依赖较少，从文件中选出最小元素的每一遍操作过程，并没有给出下一遍要找的最小元素的位置的相关消息。例如，该程序对已排好序的文件或各元素都相同的元素文件与对随机排列的文件排...
【C语言】数组排序法（升序）
qq_52696970的博客
04-19 1万+
一、冒泡排序 主要思路：相邻两个数的比较交换 #include<stdio.h> int main( ) { int a[10],temp=0; for(int i=0;i<10;i++) { scanf("%d",&a[i]); } for(int k=0;k<9;k++) { for(int j=1;j<10-k;j++) { if(a[j]>a[j-1]) { temp=a[j-1];
数据结构—八种排序算法
m0_60492395的博客
10-17 2660
八种常见的排序算法
Java实现八种排序
最新发布
xiaochuan_bsj的博客
10-15 1699
Java实现八种排序
八种排序算法
galaxyrt的博客
12-12 1601
排序算法的稳定性 排序算法的世间复杂度 简单说就是程序循环执行的总次数，算法的时间复杂度是一个函数，定量的描述了算法运行的时间用符号O表示，即O（f（n））； 常见八种排序： 1、直接排序 代码： #include<iostream> using namespace std; void InsertSort(int* a, int length) { int i = 0, j = 0, temp = 0; for (i = 1; i < l...
Java常用的八种排序算法与代码实现
xiaoxijinger的博客
12-24 4921
在Java的时候，对于排序的应用需要熟练的掌握，这样才能够确保Java学习时候能够有扎实的基础能力。那Java有哪些排序算法呢？本文小千就来详细说说Java经典的8种排序算法。
【数据结构】八大排序(超详解+附动图+源码)
热门推荐
Edward_Asia的博客
11-21 9万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
【算法专题】秒懂八种排序算法的原理
weixin_42469135的博客
07-07 1870
最经典最常用的排序算法有：冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序和桶排序。这些排序算法可以按照时间复杂度分为三类：最好、最坏和平均情况下的时间复杂度；原始数据的杂乱程度会导致同一种算法在不同情况下的时间复杂度呈现不同量级的差异，所以在选择排序算法的时候，需要给出这三个指标，结合实际业务情况的原始数据，来选择算法。时间复杂度的系数、常数和低阶；不同的排序算法可能会出现算法复杂度处在同一量级的情况，此时就需要根据时间复杂度的系数、常数和低阶来决定使用哪一种算法。算法的比较次数和移动
Java实现的八种排序算法.pdf
10-03
本文主要介绍Java实现的八种排序算法，包括冒泡排序、选择排序和插入排序。这些算法虽然时间复杂度相同，但在实际应用中表现各有差异。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的交换排序方法，它通过不断...
实现对String类型的数组进行排序
wuxudong12138的博客
08-16 6898
String类型数组排序数组排序代码 数组排序 对于基本数据类型的数组，我们可以通过java.util包中的Arrays类调动sort方法进行排序。 对于引用类型的数组，我们可以实现Comparator接口，并重写他的compare方法。 对于compare方法的放回值，如果是大于则返回正数，小于则返回负数，等于则返回0。 代码 import java.util.Arrays; import ja...
Java中的Collection
wuxudong12138的博客
08-15 471
Collection APICollection简介Iterator接口的简介 Collection简介 在类库中，Java语言包含有对一些普通数据结构的实现。该语言的一部分通常叫作Collection API。Collection API位于java.util包中。Collection实现了Iterable接口。实现了Iterable接口的类可以使用增强的for循环。 Iterator接口的简介...
递归解决汉诺塔问题
wuxudong12138的博客
08-17 124
汉诺塔问题问题描述新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 问题描述 哈哈哈哈哈哈，自己去4399玩 新...
学习算法的第一天
wuxudong12138的博客
08-15 103
算法分析的基础知识算法的定义估计算法资源消耗的数学基础计算时间复杂度的一般法则 算法的定义 算法是为了求解一个问题需要循环的、被清楚指定的简单指令的集合。对于一个问题，一旦某种算法给定并且被确定是正确的，那么重要的一步就是确定该算法将需要多少诸如时间或空间等资源量的问题 估计算法资源消耗的数学基础 定义一：如果存在正常数c和n0n_0n0​使得当 N&gt;=n0N&gt;=n_0...
数据结构篇：探索八种排序算法与后缀表达式解析
本资源主要介绍了在Java中关于数据结构和算法中的八种排序算法，以及栈（stack）在处理表达式问题中的应用，特别是逆波兰表达式（后缀表达式）的计算。以下是详细的解读： 1. **排序算法** - **冒泡排序**: 一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值