基础常用排序算法

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

文章目录

常用排序算法

image

1. 冒泡排序

  • 冒泡排序的基本思想：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
  • 优化：因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。
public class BubbleSort {
    public static void main(String[] args) {
        int arr[]={3, 9, -1, 10, 20};
        System.out.println(Arrays.toString(arr));

        int temp=0;
        boolean flag=false;
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    flag=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.println(Arrays.toString(arr));
            if (!flag){
                break;
            }else {
                flag=true;
            }
        }
    }
}

2. 选择排序

  • 选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依次规定交换位置后达到排序的目的。
  • 排序思想：第一次从arr[0]-arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选取最小值，与arr[1]交换，…，第n-1次从arr[n-2]~a[arr-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
public class SelectSort {
    public static void main(String[] args) {
        int [] arr = {101, 34, 119, 1, -1, 90, 123};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    public static void selectSort(int arr[]){
        for (int i=0;i<arr.length-1;i++){
            int min=arr[i];
            int minIndex=i;
            for (int j=i+1;j<arr.length;j++){
                if(min>arr[j]){
                    min=arr[j];
                    minIndex=j;
                }
            }
            if (minIndex!=i){
                arr[minIndex]=arr[i];
                arr[i]=min;
            }
            System.out.println("第"+(i+1)+"轮后~~");
            System.out.println(Arrays.toString(arr));
        }
    }
}

3. 插入排序

  • 插入排序属于内部排序，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
  • 基本思想:把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中包含一个元素，无需表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把他的排序码依次与有序元素的排序码进行比较，将他插入到有序表中的适当位置，使之成为新的有序表
public class InsertSort {
    public static void main(String[] args) {
        int arr[]={101, 34, 119, 1, -1, 90, 123};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        InsertSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    public static void InsertSort(int arr[]){
        int insertIndex=0;
        int insertVal=0;
        for (int i=1;i<arr.length;i++){
            insertVal=arr[i];
            insertIndex=i-1;
            while (insertIndex>=0&&insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            if(insertIndex!=i-1){
                arr[insertIndex+1]=insertVal;

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

4. 希尔排序

  • 希尔排序也是一种插入排序，他是简单插入排序经过该井之后的一个更高效的版本，也成为缩小增量排序
  • 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件被分成一组，算法便终止。
    image
    image
public class ShellSort {
    public static void main(String[] args) {
        int arr[]={101, 34, 119, 1, -1, 90, 123};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        shellSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
        shellSort2(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    //插入采用交换
    public static void shellSort(int arr[]){
        int temp=0;
        for (int grap=arr.length;grap>0;grap/=2){
            for (int i=grap;i<arr.length;i++){
                for (int j=i-grap;j>=0;j-=grap){
                    if (arr[j]>arr[j+grap]){
                        temp=arr[j];
                        arr[j]=arr[j+grap];
                        arr[j+grap]=temp;
                    }
                }
            }
        }
    }
    //插入采用移位
    public static void shellSort2(int arr[]){
        int temp;
        for (int grap=arr.length;grap>0;grap/=2) {
            for (int i = grap; i < arr.length; i++) {
                int j = i;
                temp = arr[j];
                if (arr[j] < arr[j - grap]) {
                    while (j-grap >= 0 && temp < arr[j - grap]) {
                        arr[j] = arr[j - grap];
                        j -= grap;
                    }
                }
                arr[j] = temp;
            }
        }
    }
}

5. 快速排序

  • 快速排序是对冒泡排序的一种改进，基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
    image
public class QuickSort {
    public static void main(String[] args) {
        int arr[]={101, 34, 119, 1, -1, 90, 123};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        quickSort(arr,0,arr.length-1);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int arr[],int low,int high){
        if (low<high){
            int index=getIndex(arr,low,high);
            quickSort(arr,low,index-1);
            quickSort(arr,index+1,high);
        }
    }

    private static int getIndex(int[] arr, int low, int high) {
        int temp=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=temp){
                high--;
            }
            arr[low]=arr[high];
            while(low<high&&arr[low]<=temp){
                low++;
            }
            arr[high]=arr[low];
        }
        arr[low]=temp;
        return low;
    }
}

6. 归并排序

  • 归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略(分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之)
    image
    image
public class MergeSort {
    public static void main(String[] args) {
        int arr[]={101, 34, 119, 1, -1, 90, 123};
        int []temp=new int[arr.length];
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        mergeSort(arr,0,arr.length-1,temp);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    public static void mergeSort(int arr[],int left,int right,int []temp){
        if (left<right){
            int mid=(left+right)/2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i=left;
        int j=mid+1;
        int t=0;
        while (i<=mid&&j<=right){
            if (arr[i]<=arr[j]){
                temp[t++]=arr[i++];
            }else{
                temp[t++]=arr[j++];
            }
        }
        while (i<=mid){
            temp[t++]=arr[i++];
        }
        while (j<=right){
            temp[t++]=arr[j++];
        }

        int leftIndex=left;
        t=0;
        while (leftIndex<=right){
            arr[leftIndex++]=temp[t++];
        }
    }

}

7. 基数排序

  • 基数排序介绍
    • 基数排序属于"分配式排序",又称"桶子法",通过键值的各个位的值，将要排序的元素分配至某些"桶"中，达到排序的作用
    • 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定排序法
  • 基本思想
    • 将所有待比较数值统一为同样的数位长度，数位较短的数前面补0。然后，从最低位开始，一次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
      image
public class BucketSort {
    public static void main(String[] args) {
        int arr[]={53,3,542,748,14,214};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        bucketSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    public static void bucketSort(int []arr){
        int bucket[][]=new int[10][arr.length];
        int max=arr[0];
        for (int i=0;i<arr.length;i++){
            if (max<arr[i]){
                max=arr[i];
            }
        }
        int bucketCounts[]=new int [10];
        int maxLen=(max+"").length();
        for (int i=0,n=1;i<maxLen;i++,n*=10) {
            for (int j = 0; j < arr.length; j++) {
                int digoutOfValue = arr[j] / n %10;
                bucket[digoutOfValue][bucketCounts[digoutOfValue]] = arr[j];
                bucketCounts[digoutOfValue]++;
            }

            int index = 0;
            for (int k = 0; k < bucketCounts.length; k++) {
                if (bucketCounts[k] != 0) {
                    for (int l = 0; l < bucketCounts[k]; l++) {
                        arr[index++] = bucket[k][l];
                    }
                }
                bucketCounts[k]=0;
            }
            System.out.println("第"+(i+1)+"轮排序"+Arrays.toString(arr));
        }
    }
}
平平无奇混吃等死的小y
关注
专栏目录
java插入排序
12-10
一个java插入排序程序，自己编的，可以运行成功！希望对大家有用啊
插入排序（java版）
jingnanyu的博客
05-28 107
基本推导 public static void insertSort(int[] arr){ //第一轮 //定义待插入的数 int insertVal=arr[1]; int insertIndex=1-1;//即arr[1]的前面数的下标 //给insertVal找到插入位置 //1、insertIndex>=0保证给insertVal找到插入位置，不越界 //2、insertVa
插入排序-java版
shengjk1的博客
04-11 185
1. 插入排序 1.1 插入排序的基本介绍 1.2 插入排序思想 1.3 插入排序的时间复杂度和空间复杂度等 2. 代码演示 1. 插入排序 1.1 插入排序的基本介绍 插入排序属于内排，就是以插入的方式来达到排序的目的 1.2 插入排序思想 将待排序的数组看成一个有序列表和一个无序列表。刚开始时有序列表只有一个元素 arr[0]，无序列表有n-2 的数据 arr[1] ~ arr...
直接插入排序（java版）
qq_31439011的博客
09-10 365
直接插入排序详解 直接插入排序的思想是：从第二个元素开始（因为第一个元素已经是有序的），然后依次将后面的元素插入到前面的有序序列中。内层循环一般从后面开始往前找，直到找到相应的位置，如下图所示： java代码如下： 1.双重for循环结构： public static void insertSort(int []arr){ int n=arr.length;//获取数组...
Java实现插入排序
weixin_48777366的博客
09-16 110
一、插入排序介绍 插入排序属于内部排序法，是对于欲排序的元素以插入的方式找寻元素的适当位置，以达到排序的目的。 二、插入排序法思想 插入排序的基本思想是：把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之称为新的有序表。 三、插入排序思路图 代码实现 public class InsertionSort { p.
java基础常用排序算法
08-02
Java基础常用的排序算法是编程学习中的重要组成部分，尤其对于初学者来说，掌握这些排序方法能够提升编程能力并有助于解决实际问题。在这个主题中，我们将深入探讨几种常见的排序算法，包括冒泡排序、插入排序、选择...
常用排序算法整理分享(快速排序算法、希尔排序)
01-20
Hoare发明，是目前最常用的排序算法之一。它的核心思想是“分治法”，即通过选取一个“基准”元素，将数组分为两部分，一部分所有元素都小于基准，另一部分所有元素都大于基准，然后对这两部分再分别进行快速排序。...
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
C++实现常用排序算法
07-15
在编程领域，排序算法是计算机科学中的基础但至关重要的部分，尤其在C++这样的系统级编程语言中。本文将深入探讨C++实现的几种常见排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序以及堆排序。 1. **...
常用排序算法介绍_示例程序|排序算法_程序.rar
10-26
本资源"常用排序算法介绍_示例程序"提供了一个深入理解这些算法的平台，结合了理论与实践，帮助开发者直观地看到各种排序算法的工作过程。 首先，让我们逐一探讨这些排序算法的核心思想： 1. **冒泡排序**：通过...
插入排序
weixin_42615154的博客
10-18 363
插入排序 ​ 插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。 1. 算法步骤 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置
Java插入排序（思路及实现）
qq_48718409的博客
10-20 1万+
Java数组排序——插入排序（Insertion Sort）思路及实现 1、概念及其介绍： ​ 插入排序（InsertionSort）,一般也被称为直接插入排序。对于少量元素的排序，他是一个有效的算法。 2、思路： ​ 它的基本思路是将一个记录插入到已经排序好的有序表中，从而得到一个新的、记录增加1的有序表。在实现过程中使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，进行移动。 3、适用说明： ​ 插入排序的平均时间复杂度是O(n2)，空间复杂度为常数阶
插入排序法（Java实现）
ZJLOVE的博客
08-12 5万+
插入法排序 ※ 插入法排序原理 利用插入法对无序数组排序时，我们其实是将数组R划分成两个子区间R[1．．i-1]（已排好序的有序区）和R[i．．n]（当前未排序的部分，可称无序区）。插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1．．i-1]中适当的位置上，使R[1．．i]变为新的有序区。因为这种方法每次使有序区增加1个记录，通常称增量法。 插入排序与打扑克时整理手上的...
Java常见排序算法之插入排序
xiaoxijinger的博客
04-12 1060
一、概述 本节由小千给大家分享Java常见排序算法之插入排序，之前我们说过排序是算法中的一部分。所以我们学习排序也是算法的入门，为了能让大家感受到排序是算法的一部分，我举个例子证明一下：比如麻将游戏，发完牌之后需要对手上的牌进行排序，大家想想，麻将排序如何排呢？它有什么特点呢？而且在摸牌打牌的过程中，我们要不断的排序，如何排序呢？选择什么排序算法最快呢？ 以上这种情况我们就可以分析选择哪种排序算法更高效。比如下图已经有一副固定顺序的牌了： 此时轮到我们摸牌，摸到的牌如下： 此时，要将这个“三同”放到上面
java实现插入排序（思路和实现）
热门推荐
疯狂的1024
06-06 6万+
插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。插入排序分析效果图：代码实现：public class Insert { public static void main(Strin...
直接插入排序的Java实现、性能分析以及适用场景
ZhuMin_ChosenOne的博客
08-15 8396
1.直接插入排序的Java实现：代码如下：package com.zm.testSort; /** * 直接插入排序类 * @author zm */ public class InsertSort { public static void getInsertSort(int[] a) { int n = a.length;//将数组的长度赋给n是为了防止每次for循环
八种经典排序算法
qq_25699299的博客
10-18 375
这些排序算法各有特点，适用于不同的场景和数据规模。在实际应用中，选择合适的排序算法可以显著提高程序的效率。掌握这些算法对于编程和面试都非常重要。
刷题 排序算法
seeaaan 的博客
10-11 1108
注意这道题目所有O(n^2)复杂度的算法都会超过时间限制，只有O(nlogn)的可以通过O(logn)递归的栈的调用O(n)临时数组O(logn)O(n)
【数据结构与算法】插入排序、希尔排序
最新发布
iiiiisss的博客
10-18 314
【代码】【数据结构与算法】插入排序、希尔排序。
Java版常用排序算法详解与实例
本文档主要介绍了常用排序算法在Java中的分析与实现，包括了多种排序方法，如插入排序、选择排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序以及基数排序。作者junJZ_2008花费了大量时间将这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值