冒泡排序、简单选择排序、直接插入排序、折半插入排序、快速排序、归并排序、堆排序

于 2021-04-10 15:54:34 发布
阅读量464 收藏 1
点赞数
分类专栏： java 剑指offer 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GLOAL_COOK/article/details/115578611
版权

一、冒泡排序

/**
 * @author QLBF
 * @version 1.0
 * @date 2021/4/10 15:30
 */
//冒泡排序
public class Maopao {
    public static int[] paixu(int []array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1-i; j++) {
                if (array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;

    }
    public static void main(String[] args) {
        int arr[]=new int[]{2,1,7,4,8,3,9,-1};
        int[] afterarr = paixu(arr);
        for (int i : afterarr) {
            System.out.println(i);
        }

    }
}

二、简单选择排序

选择排序原理即是，遍历元素找到一个最小（或最大）的元素，把它放在第一个位置，然后再在剩余元素中找到最小（或最大）的元素，把它放在第二个位置，依次下去，完成排序。


/**
 * @description: 简单选择排序
 * @param: * @param: null
 * @return:
 * @author QLBF
 * @date: 2021/4/11 17:09
 */
public class Xuanzhe {
    public static int[] paixu(int []array){
        for (int i = 0; i < array.length-1; i++) {
            int minIndex=i;
            for (int j = i+1; j < array.length; j++) {
                if (array[j]<array[minIndex]){
                    minIndex=j;
                }
            }

            if (i!=minIndex){
                int temp=array[i];
                array[i]=array[minIndex];
                array[minIndex]=temp;
            }
        }
        return array;
    }
    public static void main(String[] args) {
        int array[]={3,2,9,4,85,44,33,1,10};
        int[] paixu = paixu(array);
        for (int i : paixu) {
            System.out.println(i);
        }
    }
}

三、直接插入排序

原理说明：直接插入排序是一种最简单的插入排序方法，它的基本思想是，仅有一个元素的序列总是有序的，因此，对n 个记录的序列，可从第二个元素开始直到第n 个元素，逐个向有序序列中执行插入操作，从而得到n 个元素按关键字有序的序列。

/**
 * @author QLBF
 * @version 1.0
 * @date 2021/4/13 16:11
 */
public class EightSort {
    /**
     * @description: 直接插入排序
     * @param: * @param: null
     * @return:
     * @author QLBF
     * @date: 2021/4/13 17:06
     */
    public static int[] DirectInsertSort(int[] array){
        System.out.print("进行直接插入排序后的数组：");
        for (int i = 1; i < array.length; i++) {
            int temp=array[i];
            int j=i-1;
            while (j>=0 && temp<array[j]){
                array[j+1]=array[j];
                j--;
            }
            //这里是j+1而不是j++
            array[j+1]=temp;
        }
        return array;
    }

    public static void main(String[] args) {
        int array[]=new int[]{4,2,5,1,8,7,9,3};
        System.out.print("排序前数组：");
        for (int i : array) {
            System.out.print(i+" ");
        }
        System.out.println();

        int[] arrayafter = DirectInsertSort(array);

        for (int i : arrayafter) {
            System.out.print(i+" ");
        }
    }
}

四、折半插入排序

原理说明：折半插入排序是在直接插入排序的基础上，不断对半二分有序序列来寻找插入位置，即搜索插入位置的方法可以使用折半查找实现，是对直接插入排序的一种改进。

五、希尔排序

  • 参考
    先分组，再排序，gap=2，意思是把隔2个的元素组成一组，再运用插入排序的意思。
package com.yuan;

/**
 * @author QLBF
 * @version 1.0
 * @date 2021/5/22 16:13
 */
public class demo1 {
    public static void shellSort(int[] array){
        for (int gap = array.length/2; gap > 0; gap=gap/2) {
            for (int i = gap; i < array.length; i++) {
                for (int j = i-gap; j >=0 ; j=j-gap) {
                    if (array[j]>=array[j+gap]){
                        int temp=array[j];
                        array[j]=array[j+gap];
                        array[j+gap]=temp;
                    }
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int []array=new int[]{9,-2,4,3,4};
        shellSort(array);
        for (int i : array) {
            System.out.print(" "+i);
        }
    }
}

六、快速排序

参考：https://blog.csdn.net/qq_26122557/article/details/79458649


public class e8 {

    /**
     * @description: 快速排序
     * @param: * @param: null
     * @return:
     * @author QLBF
     * @date: 2021/4/20 18:59
     */
    public static void QuickSort(int[] array,int low,int high){

        int i=low;
        int j=high;
        //temp就是基准位
        if (low>high){
            return ;
        }
        //这个temp要在上面判断下，否则出错（又可能越界的）
        int temp=array[low];
        //这里用while而不用if
        while (i<j){
            //先从最右往左查小的，&&i<j条件不可少，=必须加的
            while (temp<=array[j] &&i<j){
                j--;
            }

            //再从最左往右查大的
            while (temp>=array[i]&&i<j){
                i++;
            }
            //如果它们都找到了大和小它们没相遇，则交换它们哨兵对应的值
            if (i<j){
                int temp2=array[i];
                array[i]=array[j];
                array[j]=temp2;
            }
        }

        //当它们相遇了则交换它们相遇的值和基准位
        array[low]=array[i];
        array[i]=temp;

        //递归调用左右半数组，注意取j还是high哦
        QuickSort(array,low,j-1);
        QuickSort(array,j+1,high);
    }

    public static void main(String[] args) {
        int array[]=new int[]{4,2,5,1,8,7,9,3};
        System.out.print("排序前数组：");
        for (int i : array) {
            System.out.print(i+" ");
        }
        System.out.println();
        QuickSort(array,0,array.length-1);
        System.out.print("经过快速排序后的数组：");
        for (int i : array) {
            System.out.print(i+" ");
        }
    }
}

参考：直接插入排序与折半插入排序——Java实现

七、归并排序

（分+合）

package com.yuan;

/**
 * @author QLBF
 * @version 1.0
 * @date 2021/5/23 17:13
 */
public class demo2 {
    //分+合
    public static void mergeSort(int[] array,int left,int right,int[] temp){
        if (left<right){
            int mid=(left+right)/2;
            //这里的mergeSort会把某两半变得有序（一直拆为1个），再进行merge的合并
            mergeSort(array,left,mid,temp);
            mergeSort(array,mid+1,right,temp);
            merge(array,left,right,mid,temp);
        }
    }
    //合
    public static void merge(int[] array,int left,int right,int mid,int[] temp){
        int i=left;
        int j=mid+1;
        int t=0;

        while (i<=mid && j<=right){

            if (array[i]<=array[j]){
                temp[t]=array[i];
                i++;
                t++;
            }else {
                temp[t]=array[j];
                j++;
                t++;
            }
        }
		//这里记得要写=
        while (i<=mid){
            temp[t]=array[i];
            i++;
            t++;
        }

        while (j<=right){
            temp[t]=array[j];
            j++;
            t++;
        }

        //赋值给这个数组
        t=0;
        int templeft=left;
        while (templeft<=right){
            array[templeft]=temp[t];
            t++;
            templeft++;
        }
    }
    public static void main(String[] args) {
        int []array=new int[]{9,-2,5,4};
        int[] temp=new int[array.length];
        mergeSort(array,0,array.length-1,temp);
        for (int i : array) {
            System.out.print(" "+i);
        }
    }
}

八、堆排序

参考王道考研视频
1.先构建大根堆或者小根堆（i从1开始）
在这里插入图片描述
9那里在这里插入图片描述

这里的左右孩子2i等还是得看你的具体的i从0开始还是从1开始。
若i从0开始，那么它的左孩子是2i+1,右孩子是2i+2
在这里插入图片描述好好把53下坠过程演示一遍就理解下面的代码了：

在这里插入图片描述
2.基于1构建的大根堆或者小根堆进行排序：
在这里插入图片描述每次换完堆顶元素和末尾元素，都要再次进行构建大根堆或者小根堆（就是1的过程）

排序代码：
在这里插入图片描述
代码如下(由于i从0开始，所以代码和上述代码有点出入，但是思想是一样的)：

package com.yuan.demo8;


/**
 * @author QLBF 堆排序
 * @version 1.0
 * @date 2021/6/11 11:20
 */
public class test8 {
    //1.建立大根堆
    public static void bulidMaxHeap(int[] array,int len){
        //i从 非叶子结点开始，i=array.len/2开始,i从0开始,所以还要-1
        for (int i = len/2-1; i >= 0; i--) {
            headAdjust(array,i,len);
        }
    }

    //2.(重点)将以k为根的子树调整为大根堆,len为要调整的长度，每次长度都不一样的（一开始构建大根堆是一样的）
    private static void headAdjust(int[] array, int k, int len) {
        int temp=array[k];  //temp暂存子树的跟结点
        //不断下坠的过程，由于i从0开始，所以这里2i+1才是左子树
        for (int i = 2*k+1; i < len ; i=i*2+1) {//沿值较大的子节点向下筛选
            //i<len-1 必不可少，判断有无右孩子的作业（i=len-1证明无有孩子了，因为这里i=2i+1,你要i=2i+2=len才有右孩子）
            if (i<len-1 && array[i] <array[i+1]){
                //就要指针指向左右子树中较大的一个
                i++;
            }
            //这是if而不是else if
            //这里是temp比较而不能用array[k]来比较
            if (temp>=array[i]){
                //就是当前结点比左右孩子都大，跳出
                break;
            }else {
                //否则把较大的孩子与当前孩子互换
                array[k]=array[i];
                k=i;
            }
        }
        array[k]=temp; //确定好最终下坠的位置，就把它原本的值还给它
    }



    //3.真正的堆排序完整逻辑
    //len传入不用-1,因为i从0开始
    public static void headSort(int[] array,int len){
        bulidMaxHeap(array,len); //调用1 初始建堆
       /* n-1趟交换和建堆过程，每次堆顶元素和末尾元素交换完，
        都得以末尾元素（此时在堆顶）重新构建一次堆*/
        for (int i = len-1; i > 0; i--) {
            //堆顶元素和末尾元素交换
            int temp=array[i];
            //这是把堆顶元素（最大值）赋值给数组的最后一个值（从此i末尾往前就是有序了）
            array[i]=array[0];
            array[0]=temp;
            
            headAdjust(array,0,i);//把剩余的待排序元素重新构建堆（最后一个已经是有序的，所以不用i+1了哦），这里的i为代构建堆的长度，不要和前面的i搞混了
        }

    }

    public static void main(String[] args) {
        int[] array=new int[]{8,-2,3,1,7,5,11,-3,4};
        headSort(array,array.length);
        for (int i : array) {
            System.out.println(i+" ");
        }
    }
}

可参考：堆排序

九、基数排序

下面演示递减
在这里插入图片描述
在这里插入图片描述
第一趟收集是从个位数大（因为我们要的是递减排序）的开始弄成一个链表，而且要队头放在前面

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

https://blog.csdn.net/weixin_44531966/article/details/116464294
六个排序

618GLOAL_COOK2237
关注
专栏目录
冒泡排序、选择排序、插入排序、堆排序
Lycorisradiata__的博客
05-28 1125
        本文主要讲解几种数据结构当中常用的排序算法，本文的例子与代码都以实现升序排序为基础。首先，给出实现排序的基础交换两个值的函数void Swap(int* a, int* b)//交换函数 { int ret = *a; *a = *b; *b = ret; return; } 一. 冒泡排序1. 实现思想：        遍历要排序的数列，每次遍...
C 中几种排序算法
weixin_34283445的博客
06-19 152
相关知识介绍（所有定义只为帮助理解相关概念，并非严格定义，请勿阅读此文后局限自己的思想）： 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就 说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5， 则我们说这...
简单选择排序、冒泡排序、直接插入排序、希尔排序、堆排序、归并排序
qq_27378875的博客
07-22 349
简单选择排序，最坏最好平均的时间复杂度都是O(n^2)，排序是稳定的 public class SelectiveSort{ public static void sSort(int[] nums){ if(nums==null||nums.length==0){ return; } int min; ...
数据结构排序算法之直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序（二路归并排序）C语言实现
c_cjiajia_的博客
06-13 3389
插入：直接插入、折半插入、希尔排序 交换：冒泡排序、快速排序⭐ 选择：简单选择排序、堆排序⭐ 归并：归并排序（二路归并排序）⭐ 快速排序、堆排序和归并排序为时间复杂度较小的排序方法，为O(nlogn); 英语不太好，有些算法就直接用拼音了... 这些算法的输入输出语句用的是cout.cin。（为C++内容，只需将头文件改为#include<iostream> using namespace std;即可兼容C\C++语句。或可直接将cin.cout语句改为scanf\printf语.
数据结构实验（C语言）：折半插入排序、快速排序
qq_44143507的博客
09-01 1092
文章参考过网上的内容，如有侵权，请联系 #include<stdio.h> #include<stdlib.h> typedef struct { int *data; //线性链表的初值 int length; }Sqlist; int Partition2(Sqlist &L,int low,int high) {//交换顺序表L中子表r[l...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
直接插入排序、折半排序、shell排序、冒泡排序、快速排序、选择排序、堆排序的实现
11-05
数据结构（c语言版）严蔚敏 吴伟民编著 中直接插入排序、折半排序、shell排序、冒泡排序、快速排序、选择排序、堆排序的实现、归并排序,使用c语言实现
排序算法java版，速度排行：冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序.mht
09-13
排序算法java版，速度排行：冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序.mht
排序方式 堆排序 选择 冒泡排序 归并排序 插入 选择
12-16
本资源包含了几种常见的排序算法，包括堆排序、选择排序、冒泡排序、归并排序和插入排序。这些排序算法各有特点，适用于不同的场景，并且在理解它们的工作原理后，能够帮助初学者更好地掌握编程基础。 1. **堆排序*...
直接插入、折半插入、冒泡、快速、简单选择等排序方法 用c语言实现
12-06
直接插入、折半插入、冒泡、快速、简单选择等排序方法 用c语言实现 代码运行正常 不会有任何的问题
六种内部排序算法比较：直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序。
12-04
六种内部排序算法比较：直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序。包含实验报告和源代码设计。
C++实现直接插入排序，折半插入排序，希尔排序，冒泡排序，简单选择排序，快速排序，堆排序
ringrang的专栏
08-31 4900
C++实现直接插入排序，折半插入排序，希尔排序，冒泡排序，简单选择排序，快速排序，堆排序。 如有不足之处，还望指正！  [cpp] view plaincopy // Sort.cpp : 定义控制台应用程序的入口点。   //      #include "stdafx.h"   #include       using namesp
冒泡排序，快速排序，直接插入排序，希尔排序，简单选择排序，堆排序，冒泡排序总结
跑够一万公里就结婚
08-15 987
从算法的简单性来看： 简单算法：冒泡排序，简单选择排序，直接插入排序 改进算法：希尔排序，堆排序，归并排序，快速排序 从平均情况来看：堆排序，归并排序，快速排序好于希尔排序 从最好情况来来看：冒泡排序和直接插入排序更好一些，要是待排数组基本有序，不应该考虑四种复杂算法 从最坏情况来看：堆排序与归并排序好于快排以及简单排序 从空间复杂度来看：归并排序需要额外开辟空间，时间复杂度为O(N),快...
C++实现内部排序算法(包含直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序）
qq_40945306的博客
09-09 997
1.直接插入排序。其中len的值为待排序数的长度+1，数组第一个空间用作辅助。基本思想：直接插入排序其基本操作就是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。这里就是将待排序的数插入已排序好的序列中从而实现排序。 void Sort::InsertSort() { int i, j; for (i = 2; i<this->len; i++) { ...
排序算法：直接插入排序，折半插入排序，冒泡排序，快速排序，简单选择排序
xiaoyeren_ITRoad的博客
05-24 2842
一、直接插入排序 基本操作是将一条记录插入到已排好序的有序表中，从而得到一个新的、记录数量增1的有序表。 算法步骤： ①设待排序的记录存放在数组r[1...n]中，r[1]是一个有序序列； ②循环n-1次，每次使用顺序查找法，查找r[i](i=2...n)在已排好序的序列r[1...i-1]中的插入位置，然后将r[i]插入表长为i-1的有序序列r[1...i-1]，直到r[n]插入表长为n-1的有序序列r[1...n-1]，最后得到一个表长为n的有序序列。 void insertsort(nod
C语言实现各个排序算法（直接插入排序，折半插入排序，希尔排序，冒泡排序，简单选择排序）
ring__wang的博客
09-24 3457
数据结构开发总结报告 ——内部排序综合设计程序的编程实现 实现各个排序算法（直接插入排序，折半插入排序，希尔排序，冒泡排序，简单选择排序） #include<stdio.h> #define MaxSize 20 #include<windows.h> typedef int KeyType; //定义关键字类型 typedef struct //记录类型 { KeyType key; //关键字项 } RecType;
❗⭕⭕算法——排序（直接插入，希尔，简单选择，堆排序，冒泡，快排，归并，基数）
qq_31870305的博客
09-18 1019
文章目录1 介绍1.1 八大排序分类1.2 时间复杂度1.3 空间复杂度2 插入排序-直接插入3 插入排序-希尔排序4 选择排序-简单选择排序5 选择排序-堆排序6 交换排序-冒泡排序7 交换排序-快速排序8 归并排序9 基数排序 1 介绍 1.1 八大排序分类 1.2 时间复杂度 图片来自于网络 1.3 空间复杂度 一个算法运行时，临时占用存储空间大小的度量，与解决问题的规模n有关，n较大时，会占用较多存储单元，例如快速排序和归并排序。 主要讨论时间复杂度，更看重执行速度，缓存产品（r
十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
热门推荐
Meditation
08-01 6万+
首先声明一下，本文只对七种排序算法做简单总结，并参照一些资料给出自己的代码实现，并没有对某种算法理论讲解，更详细的 了解可以参考以下资料（本人参考）： 1、《data structure and algorithm analysis in c 》 2、《大话数据结构》 3、http://blog.csdn.net/morewindows/article/details/7961256
冒泡，插入，折半插入，希尔，快速，简单选择排序的源代码总结
java开发指南博客 【转载】
08-02 177
#include &lt;iostream&gt; using namespace std; //各种排序方法： /**冒泡排序法**/ //它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。 ...
排序算法实现与分析：直接插入、折半、冒泡、快速等
本文主要介绍了数据结构学习中的排序算法，包括直接插入排序、折半插入、冒泡排序、快速排序、直接选择排序、堆排序和归并排序，并强调了掌握这些算法的基本思想、排序过程、算法实现以及进行性能分析的重要性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值