关于九种排序算法解析

最新推荐文章于 2023-12-23 20:02:39 发布
最新推荐文章于 2023-12-23 20:02:39 发布
阅读量118 收藏
点赞数 1
分类专栏： 大数据 算法 文章标签： 排序 合并排序 快速排序 插入排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingdianp/article/details/110150181
版权

注意： 快速排序是排序大数组的最常用算法

下表是各个排序算法的比较说明
在这里插入图片描述

插入排序：

是一个对少量元素进行排序的有效算法。实现比较简单。时间复杂度：O(n^2)，空间复杂度：O(1)。是稳定的排序方法。

void InsertionSort(int *a,int n)
{
    int temp;
    for(int i = 1;i < n;++i)
    {
        temp = *(a + i);
        int j = i - 1;
        while(j >= 0 && *(a + j) > temp)
        {
            *(a + j + 1) = *(a + j);
            --j;
        }
        *(a + j + 1) = temp;
    }
}

合并排序
采用分治法。将n个元素分成各含n/2个元素的子序列，用合并排序法对两个子序列递归的排序(子序列长度为1时递归结束)，最后合并两个已排序的子序列得到结果。时间复杂度：O(nlogn)，空间复杂度：O(n)。是稳定的排序方法。

//合并排序

#include <iostream>
using namespace std;

#define MAX_VALUE 100000//用于设置哨兵，避免检查是否每一个堆都是空的

//合并两个子数组的函数
void Merge(int *a,int p,int q,int r)
{
    int num1,num2;
    num1 = q - p + 1;
    num2 = r - q;
    int *a1 = (int*)malloc((num1 + 1) * sizeof(int));
    int *a2 = (int*)malloc((num2 + 1) * sizeof(int));
    for(int i = 0;i < num1;++i)
        *(a1 + i) = *(a + p + i);
    *(a1 + num1) = MAX_VALUE;//设置哨兵元素
    for(int i = 0;i < num2;++i)
        *(a2 + i) = *(a + q + 1 + i);
    *(a2 + num2) = MAX_VALUE;//设置哨兵元素
    
    //进行排序
    int index1 = 0;
    int index2 = 0;
    for(int i = p;i <= r;++i)
    {
        if(*(a1 + index1) < *(a2 + index2))
        {
            *(a + i) = *(a1 + index1);
            ++index1;
        }
        else
        {
            *(a + i) = *(a2 + index2);
            ++index2;
        }
    }
    free(a1);
free(a2);
}

冒泡排序
每一趟都比较相邻两个元素，若是逆序的，则交换。结束的条件应该是“在一趟排序过程中没有进行过交换元素的操作”。时间复杂度：O(n^2)，空间复杂度O(1)。是稳定的排序。

void BubbleSort(int *a,int n)
{
    int flag,temp;//标记是否进行过交换操作
    for(int i = 0;i < n - 1;++i)
    {
        flag = 0;
        for(int j = 0;j < n - 1 - i;++j)
        {
            if(*(a + j) > *(a + j + 1))
            {
                temp = *(a + j);
                 *(a + j) = *(a + j + 1);
                 *(a + j + 1) = temp;
                 flag = 1;
            }
        }
        if(flag == 0)break;
    }
}

快速排序
它是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将待排序元素分成两个部分，其中一部分元素比另一部分元素小。再分别对这两部分元素进行排序。以达到整个元素序列有序。时间复杂度：O(nlogn)，空间复杂度O(logn)，是不稳定的算法。

int Partition(int *a,int low,int high)
{
    int pivotKey = *(a + high);
    int i = low - 1;
    for(int j = low;j <= high - 1;++j)
    {
        if (*(a + j) < pivotKey)
        {
            ++i;
            int tmp = *(a + i);
            *(a + i) = *(a + j);
            *(a + j) = tmp;
        }
    }
  
    int tmp = *(a + i + 1);
    *(a + i + 1) = *(a + high);
    *(a + high) = tmp;
  
    return (i + 1);
}
  
void QuickSort(int *a,int low,int high)
{
    if(low < high)
    {
        int PivotLoc = Partition(a,low,high);
        QuickSort(a,low,PivotLoc - 1);
        QuickSort(a,PivotLoc + 1,high);
    }
}

堆排序：
一种原地排序算法，即在任何时刻数组中只有常数个元素存储在输入数组以外

//注意：下表都以1开始，而不是0
//得到父节点索引
int getParent(int i)
{
    return i>>1;
}
  
//得到左子树索引
int getLeftSon(int i)
{
    return i<<1;
}
  
//得到右子树索引
int getRightSon(int i)
{
    return ((i<<1) + 1);
}
  
//调整以某个节点i为根节点的子树为大根堆
void MaxHeapify(int A[],int i,int HeapSize)
{
    int left = getLeftSon(i);
    int right = getRightSon(i);
    int largest = i;//记录值最大的元素的索引
  
    if (left <= HeapSize && A[left] > A[i])
    {
        largest = left;
    }
  
    if (right <= HeapSize && A[right] > A[largest])
    {
        largest = right;
    }
  
    if (largest != i)//此子树不满足大根堆的性质，需要进行调整
    {
        //进行交换
        int temp = A[i];
        A[i] = A[largest];
        A[largest] = temp;
          
        MaxHeapify(A,largest,HeapSize);//递归调用，继续调整子树
    }
}
  
//输出数组元素
void printHeap(int A[],int HeapSize)
{
    for(int i = 1;i <= HeapSize;++i)
    {
        cout << A[i] << " ";
    }
    cout << endl;
}
  
//建堆
void buildMaxHeap(int A[],int HeapSize)
{
    for (int i = (int)floor((float)HeapSize / 2);i > 0;--i)
    {
        MaxHeapify(A,i,HeapSize);
    }
  
    cout << "建成的大根堆：" << endl;
    printHeap(A,HeapSize);
}
  
//堆排序
void heapSort(int A[],int HeapSize)
{
    buildMaxHeap(A,HeapSize);
    for (int i = HeapSize;i > 0;--i)
    {
        int temp = A[1];
        A[1] = A[i];
        A[i] = temp;
        MaxHeapify(A,1,i - 1);
    }
}

计数排序
思想是对每一个输入元素x，确定出小于x的元素的个数。然后我们就可以直接把它放在嘴中输出数组中相应的位置上。 但是计数排序基于这样一个假设：n个输入元素的每一个大小范围都是[0,k]。

void CountintSort(int A[],int *B,int n,int k,int *C)
{
    //初始化C数组
    for (int i = 0;i <= k;++i)
    {
        C[i] = 0;
    }
  
    for (int i = 0;i < n;++i)
    {
        ++C[A[i]];//C[i]：值等于i的元素的个数
    }
  
    for (int i = 1;i <= k;++i)
    {
        C[i] += C[i - 1];//C[i]：值小于等于i的元素的个数
    }
      
    for (int i = n - 1;i >= 0;--i)
    {
        B[C[A[i]] - 1] = A[i];//注意：下标索引从0开始！
        --C[A[i]];
    }
}

时间复杂度是O(k + n)。一般，当k = O(n)时，常常采用计数排序。这时候的运行时间为O(n)。计数排序是稳定的排序。
基数排序
算法思想

基数排序是从低位到高位依次对所有的数进行排序。如果所有的数最高位数是d，那么先按最低有效位数字进行排序，得到一个结果。然后往高位重复这个过程。需要注意的是，按位排序必须是稳定的排序算法。经常采用的是计数排序。

/********************************************************
*函数名称：GetNumInPos
*参数说明：num 一个整形数据
*         pos 表示要获得的整形的第pos位数据
*说明： 找到num的从低到高的第pos位的数据
*********************************************************/
int GetNumInPos(int num,int pos)
{
    int temp = 1;
    for (int i = 0; i < pos - 1; i++)
        temp *= 10;

    return (num / temp) % 10;
}

/********************************************************
*函数名称：RadixSort
*参数说明：pDataArray 无序数组；
*         iDataNum为无序数据个数
*说明： 基数排序
*********************************************************/
#define RADIX_10 10 //整形排序
#define KEYNUM_31 10 //关键字个数，这里为整形位数
void RadixSort(int* pDataArray, int iDataNum)
{
    int *radixArrays[RADIX_10]; //分别为0~9的序列空间
    for (int i = 0; i < 10; i++)
    {
        radixArrays[i] = (int*)malloc((iDataNum + 1)*sizeof(int));
        radixArrays[i][0] = 0; //index为0处记录这组数据的个数
    }
    
    for (int pos = 1; pos <=KEYNUM_31; pos++) //从个位开始到KEYNUM_31位
    {
        for (int i = 0; i < iDataNum; i++) //分配过程
        {
            int num = GetNumInPos(pDataArray[i], pos);
            int index = ++radixArrays[num][0];
            radixArrays[num][index] = pDataArray[i];
        }

        int j;
        for (i = 0, j =0; i < RADIX_10; i++) //收集
        {
            for (int k = 1; k <= radixArrays[i][0]; k++)
                pDataArray[j++] = radixArrays[i][k];
            radixArrays[i][0] = 0; //复位
        }
    }
}

桶排序
当输入数据符合均匀分布时，即可以以线性期望时间运行。即使输入不满足线性关系，桶排序也仍然可以以线性时间运行。只要输入满足这样一个性质，即各个桶尺寸的平方和与总的元素数呈线性关系。

桶排序的思想：
将区间[0,1)分成n个相同大小的子区间，或称为桶。然后将n个输入元素分布到各个桶中去。每个桶中的元素用一个链表来存储

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
  
using namespace std;
  
//桶中链表节点数据结构
typedef struct StructLinkNode{
    double elem;
    struct StructLinkNode *next;
}LinkNode,*LinkNodePtr;
  
//桶排序
void BucketSort(double *a,int n);
//删除一条链表
void deleteLinkList(LinkNodePtr head);
  
int main()
{
    srand(time(NULL));
    int n = 8;
    double *a = new double[n];
    for(int i = 0;i < n;++i)
        *(a + i) = rand() * 1.0 / RAND_MAX;
  
    cout << "Before sort : " << endl;
    for(int i = 0;i < n;++i)
        cout << *(a + i) << " ";
    cout << endl;
  
    BucketSort(a,n);
  
    cout << "After sort : " << endl;
    for(int i = 0;i < n;++i)
        cout << *(a + i) << " ";
    cout << endl;
}
  
//桶排序
void BucketSort(double *a,int n)
{
    //存放链表的数组
    LinkNodePtr *linkListArr = new LinkNodePtr[n];
    //初始化
    for (int i = 0;i < n;++i)
    {
        linkListArr[i] = new LinkNode;
        linkListArr[i]->elem = -1;
        linkListArr[i]->next = NULL;
    }
  
    //将n个输入元素依次放入n个桶中
    for (int i = 0;i < n;++i)
    {
        LinkNodePtr newNode = new LinkNode;
        newNode->elem = *(a + i);
        newNode->next = NULL;
  
        //将新元素插入对应桶的链表的正确位置
        int index = floor(n * *(a + i));
        LinkNodePtr loopPtr = linkListArr[index]->next;
        LinkNodePtr prevPtr = linkListArr[index];
        while(loopPtr != NULL && *(a + i) > loopPtr->elem)
        {
            prevPtr = loopPtr;
            loopPtr = loopPtr->next;
        }
        newNode->next = loopPtr;
        prevPtr->next = newNode;
    }
  
    int count = 0;
    for (int i = 0;i < n;++i)
    {
        LinkNodePtr loopPtr = linkListArr[i]->next;
        while(loopPtr != NULL)
        {
            *(a + count) = loopPtr->elem;
            ++count;
            loopPtr = loopPtr->next;
        }
    }
  
    for (int i = 0;i < n;++i)
        deleteLinkList(linkListArr[i]);
}
  
//删除一条链表
void deleteLinkList(LinkNodePtr head)
{
    if (NULL == head)
    {
        return;
    }
    deleteLinkList(head->next);
    delete head;
}
星点xingdian
关注
专栏目录
9种常见内部排序算法的性能比较
Thinker的专栏
11-15 5625
在写完这9种常见的内部排序算法后总觉得需要把它们拿出来好好比较一番，看看各个算法的性能优劣。 我们先来看看各个排序算法的理论性能，再看实际性能。
Python——常见排序算法解析
m0_59485658的博客
12-03 637
非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。
【算法学习】线性时间排序-计数排序、基数排序和桶排序详解与编程实现
计算机专业同学的充电站。
03-28 3030
计数排序 计数排序假设n个输入元素中的每一个都是介于0到k之间的整数。此处k为某个整数（输入数据在一个小范围内）。 算法思想 计数排序的基本思想是对每一个输入元素x，确定出小于x的元素的个数。然后再将x直接放置在它在最终输出数组中的位置上。 由于数组中可能有相等的数，在处理时需要注意。 时间复杂度和空间复杂度分析 算法总时间Θ(k + n)。当k
九种常用排序的性能分析总结
热门推荐
一个程序员的修炼之路
09-07 1万+
间间断断的将9种排序实现，并且将其以博客笔记的形式记录下来；现在就该来综合的分析这九种排序，让我们先来看看其算法复杂度和稳定性的分析结果： 算法复杂度以及稳定性分析 算法名称 平均时间 辅助空间 稳定性 冒泡排序 O(n2) O(1) 是 选择排序 O(n2) O(1) 否 插入排序 O(n2) O(1) 是 自底
算法导论-- 线性时间排序(计数排序、基数排序、桶排序)
勿在浮砂筑高台
04-14 4185
线性时间排序 1.计数排序 2.基数排序 3.桶排序
八大经典、常用排序算法的原理、Java 实现以及算法分析
多选参数
06-17 323
0. 前言大家好，我是多选参数的程序锅，一个正在 neng 操作系统、学数据结构和算法以及 Java 的硬核菜鸡。数据结构和算法是我准备新开的坑，主要是因为自己在这块确实很弱，需要大补（...
【数据结构考研】九种内部排序算法代码及排序过程图示
07-19
最后，该资源提供了一个CSDN博主的链接，博主详细解释了每种排序算法，并且包含了一些408真题的讲解，这对于考研备考者来说是一份宝贵的参考资料。通过这些内容的学习，不仅可以理解排序算法的基本思想，还能掌握其...
C++九种排序算法详解及示例
本文将详细介绍C++中的九种排序算法，包括直接插入排序、折半插入排序、希尔排序以及直接选择排序，以便于开发者在学习和工作中能更好地理解和实践。以下是每种排序算法的详细解析： 1. 直接插入排序： - 直接插入...
排序算法解析：稳定性与分类
"数据结构（本科）辅导第九章主要涵盖了排序的基本概念、稳定性和分类，以及内部排序的几种策略，并提到了排序算法分析中的基本操作。" 在数据结构的学习中，排序是一个至关重要的主题，特别是在本科阶段。第九章的...
【数据结构入门精讲 | 第九篇】考研408排序算法专项练习（一）
最新发布
等风来
12-23 3725
1.希尔排序是稳定的算法。（错） 解析：稳定性是指如果两个元素在排序前后的相对顺序保持不变，那么这个排序算法就是稳定的。对于具有相同关键字的元素，排序后它们的相对位置应该保持不变。 2.仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。（对） 3.对N个记录进行归并排序，归并趟数的数量级是O(NlogN)。（错） 答案：O(logN) 4.对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。（错）
JavaScript实现的九种排序算法
12-11
前言 排序是数据结构主要内容，并不限于语言主要在于思想；大学曾经用C语言研究过一段时间的排序实现， 这段时间有空用JS再将排序知识点熟悉一遍。 下面话不多说了，来一起看看详细的介绍吧 一、代码汇总(一) 1、冒泡排序 2、改进版冒泡排序 3、选择排序 4、直接插入排序 5、二分插入排序 /* * @Author: laifeipeng * @Date: 2019-02-20 10:00:36 * @Last Modified by: laifeipeng * @Last Modified time: 2019-02-21 11:57:58 */ /********* 1、
线性时间排序(计数排序、基数排序、桶排序)
rock_joker的博客
08-18 568
转载:http://blog.csdn.net/luoshixian099/article/details/45043337 线性时间排序   前面介绍的几种排序，都是能够在复杂度nlg(n)时间内排序n个数的算法，这些算法都是通过比较来决定它们的顺序，这类算法叫做比较排序 。下面介绍的几种算法用运算去排序，且它们的复杂度是线性时间。 ——————————————————————
数据结构与算法——线性时间排序（计数排序、基数排序、桶排序）
关注校招求职，微信号：job_campus
07-09 1293
前言：计数排序、基数排序he
简单算法之9种排序
weixin_33758863的博客
11-19 101
甭管什么，笔者就喜欢凑个9。这次，关于排序的算法还是9种，小结一下。排序的算法，尽管有很多的方法例子，但这次是自己总结的，挺有意思算法希望大家喜欢。直接上代码楼，以下算法，都经过笔者亲测，并修改使之有效（粘贴可用）。 package com.css.java.learning.massbag; import java.util.Arrays; /**算法： * 排序相关小结 * @author...
9种排序方法
fool_best的博客
01-19 377
#9种常用排序方法如下 #插入排序 Insertion Sort 对未排序数据中进行从后向前的扫描，并找到相应的位置插入 #include<stdio.h> #include<stdio.h> #include<string.h> void insertion_sort(int arr[],int len) { int i,j,temp; ...
九大排序算法总结
shinecjj的博客
09-03 3292
1、堆排序 2、归并排序 3、快速排序 4、基数排序 5、计数排序 6、选择排序 7、冒泡排序 8、插入排序 9、希尔排序 10、空间复杂度 11、时间复杂度 与稳定性 辅助记忆： 1）推排序—— 2）归并排序—— 3）快速排序—— 1、堆排序 import java.util.*; public class HeapSort { public i...
9种排序算法
维生素C吃多了会上火
03-23 607
维生素C吃多了会上火-个人CSDN博文目录 2022蓝桥杯 目录第一类选择排序插入排序冒泡排序第二类堆排序归并排序快速排序第三类计数排序基数排序桶排序 第一类 选择排序 选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，继续放在起始位置直到未排序元素个数为0。 #include<bits/stdc++.h> using namespace std; int a[100]
九种排序算法
Paranoid_cc的博客
06-26 660
一、插入排序 有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法, （1）算法适用于少量数据的排序， （2）时间复杂度为O(n^2)。 （3）是稳定的排序方法。 插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值