排序排序排序

最新推荐文章于 2023-06-28 11:01:37 发布
最新推荐文章于 2023-06-28 11:01:37 发布
阅读量124 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46245582/article/details/119304222
版权

内部排序

1、插入排序

直接插入排序

#include <iostream>
using namespace std;


void InsertSort(SqList &L){  //对顺序表L作直接插入排序
	for(i=2;i<=L.length;++i)
	if(LT(L.r[i].key,L.r[i-1].key)){//需将L.r[i]插入有序子表
		L.r[0]=L.r[i];//复制为哨兵
		L.r[i]=L.r[i-1];
		for(j=i-2;LT(L.r[0].key,L.r[j].key);--j)
		L.r[j+1]=L.r[j];//记录后移
		L.r[j+1]=L.r[0];//插入到正确位置
	}
}

折半插入排序

void BInsertSort(SqList &L){//对顺序表L作折半插入排序
	
	for(i=2;i<=L.length;++i){
		L.r[0]=L.r[i];//将L。r[i]暂存到L.r[0]
		low=1;high=i-1;
		while(low<=high){//在r[low.high]中折半查找有序插入的位置
			m=(low+high)/2;//折半
			if(LT(L.r[i].key,L.r[i-1].key))//插入点在低半区
			high=m-1;
			else low=m+1;//插入点在高半区
		}
		for(j=i-1;j>=high+1;--j)//记录后移
		L.r[j+1]=L.r[j];
		L.r[high+1]=L.r[0];//插入
	}
	
}

表插入排序

#include <iostream>
using namespace std;


#define SIZE 100   //静态链表容量 
typedef struct{
	RcdType rc;//记录项 
	int next;//指针项 
}SLNode;//表结点类型 
typedef struct{
	SLNode r[SIZE];//0号单元为表头结点 
	int length;//链表当前长度 
}SLinkListType;//静态链表类型

希尔排序

#include <iostream>
using namespace std;


void ShellSort(SqList &L,int dlta[],int t){//按增量序列dlta[0...t-1]对顺序表L作希尔排序 
	for(k=0;k<t;++k)
	ShellInsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序 
}

void ShellInsert(SqList &L,int dk){//对顺序表L作一趟希尔插入排序
//前后记录位置的增量是dk，而不是1；r[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已找到 
	for(i=dk+1;i<=L.length;++i)
	if(LT(L.r[i].key,L.r[i-dk].key)){//需将L.r[i]插入有序增量子表 
		L.r[0]=L.r[i];//暂存在L.r[0] 
		for(j=i-dk;j>0&&LT(L.r[0].key,L.r[j].key);j-=dk)
		L.r[j+dk]=L.r[j];//记录后移，查找插入位置 
		L.r[j+dk]=L.r[0];//插入 
	}
}

2、快速排序（是目前认为最好的一种内部排序方法）

#include <iostream>
using namespace std;


void QSort(SqList &L,int low,int high){//对顺序表L中子序列L.r[low..high]作快速排序 
	if(low<high){//长度大于1 
		pivotloc=Partition(L,low,high);//将L.r[low..high]一分为二 
		QSort(L,low,pivotloc-1);//对低子表递归排序，pivotloc时枢轴位置 
		QSort(L,pivotloc+1,high);//对高子表递归排序 
	}
} 

void QuickSort(SqList &L){//对顺序表L作快速排序 
	QSort(L,1,L.length);
}

3、选择排序

简单选择排序

#include <iostream>
using namespace std;


void SelectSort(SqList &L){//对顺序表L作简单选择排序 
	for(i=1;i<L.length;++i){//选择第i小的记录，并交换到位 
		j=SelectMinKey(L,i);//在L.r[i..L.length]中选择key最小的记录 
		if(i!=j)  L.r[i]<-->L.r[j];//与第i个记录交换 
	}
}

树形选择排序（锦标赛排序）

堆排序

#include <iostream>
using namespace std;


void HeapSort(HeapType &H){//对顺序表H进行堆排序 
	for(i=H.length/2;i>0;--i)//把H.r[1..H.length]建成大顶堆 
	HeapAdjust(H,i,H.length);
	for(i=H.length;i>1;--i){
		H.r[1]<-->H.r[i];//将堆顶记录和当前未经排序子序列Hr[1..i]中 
		//最后一个记录相互交换 
		HeapAdjust(H,1,i-1);//将H.r[1..i-1]重新调整为大顶堆 
	}
}

4、归并排序

#include <iostream>
using namespace std;


void MSort(RcdType SR[],RcdType &TR1[],int s,int t){//将SR[s..t]归并排序为TR1[s..t] 
	if(s==t)
	TR1[s]=SR[s];
	else{
		m=(s+t)/2;//将SR[s..m]平分为SR[s..m] 和SR[m+1..t] 
		MSort(SR,TR2,s,m);//递归的将SR[s..m]归并为有序的TR2[s..m] 
		MSort(SR,TR2,m+1,t);//递归的将SR[m+1..t]归并为有序的TR2[m+1..t] 
		Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] 
		
	}
}

5、基数排序

链式基数排序

#define MAX_NUM_OF_KEY 8//关键字项数的最大值
#define RADIX 10//关键字基数，此时是十进制整数的基数
#define MAX_SPACE 10000
typedef struct{
KeysType keys[MAX_NUM_OF_KEY];//关键字
InFoType otheritems;//其他数据项
int next;
}SLCell;//静态链表的结点类型
typedef struct{
SLCell r[MAX_SPACE];//静态链表的可利用空间，r[0]为头结点
int keynum;//记录当前关键字个数
int recnum;//静态链表的当前长度
}SLList;//静态链表类型
typedef int ArrType[RADIX];指针数组类型

6、拓扑排序

拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。且该序列必须满足下面两个条件：

1.每个顶点出现且只出现一次。
2.若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。
 

#include"topological_sort.h"

Graph_DG::Graph_DG(int vexnum, int edge) {
    this->vexnum = vexnum;
    this->edge = edge;
    this->arc = new Vnode[this->vexnum];
    this->indegree = new int[this->vexnum];
    for (int i = 0; i < this->vexnum; i++) {
        this->indegree[i] = 0;
        this->arc[i].firstarc = NULL;
        this->arc[i].data = "v" + to_string(i + 1);
    }
}
//释放内存空间
Graph_DG::~Graph_DG() {
    ArcNode * p, *q;
    for (int i = 0; i < this->vexnum; i++) {
        if (this->arc[i].firstarc) {
            p = this->arc[i].firstarc;
            while (p) {
                q = p->next;
                delete p;
                p = q;
            }
        }
    }
    delete [] this->arc;
    delete [] this->indegree;
}
//判断我们每次输入的的边的信息是否合法
//顶点从1开始编号
bool Graph_DG::check_edge_value(int start, int end) {
    if (start<1 || end<1 || start>vexnum || end>vexnum) {
        return false;
    }
    return true;
}
void Graph_DG::createGraph() {
    int count = 0;
    int start, end;
    cout << "输入每条起点和终点的顶点编号（从1开始编号）" << endl;
    while (count != this->edge) {
        cin >> start;
        cin >> end;
        //检查边是否合法
        while (!this->check_edge_value(start, end)) {
            cout << "输入的顶点不合法，请重新输入" << endl;
            cin >> start;
            cin >> end;
        }
        //声明一个新的表结点
        ArcNode * temp = new ArcNode;
        temp->adjvex = end - 1;
        temp->next = NULL;
        //如果当前顶点的还没有边依附时，
        if (this->arc[start - 1].firstarc == NULL) {
            this->arc[start - 1].firstarc = temp;
        }
        else {
            ArcNode * now = this->arc[start - 1].firstarc;
            while(now->next) {
                now = now->next;
            }//找到该链表的最后一个结点
            now->next = temp;
        }
        ++count;
    }
}
void Graph_DG::print() {
    int count = 0;
    cout << "图的邻接矩阵为：" << endl;
    //遍历链表，输出链表的内容
    while (count != this->vexnum) {
        //输出链表的结点
        cout << this->arc[count].data<<" ";
        ArcNode * temp = this->arc[count].firstarc;
        while (temp) {
            cout<<"<"<< this->arc[count].data<<","<< this->arc[temp->adjvex].data<<"> ";
            temp = temp->next;
        }
        cout << "^" << endl;
        ++count;
    }
}

bool Graph_DG::topological_sort() {
    cout << "图的拓扑序列为：" << endl;
    //栈s用于保存栈为空的顶点下标
    stack<int> s;
    int i;
    ArcNode * temp;
    //计算每个顶点的入度，保存在indgree数组中
    for (i = 0; i != this->vexnum; i++) {
        temp = this->arc[i].firstarc;
        while (temp) {
            ++this->indegree[temp->adjvex];
            temp = temp->next;
        }

    }

    //把入度为0的顶点入栈
    for (i = 0; i != this->vexnum; i++) {
        if (!indegree[i]) {
            s.push(i); 
        }
    }
    //count用于计算输出的顶点个数
    int count=0;
    while (!s.empty()) {//如果栈为空，则结束循环
        i = s.top();
        s.pop();//保存栈顶元素，并且栈顶元素出栈
        cout << this->arc[i].data<<" ";//输出拓扑序列
        temp = this->arc[i].firstarc;
        while (temp) {
            if (!(--this->indegree[temp->adjvex])) {//如果入度减少到为0，则入栈
                s.push(temp->adjvex);
            }
            temp = temp->next;
        }
        ++count;
    }
    if (count == this->vexnum) {
        cout << endl;
        return true;
    } 
    cout << "此图有环，无拓扑序列" << endl;
    return false;//说明这个图有环
}
bool Graph_DG::topological_sort_by_dfs() {
    stack<string> result;
    int i;
    bool * visit = new bool[this->vexnum];
    //初始化我们的visit数组
    memset(visit, 0, this->vexnum);
    cout << "基于DFS的拓扑排序为：" << endl;
    //开始执行DFS算法
    for (i = 0; i < this->vexnum; i++) {
        if (!visit[i]) {
            dfs(i, visit, result);
        }
    }
    //输出拓扑序列，因为我们每次都是找到了出度为0的顶点加入栈中，
    //所以输出时其实就要逆序输出，这样就是每次都是输出入度为0的顶点
    for (i = 0; i < this->vexnum; i++) {
        cout << result.top() << " ";
        result.pop();
    }
    cout << endl;
    return true;
}
void Graph_DG::dfs(int n, bool * & visit, stack<string> & result) {

        visit[n] = true;
        ArcNode * temp = this->arc[n].firstarc;
        while (temp) {
            if (!visit[temp->adjvex]) {
                dfs(temp->adjvex, visit,result);
            }
            temp = temp->next;
        }
        //由于加入顶点到集合中的时机是在dfs方法即将退出之时，
        //而dfs方法本身是个递归方法，
        //仅仅要当前顶点还存在边指向其他不论什么顶点，
        //它就会递归调用dfs方法，而不会退出。
        //因此，退出dfs方法，意味着当前顶点没有指向其他顶点的边了
        //，即当前顶点是一条路径上的最后一个顶点。
        //换句话说其实就是此时该顶点出度为0了
        result.push(this->arc[n].data);

}

风铃奈
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
经典九大排序（1）——简单排序
刘斐浩的博客
07-23 7万+
本博客已弃用，当时存在一些小细节错误后期也不再修改了 欢迎来我的新博客 九大排序排序是数据结构体系中最重要的内容之一，这一块必须要非常熟练的掌握，应该做到可以立马写出每个排序的代码，有多种实现方法的必须多种都能很快写出来，当然对各个排序的性能的了解也是基础且重要的。我们先对排序这一块进行一个整体的把握。 这里先说明几个概念 内排序：在对待排序数据存放在内存中进行的排序过程。是...
排序之堆排序
suhanning的博客
05-26 185
堆排序基于完全二叉树的大小根堆结构进行排序，以升序为例，步骤如下： 对原始数据进行大根堆构建，即父节点大于两个子节点； 将根节点的值即最大值和最后的叶子节点交换，将最大值放到最末； 继续对剩下的数据进行大根堆构造，从上至下，由根节点开始，到倒数第二个节点位置，找到第二大数据，重复2步骤，直至每个数据都进行了处理。 code： void swap(int *a, int indexbefore, int indexafter) { int tmp; tmp = a[indexbefore]; a[
力扣算法题（一）
qq_60587956的博客
04-09 477
1.两数之和（简单） var twoSum = function(nums, target) { const map = new Map(); for(let i = 0;i < nums.length;i++){ const ret = target - nums[i]; if(map.has(ret)){//判断map中是否有结果 return [map.get(ret),i];//如果有，返回结果 }
常见的7种排序算法小结
datian1234的博客
05-09 1311
1. 冒泡排序：每次比较相邻两个元素，然后交换它们的位置，重复这个过程直到整个数组排序完成。 2. 选择排序：每次从未排序的部分选出最小（或最大）的元素，然后与未排序部分的第一个元素交换位置，如此反复直到整个数组排序完成。 3. 插入排序：从第二个元素开始，将每个元素插入到已排序的数组中的适当位置，直到整个数组排序完成。
八大排序算法——（万字图文详解）
Forward♞的博客
06-28 2172
本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析（算法逻辑、具体实现过程、时间复杂度、稳定性），并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。
排序|常见7种排序
Zero_H的博客
10-19 4073
常见的各种排序有哪些？ 直接插入排序 希尔排序 冒泡排序 选择排序 堆排序 快速排序 归并排序 以上七种排序都是我们在学习中经常会遇到的常见的排序 插入排序 什么是插入排序？ 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找...
排序-插入排序
Triangle23
07-05 1314
零、数据结构和算法系列目录 数据结构和算法系列目录(不断更新)： http://blog.csdn.net/adrastos/article/details/9093857 一、插入排序简介 插入排序是比较简单也比较直接的一种排序算法。对于少量元素待排序数据较为有效。插入排序就像安身高排队，有一个人指挥排队从第二个人开始，按身高把当前的人安插到之前排序好的队列的合适位置。插入排
排序_排序_
10-04
在Java中，`java.util.Arrays.sort()`提供了对基本类型数组和对象数组的排序支持，底层使用了混合排序算法，结合了快速排序、插入排序和归并排序的优点，对于小数组采用插入排序，中等大小的数组使用快速排序，大的...
排序查询
12-14
排序查询按单个字段排序按表达式 / 别名排序按函数排序按多个字段排序 排序查询：SELECT 查询列表 FROM 表 WHERE 筛选条件 ORDER BY 排序列表(ASC/DESC) AEC/DESC = 升序/降序，默认为升序 ORDER BY 支持单个字段、...
python十大排序算法
07-26
使用 python 实现十种最常见的排序算法：选择排序、冒泡排序、插入排序、归并排序、桶排序、计数排序、基数排序、（随机）快速排序、希尔排序和堆排序算法。 适用于数据结构与算法的学习过程中，也是面试过程中常被...
chapter9 排序1
08-03
【排序算法概述】 排序是计算机科学中的一种基本操作，它涉及对一组数据进行重新排列，使得数据按照特定的标准（通常是升序或降序）形成有序序列。在排序过程中，我们通常考虑两个关键因素：排序码（key），即用于...
姓名排序工具
07-12
姓名排序工具是一款专为行政事业单位设计的实用程序，旨在解决多个人名按特定规则排序的难题。在日常工作中，人员名单的整理与排列是一项频繁且重要的任务，手工操作不仅耗时，而且容易出现人为错误。这款小工具通过...
数据结构算法题
weixin_51426308的博客
01-01 143
数据结构大题1、有序顺序表的插入2、 两个有序的单链表合并3、 顺序表的删除4、单链表的删除5、顺序表上的查找6、折半查找7、直接插入排序8、求二叉树的叶子数9、求二叉树的深度10、折半插入排序 1、有序顺序表的插入 void InsertOrderList(SqList &a,ElemType x){ if(a.length==a.listsize) return 0; else{ i = a.length - 1; while(i>=0&&x<a.el
排序的基本概念（及常见的排序算法）
blue丶的博客
05-28 3744
排序的概念 排序 排序就是将一组杂乱无章的数据按照一定的规律（升序或降序）组织起来。 排序码 通常数据元素有多个属性域，其中有一个属性域可用来区分元素，作为排序依据，该域即为排序码。 按主排序码进行排序，排序的结果是唯一的。 按照次排序码进行排序，排序的结果不是唯一的。 排序算法稳定性 如果在元素序列中有两个元素R[i]和R[j]，他们的排序码K[i]==K[j]，且在排序之前，...
数据结构(c)——排序算法
Jali_li的博客
05-14 940
排序是将一个记录的任意序列，重新排列成一个按关键字有序的序列(按非递减或非递增)。 排序算法按排序过程中依据的不同原则可以大致分为五类：插入排序、交换排序、选择排序、归并排序、基数排序。 下面程序均使无序序列排序成非递减序列。 数据结构使用顺序表，并初始化8个元素 [49,38,65,97,76,13,27,49]， typedef struct Record{ int key;
算法（一）排序算法（桶排序、冒泡排序、快速排序）
努力向前的小蜗牛
04-07 6007
前言这些一个系列的文章，主要是自己学习算法和数据结构的一些笔记整理。从最简单开始，一步步深入，都是自己学习过程中的领悟。对于程序猿而言，算法和数据结构就像一门强大的内功，练的过程中，会比较难，相对于武学招式，需要更多的理解能力和悟性，但是一旦练成，那就能变身强大的武林高手，纵横武林，不再是梦想。本系列武林秘籍主要来自于个人学习《啊哈！算法》《算法导论》这两个算法的入门级书籍。所以，高手就不喜勿喷啦...
哈希插入排序
m0_53438035的博客
06-23 131
#include <stdio.h> #include <iostream> #include <stdlib.h> using namespace std; #define MAXSIZE 20 #define OK 0 #define ERROR 1 typedef char InforType; typedef int KeyType; typedef int Status; typedef struct { KeyType key; Info
二分查找
想飞的小菜鸡
08-02 239
升序序列的二分查找： int bsearchWithoutRecursion(int array[], int low, int high, int target) { while(low <= high) { int mid = (low + high)/2; if (array[mid] > target) high =
工作述职报告PPT模板 (25)
最新发布
07-12
【作品名称】：工作述职报告PPT模板 (25) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风铃奈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值