数据结构--排序算法

最新推荐文章于 2024-01-20 09:45:00 发布
最新推荐文章于 2024-01-20 09:45:00 发布
阅读量280 收藏 1
点赞数 1
分类专栏： 【数据结构】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alibaba_lhl/article/details/84573427
版权

Ps：one:程序的数据存储均是从下标1开始的。 two:以下程序均是升序。

直接插入排序（O(n^{2}) 稳定排序）

思路：插入排序是一种比较容易想到的算法，它的思路有点向我们打扑克时排列手牌的操作。比如我们要把手中的牌从左至右，从小到大进行排序。此时只需要将牌一张张抽出来，依次插入到前面已经排好的适当位置。只需重复这一操作直至插入最后一张牌，排序就已经完成了。（注意：二分中的写法，使high所指的值为 小于或等于 未排序顺序表中的第一个数）

code one(伪代码)

void InsertSort(int a[], int len) //len为元素个数
{
    int i, j, v;
    for(int i=2; i<=len; i++)
    {
        v = a[i]; //取出未排序部分开头的元素赋值给变量v
        j = i - 1;
        while(j>1 && a[j]>v) //在已排序部分，将所有比v大的元素向后移动一个单位
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = v; //将已取出的元素v插入空位
    }
}

code two（顺序表实现）

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e4+10;
int n;
typedef struct
{
    int key;
    char *otherinfo;
}ElemType;
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
void GetData(SqList &L) 
{
    L.length = 0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&L.elem[i].key);
        L.length++;
    }

}
void InsertSort(SqList &L)
{
    int i, j, v;
    for(i=2; i<=n; i++)
    {
        L.elem[0] = L.elem[i];
        j = i - 1;
        while(j>=1 && L.elem[0] < L.elem[j].key)
        {
            L.elem[j+1] = L.elem[j];
            j--;
        }
        L.elem[j+1] = L.elem[0];
    }
}
void print(SqList L)
{
    for(int i=1; i<=L.length; i++) printf("%d ",L.elem[i].key);
}
int main()
{
    cin>> n;
    SqList L;
    L.elem = new ElemType[MAXN];
    GetData(L);
    InsertSort(L);
    print(L);
    return 0;
}

折半插入排序（O(n^{2}) 稳定排序）

上面的直接插入排序采用顺序查找法查找当前未排序部分的首个元素可以插入的[适当]位置，这个查找过程可以用二分查找来实现，剩下的是和直接插入排序相同的。

code one(伪代码)

void BInsertSort(int a[], int len)
{
    int i, j, v;
    for(i=2; i<=len; i++)
    {
        v = a[i];
        int low = 1, high = i-1, mid; //置查询区间初值，
        while(low<=high) //在已经排好序的序列二分查找可以插入的位置
        {
            mid = (low+high)>>1; //二分
            if(a[mid]>v) high = mid - 1; //插入点在前一子表
            else  low = mid + 1; //插入点再后一子表
        }
        for(j=i-1; j>=high+1; j--) a[j+1] = a[j]; //记录后移
        a[high+1] = v; //插入到合适位置
    }
}

code two(顺序表实现)

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e4+10;
int n;
typedef struct
{
    int key;
    char *otherinfo;
}ElemType;
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
void GetData(SqList &L) 
{
    L.length = 0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&L.elem[i].key);
        L.length++;
    }
}
void BInsertSort(SqList &L)
{
    int i, j;
    for(i=2; i<=n; i++)
    {
        L.elem[0] = L.elem[i];
        int low = 1, high = i-1, mid;
        while(low<=high)
        {
            mid = (low+high)>>1;
            if(L.elem[mid].key>L.elem[0].key) high = mid - 1;
            else low = mid + 1;
        } 
        for(j=i-1; j>=high+1; j--) L.elem[j+1] = L.elem[j];
        L.elem[high+1] = L.elem[0];
    }
}
void print(SqList L)
{
    for(int i=1; i<=L.length; i++) printf("%d ",L.elem[i].key);
}
int main()
{
    cin>> n;
    SqList L;
    L.elem = new ElemType[MAXN];
    GetData(L);
    BInsertSort(L);
    print(L);   
    return 0;
}

 希尔排序(O(n* (log n )^{2}) 不稳定排序)

希尔排序又称“缩小增量排序”，该排序是在简单插入排序基础上进一步改进而得到的算法。 

实现该算法的核心：InsertionSort(A,n,g)是仅以间隔为g的元素为对象进行的插入排序。

                                ShellSort(A,n)则是以InsertionSort(A,n,g)的循环，并且在每轮循环后逐渐缩小g的范围。

插入排序法可以高速处理顺序较整齐的数据，而希尔排序法就是充分发挥这一特长的高速算法。

code one

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5+10;
int a[MAXN];
vector<int> G;
void GetData(int f[], int len)
{
    int i;
    for(i=1; i<=len; i++) scanf("%d",&a[i]);
}
void Print(int a[],int len)
{
    int i;
    for(int i=1; i<=len; i++) printf("%d ",a[i]);
}
void InsertionSort(int a[], int len, int g)//仅以间隔为g的元素为对象进行插入排序
{
    for(int i=g; i<=len; i++)
    {
        int v = a[i];
        int j = i - g;
        while(j>=1 && a[j]>v)
        {
            a[j+g] = a[j];
            j -= g;
        }
        a[j+g] = v;
    }
}
void ShellSort(int a[],int len)
{
    //生成数列G = {1,4,13,40,121,364,1093,,,}
    for(int h = 1; ; )
    {
        if(h>len) break;
        G.push_back(h);
        h = 3*h+1;
    }
    int t = G.size() - 1;
    for(int i=t; i>=0; i--) InsertionSort(a,len,G[i]);
}

int main()
{
    int n;
    cin>> n;
    GetData(a,n);
    ShellSort(a,n);
    Print(a,n);
    return 0;
}

code two（顺序表实现）

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e4+10;
int n;
vector<int> G;
typedef struct
{
    int key;
    char *otherinfo;
}ElemType;
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
void GetData(SqList &L) 
{
    L.length = 0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&L.elem[i].key);
        L.length++;
    }
}
void print(SqList L)
{
    for(int i=1; i<=L.length; i++) printf("%d ",L.elem[i].key);
}
void InsertionSort(SqList &L, int len, int g)
{
    for(int i=g; i<=len; i++)
    {
        ElemType v = L.elem[i];
        int j = i-g;
        while(j>=1 && L.elem[j].key > v.key)
        {
            L.elem[j+g] = L.elem[j];
            j = j - g;
        }
        L.elem[j+g] = v;
    }
}
void ShellSort(SqList &L, int len)
{
    for(int h=1; ;)
    {
        if(h>len) break;
        G.push_back(h);
        h = 3*h+1;
    }
    int t = G.size() - 1;
    for(int i=t; i>=0; i--) InsertionSort(L,len,G[i]);
}
int main()
{
    cin>> n;
    SqList L;
    L.elem = new ElemType[MAXN];
    GetData(L);
    ShellSort(L,L.length);
    print(L);
    return 0;
}

冒泡排序（O(n^{2})稳定排序）

冒泡排序是一种最简单的交换排序方法。它通过两两比较相邻的关键字，如果发生逆序，则进行交换，从而使关键字小的记录“漂浮”，或者使关键字较大的“坠落”。

算法核心：从数组尾端a[n]开始依次向前遍历,将相邻的两个进行比较，较小的排在前面。这样遍历到最前面时，则最小的数据冒出。循环进行该操作，使已排序部分增加，未排序部分减少。设置flag标志的意义在于:若进行一次从后到前的遍历后，若无数据进行交换，则证明该组数据已经排序完毕。

冒泡排序法对相邻的元素进行比较和交换，因此键值相同的元素不会改变顺序，所以冒泡排序是一种稳定的排序算法。但注意：如果将比较运算改为a[j]<=a[j-1],就会失去稳定性。

PS:冒泡排序算法中的交换次数又称为反序数或逆序数，可以体现数列的混乱程度。

code one(伪代码)

void BubbleSort(int a[], int len)
{
    bool flag = true;
    for(int i=1; flag; i++)
    {
        flag = false;
        for(int j=len; j>i; j--)
        {
            if(a[j]<a[j-1]) 
            {
                swap(a[j],a[j-1]);
                flag = true;
            }
        }
    }
}

code two（顺序表实现）

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e4+10;
int n;
vector<int> G;
typedef struct
{
    int key;
    char *otherinfo;
}ElemType;
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
void GetData(SqList &L) 
{
    L.length = 0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&L.elem[i].key);
        L.length++;
    }
}
void print(SqList L)
{
    for(int i=1; i<=L.length; i++) printf("%d ",L.elem[i].key);
}
void BubbleSort(SqList &L, int len)
{
    bool flag = true;
    for(int i=1; flag; i++)
    {
        flag = false;
        for(int j=n; j>i; j--)
        {
            if(L.elem[j].key<L.elem[j-1].key)
            {
                swap(L.elem[j],L.elem[j-1]);
                flag = true;
            }
        }
    }
}
int main()
{
    cin>> n;
    SqList L;
    L.elem = new ElemType[MAXN];
    GetData(L);
    BubbleSort(L,L.length);
    print(L);
}

快速排序（O(nlogn)）  

code one(伪代码)

void QuickSort(int a[], int st, int ed)
{
    if(st>=ed-1) return ;
    int low = st;
    int high = ed;
    int val = a[low];
    while(low<high)
    {
        while(low<high)
        {
            if(a[high]<=val)
            {
                a[low++] = a[high];
                break;
            }
            --high;
        }
        while(low<high)
        {
            if(a[low]>=val)
            {
                a[high--] = a[low];
                break;
            }
            ++low;
        }
    }
    a[low] = val;
    QuickSort(a, st, low);
    QuickSort(a, high+1, ed);
}

简单选择排序（O(n^{2})不稳定排序）

选择排序算法是一种非常直观的排序算法，又被称为直接选择排序。

算法核心：每遍历一趟，选出未排序部分的最小值放在已排序的最大值的后面。直至未排序部分长度为0.

code one(伪代码)

void SelectionSort(int a[], int len)
{
    int minj;
    for(int i=1; i<len; i++)
    {
        minj = i;
        for(int j=i+1; j<=len; j++)
        {
            if(a[minj]>a[j]) minj = j;
        }
        if(i!=minj) swap(a[i],a[minj]);
    }
}

code two(顺序表实现)

#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e4+10;
int n;
vector<int> G;
typedef struct
{
    int key;
    char *otherinfo;
}ElemType;
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
void GetData(SqList &L) 
{
    L.length = 0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&L.elem[i].key);
        L.length++;
    }
}
void print(SqList L)
{
    for(int i=1; i<=L.length; i++) printf("%d ",L.elem[i].key);
}
void SelectionSort(SqList &L, int len)
{
    int minj;
    for(int i=1; i<len; i++)
    {
        minj = i;
        for(int j=i+1; j<=len; j++)
        {
            if(L.elem[minj].key>L.elem[j].key) minj = j;
        }
        if(i!=minj) swap(L.elem[i],L.elem[minj]);
    }
}
int main()
{
    cin>> n;
    SqList L;
    L.elem = new ElemType[MAXN];
    GetData(L);
    SelectionSort(L,L.length);
    print(L);
}

 

 

 

 

 

 

 

 

 

 

 

 

 

Andy--lee
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法----不稳定排序
mistakk
09-20 1万+
1 不稳定排序     稳定排序的定义是：在排序过程中，如果两个键的值相同，那么他们的相对位置不发生变化。不符合该规则的排序算法不是稳定排序算法。   2 排序算法 冒泡排序： 通过元素两两交换的方式，每次将数组的未排序区域的一个最大/小元素归位 插入排序： 通过元素插入的方式，每次将数组的未排序区域的一个最值元素归位 选择排序： 通过单个元素相互交换的方式，每次将数组的未排序区域的一...
八大排序2——不稳定排序
Hello_1024的博客
10-16 2276
不稳定排序有四种： 快速排序（quick）：每次在一个数组的空间中选择一个基准值，一般选择第一个。以升序为例，从后开始找第一个比基准值小的数，用j来标记。从头开始找第一个比基准值大的数，用i来标记。找的过程中要始终保证i&amp;amp;lt;j。直到某一次ij。如果是先从后向前找，那么在ij之前一定是j在跑，所以i和j所指向的数字一定是小于等于基准值的，这也是为什么先从后向前找的原因。然后再将基准值和该数进行...
不稳定排序算法有哪些
热门推荐
只为成功找方法 不为失败找借口
10-03 2万+
一、不稳定排序算法有哪些 1、堆排序 2、希尔排序 3、快速排序 4、选择排序 口诀：一堆（堆）希尔（希尔）快（快速）选（选择） 二、常见排序算法稳定性分析 1、堆排序稳定性分析 我们知道堆的结构是节点i的孩子为 2*i 和 2*i+1 节点，大顶堆要求父节点大于等于其 2 个子节点，小顶堆要求父节点小于等于其 2 个子节点。 在一个长为 n 的序列，堆排序的过程是从第 n/2 开始和其子节点共 3 个值选择最大（大顶堆）或者最小（小顶堆），这 3 个元素之间的选择当然不...
不稳定的排序-选择排序
NICHUN12345的博客
09-23 4868
前言 选择排序是直观的排序，通过确定一个最大或最小值，再从待排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)。简单选择排序是不稳定排序。 算法性能 时间复杂度: O(n^2)，选择排序比冒泡排序快。 稳定性: 不稳定 代码实现 /*选择排序 */ #include <stdio.h> void select_sort(int arr[],int n); //选择排序函数声明 int main() { int i = 0; int a
八大排序总结篇
须知少日拏云志，曾许人间第一流。
11-16 1573
一、前言到这里，数据结构的八大排序就算是全部写完了。这一期总结篇我们来测试一下八大排序的效率，印证一下八大排序的时间复杂度，以及深度剖析一下八大排序的稳定性问题。二、八大排序。
数据结构-排序算法
程国华的专栏
05-11 645
设有n个记录R[1]~R[n]。 一、插入排序 1. 直接插入排序      直接插入排序是指将R[i]~R[n]插入到已经有序的R[1]~R[i-1]序列中。R[0]是一个哨兵，起到作为边界条件并作为暂存单元的作用。      实际上，一切为简化边界条件而引入的附加节点（元素）均可称为哨兵。例如单链表中的头结点。      对于有n个记录的集合，要进行n-1趟排序。      其
数据结构--九种排序算法 --排序001.cpp
11-22
此文件为数据结构中的九种排序算法，包含一些排序方法的过程，其九种排序包括：直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序！
数据结构--算法相关.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
LUT算法与数据结构-- 排序算法比较问题和学生搭配问题
12-10
总之，这个项目提供了对基础算法和数据结构的实战练习，涵盖了排序算法的性能分析和实际问题的解决，对于提升编程思维和问题解决技巧有着积极的作用。通过深入研究和实施，可以加深对这些概念的理解，并为未来更复杂...
数据结构-算法.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
LUT算法与数据结构--排序算法比较问题和教学计划编制问题
12-10
本项目聚焦于"LUT算法"（可能是指查找表Look-Up Table）与数据结构的应用，特别是针对排序算法的比较以及教学计划编制问题。以下是这些主题的详细讨论。 首先，排序算法是计算机科学中的基本操作，用于将一组数据...
几种常见的排序方法
weixin_41812379的博客
03-11 404
快速排序 快速排序体现了分治的思想。每次决定一个数的最终位置，将其放置到正确位置后，再通过递归的方式将两头的数组按照同样的方式快速排序。 需要注意的是，使用快速排序时，需要随机取那个决定数，这叫做随机选择比较子。因为当数组时已排好序的时候，指针只会从尾刷到头，快速排序的效率就会非常低，时间复杂度为O(n^2)。所以随机选择比较子后，将比较子和数组最左边的数交换，再做排序。这样的话就算数字已经排好序了，指针也不会从尾刷到头。 快速排序是一种不稳定的算法。算法不稳定是指：在排序之前，有两个数相等，但是在排序结
哪些排序是不稳定的?稳定又意味着什么？
从此不在404的博客
06-21 2万+
最近有看到稳定排序和不稳定排序这一说，貌似还是挺常识的概念，排序可能大家在面试当中经常被问到，但是对于稳定性和不稳定性，又了解多少呢？下面通过这篇文章给大家全面讲解一下。 对于排序稳定性的意义： 通俗地讲就是待排序的序列中有两元素相等,排序之后它们的先后顺序不变。例如：如果Ai = Aj，Ai原来在位置前，排序后Ai还是要在Aj位置前。 其次就是稳定性带来的好处： 我们平时自...
稳定和不稳定排序
mabiao6822的博客
06-20 5461
稳定的排序算法：直接插入排序、冒泡排序、归并排序 不稳定的排序算法：希尔排序、快速排序、简单选择排序、堆排序 Q:为什么直接插入排序稳定？ A:因为每加入一个新的数都要把它和前面排好序的最后一位对比，比它大则直接放后面；比它小则往前插入；如果遇到相等的，就不往前插了，直接放后面，这样可以确保相同值相对顺序不变。因此是稳定的。 Q:为什么冒泡排序稳定？ A:每一次的比较都是前一个数与后一个数比较，如...
稳定排序与不稳定排序的区别
Think_and_work的博客
05-06 6742
稳定和不稳定排序详解 参考：https://www.jianshu.com/p/7c03e5eb143c 稳定排序有：插入排序、冒泡排序、归并排序、基数排序 不稳定排序有：选择排序、快速排序、希尔排序、堆排序 稳定排序 插入排序： 在一个有序的序列中插入一个数，使插入后的序列保持有序。 因为插入的过程中都是从后向前进行查找，遇到小于等于(或大于等于)的数停止寻找，进行插入操作。 不改变排序前后相等数值的相对顺序，故使稳定的排序算法。 冒泡排序： 冒泡故名思义，数值小的向上飘，数值大的向下
数据结构与算法_排序_不稳定性算法
最新发布
m0_66672931的博客
01-20 618
不稳定的排序算法:选择排序、快速排序、希尔排序、堆排序具有相同关键字的纪录经过排序后，相对位置发生改变，这样的算法是不稳定性算法算法思想的本身是独立于编程语言的,所以你写代码去实现算法的时候很多细节可以做不同的处理.采用不稳定算法不管你具体实现时怎么写代码,最终相同元素位置总是不确定的 (可能位置没变也可能变了).
不稳定排序
有点皮的博客
01-01 608
假设有这样一个待排序列表: 排序前：              1             3           2          4            5          2 排序前的下标：a[0]       a[1]       a[2]      a[3]       a[4]     a[5] 排序后：             1              2     ...
数据结构之线性表（顺序表，单链表，循环链表，双向链表）-- 图书管理系统
Alibaba_lhl的博客
09-09 4499
顺序表 #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdlib&gt;///exit()头文件exit(0):正常执行程序并退出程序。exit(1):非正常执行导致退出程序 #include &lt;fstream&gt;///fstream是C++ STL中对文件操作的合集 #include &lt;io...
数据结构-十大经典排序算法
07-27
十大经典排序算法是指在计算机科学中常用的排序算法，它们分别是： 1. 冒泡排序（Bubble Sort）：重复地比较相邻的两个元素，将较大的元素逐渐向右移动。 2. 选择排序（Selection Sort）：每次从未排序的部分选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值