大话数据结构 ：排序

最新推荐文章于 2023-09-19 19:05:03 发布
最新推荐文章于 2023-09-19 19:05:03 发布
阅读量129 收藏
点赞数
分类专栏： 数据结构与算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42376458/article/details/113359873
版权

排序算法概要

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

冒泡排序和快速排序

快速排序是冒泡排序的升级，冒泡排序的算法性能较低时间性能O(n2),而快速排序平均可以达到o(nlogn)。冒泡排序就是两两比较，直到所有的位置都是有序排列的数据。而快速排序就是在两两比较的过程中增加了一个将比当前数据小的都放在一段，比当前数据大的都放在另一端的思想，提高了算法效率。

代码

#include <stdio.h>    
#include <string.h>
#include <ctype.h>      
#include <stdlib.h>   
#include <io.h>  
#include <math.h>  
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */

typedef int Status;

#define MAXIZE 10000 /* 用于要排序数组个数最大值，可根据需要修改 */
typedef struct
{
	int r[MAXIZE + 1];
	int length;
}SqList;

/* 交换L中数组r的下标为i和j的值 */
void swap(SqList* L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}

void print(SqList L)
{
	int i;
	for (int i = 1; i < L.length; i++)
		printf("%d,", L.r[i]);
	printf("\n");
}

/* 对顺序表L作交换排序（冒泡排序初级版） */
void BubbleSort0(SqList* L)
{
	int i;
	int j;
	for (int i = 1; i < L->length; i++)
	{
		for (int j = i + 1; j <= L->length; j++)
		{
			if (L->r[i] > L->r[j])
			{
				swap(L, i, j);/* 交换L->r[i]与L->r[j]的值 */
			}
		}
	}
}

/* 对顺序表L作冒泡排序 */
void BubbleSort(SqList* L)
{
	int i;
	int j;
	for (int i = 1; i < L->length; i++)
	{
		for (int j = L->length - 1; j >= i; j--)
		{
			if (L->r[j] > L->r[j + 1]) //冒泡排序经典方法
			{
				swap(L, j, j + 1);
			}
		}
	}
}

/* 对顺序表L作改进冒泡算法*/
void BubbleSort2(SqList* L)
{
	int i;
	int j;
	Status flag = TRUE;
	for (int i = 1; i < L->length && flag; i++)
	{
		flag = FALSE;
		for (int j = (*L).length - 1; j >= i; j--)
		{
			if (L->r[j] > L->r[j + 1])
			{
				swap(L, j, j+1);
				flag = TRUE;
			}
		}
	}
}

/**************** 快速排序******************************** */
/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */

int Partition(SqList* L, int low, int high)
{
	int pivotkey;
	pivotkey = L->r[low]; /* 令第一个元素为枢轴*/
	while (low < high)/*  从表的两端交替地向中间扫描 */
	{
		while ((low < high) && (L->r[high] >= pivotkey))
		{
			high--;
		}
		swap(L, low, high);/* 将比枢轴记录小的记录交换到低端 */
		while (low < high && L->r[low] <= pivotkey)
		{
			low++;
		}
		swap(L, low, high);
	}
	return low; /* 返回枢轴所在位置 */
}

/* 对顺序表中的子序列作快速排序*/
void QSort(SqList* L, int low, int high)
{
	int pivot;
	if(low < high)
	{
		pivot = Partition(L, low, high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
		QSort(L, low, pivot - 1);		/*  对低子表递归排序 */
		QSort(L, pivot + 1, high);		/*  对高子表递归排序 */
	}
}
/* 对顺序表L作快速排序 */
void QuickSort(SqList* L)
{
	QSort(L, 1, L->length);
}

/* 改进后快速排序******************************** */
/* 快速排序优化算法 */
int Partition1(SqList* L, int low, int high)
{
	int pivotkey;

	int m = low + (high - low) / 2; //三数确定P值所在位置
	if (L->r[low] > L->r[high])
		swap(L, low, high);	/* 交换左端与右端数据，保证左端较小 */
	if (L->r[m] > L->r[high])
		swap(L, high, m);		/* 交换中间与右端数据，保证中间较小 */
	if (L->r[m] > L->r[low])
		swap(L, m, low);		/* 交换中间与左端数据，保证左端较小 */

	pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	L->r[0] = pivotkey;  /* 将枢轴关键字备份到L->r[0] */

	while (low < high) /*  从表的两端交替地向中间扫描 */
	{
		while (low < high && L->r[high] >= pivotkey)
			high--;
		L->r[low] = L->r[high];
		while (low < high && L->r[low] <= pivotkey)
			low++;
		L->r[high] = L->r[low];
	}

	L->r[low] = L->r[0];
	return low; /* 返回枢轴所在位置 */

}

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


void QSort1(SqList* L, int low, int high)
{
	int pivot;
	if ((high - low) > MAX_LENGTH_INSERT_SORT)
	{
		while (low < high)
		{
			pivot = Partition1(L, low, high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
			QSort1(L, low, pivot - 1);		/*  对低子表递归排序 */
			/* QSort(L,pivot+1,high);		/*  对高子表递归排序 */
			low = pivot + 1;	/* 尾递归 */
		}
	}
	else
		InsertSort(L);
}

/* 对顺序表L作快速排序 */
void QuickSort1(SqList* L)
{
	QSort1(L, 1, L->length);
}
#define N 9
int main()
{
	int i;

	/* int d[N]={9,1,5,8,3,7,4,6,2}; */
	int d[N] = { 50,10,90,30,70,40,80,60,20 };
	/* int d[N]={9,8,7,6,5,4,3,2,1}; */

	SqList l0, l1, l2, l3, l4, l5, l6, l7, l8, l9, l10;

	for (i = 0; i < N; i++)
		l0.r[i + 1] = d[i];
	l0.length = N;
	l1 = l2 = l3 = l4 = l5 = l6 = l7 = l8 = l9 = l10 = l0;
	printf("排序前:\n");
	print(l0);


	printf("初级冒泡排序:\n");
	BubbleSort0(&l0);
	print(l0);

	printf("冒泡排序:\n");
	BubbleSort(&l1);
	print(l1);

	printf("改进冒泡排序:\n");
	BubbleSort2(&l2);
	print(l2);

	printf("快速排序:\n");
	QuickSort(&l9);
	print(l9);
}

直接插入和希尔排序

直接插入算法简单，就是从第2个元素开始，将其与首个元素比较，如果小于首个元素则将其插入到第一位，如果大于则比较之后的元素，直到达到自身。希尔排序是其改进，其采用首先保证一定间隔的元素是有序排列的，比如任意间隔为3的元素序列都是有序的，这一步采取的方法同直接插入，然后逐步将间隔缩小直到1，这是所有序列都有序。这个算法适合大部分数据是有序的，主要优点在于数据的移动较小。

代码

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

/* 对顺序表L作希尔排序 */
void ShellSort(SqList* L)
{
	int i;
	int j;
	int k = 1;
	int increment = L->length;
	do
	{
		increment = increment / 3 + 1;/* 增量序列 */
		for (int i = increment + 1; i <= L->length; i++)
		{
			if (L->r[i] < L->r[i - increment])/*  需将L->r[i]插入有序增量子表 */
			{
				L->r[0] = L->r[i]; /*  暂存在L->r[0] */
				for (j = i - increment; j > 0 && L->r[0] < L->r[j]; j -= increment)
					L->r[j + increment] = L->r[j]; /*  记录后移，查找插入位置 */
				L->r[j + increment] = L->r[0]; /*  插入 */
			}
		}
		printf("	第%d趟排序结果: ", ++k);
		print(*L);
	} while (increment > 1);
}

简单选择排序和堆排序

简单选择排序就是首先找到最小的，然后找到第2小的，依次排序。堆排序是把数据按照完全二叉树结构组织起来，构成一个大顶堆或者小顶堆。然后每次从堆顶取出一个数，接着将最后一位数移到堆顶，重新堆数据按照大顶堆排序，此时操作实际比较简单。
具体看代码，主要就是大顶堆初始排序要从底层开始，之后再排序就容易了。

代码

/* 对顺序表L作简单选择排序 */
void SelectSort(SqList* L)
{
	int i, j, min;
	for (i = 1; i < L->length; i++)
	{
		min = i;						/* 将当前下标定义为最小值下标 */
		for (j = i + 1; j <= L->length; j++)/* 循环之后的数据 */
		{
			if (L->r[min] > L->r[j])	/* 如果有小于当前最小值的关键字 */
				min = j;				/* 将此关键字的下标赋值给min */
		}
		if (i != min)						/* 若min不等于i，说明找到最小值，交换 */
			swap(L, i, min);				/* 交换L->r[i]与L->r[min]的值 */
	}
}

/* 堆排序********************************** */
/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义， */
/* 本函数调整L->r[s]的关键字,使L->r[s..m]成为一个大顶堆 */
void HeapAdjust(SqList* L, int s, int m)
{
	int temp;
	temp = L->r[s];
	for (int j = 2 * s; j <= m; j *= 2)
	{
		if (j < m && L->r[j] < L->r[j + 1])
		{
			++j;/* j为关键字中较大的记录的下标 */
		}
		if (temp >= L->r[j])
			break;
		L->r[s] = L->r[j];
		s = j;
	}
	L->r[s] = temp;/* 插入 */
}

/*  对顺序表L进行堆排序 */
void HeapSort(SqList *L)
{
	for (int i = L->length / 2; i > 0; i--)//注意这里的i值表示从底层开始大顶堆
	{
		HeapAdjust(L, i, L->length);
	}
	for (int i = L->length; i > 1; i--)
	{
		swap(L, 1, i);
		HeapAdjust(L, 1, i - 1); /*  将L->r[1..i-1]重新调整为大根堆 */
	}
}

归并排序

归并排序可以说是排序算法中效率，稳定性方面最好的，实现也比较简单。主要就是将数据分片，片内排序然后合并，对于归并排序应该使用它的分递归方式，占用内存少。

代码

/**************** 归并排序********************************** */
/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
void Merge(int SR[], int TR[], int i, int m, int n)
{
	int k,j;
	for (j = m + 1, k = i; i <= m && j <= n; k++)/* 将SR中记录由小到大地并入TR */
	{
		if (SR[i] < SR[j])
			TR[k] = SR[i++]; //注意这里的i++
		else
			TR[k] = SR[j++];
	}
	if (i <= m)
	{
		for (int h = 0; h <= m - i; h++)
			TR[k + h] = SR[i + h]; /* 将剩余的SR[i..m]复制到TR */
	}
	if (j <= n)
	{
		for (int h = 0; h <= h - j; h++)
			TR[h + k] = SR[j + h]; /* 将剩余的SR[j..n]复制到TR */
	}
}

/* 递归法 */
/* 将SR[s..t]归并排序为TR1[s..t] */
void MSort(int SR[], int TR1[], int s, int t)
{
	int m;
	int TR2[MAXIZE + 1];
	if (s == t)
		TR1[s] = SR[s];
	else
	{
		m = (s + t) / 2;				/* 将SR[s..t]平分为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] */
	}
}

/* 对顺序表L作归并排序 */
void MergeSort(SqList* L)
{
	MSort(L->r, L->r, 1, L->length);
}
/* 非递归法 */
/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
void MergePass(int SR[], int TR[], int s, int n)
{
	int i = 1;
	int j;
	while (i <= n - 2 * s + 1)
	{/* 两两归并 */
		Merge(SR, TR, i, i + s - 1, i + 2 * s - 1);
		i = i + 2 * s;
	}
	if (i < n - s + 1) /* 归并最后两个序列 */
		Merge(SR, TR, i, i + s - 1, n);
	else /* 若最后只剩下单个子序列,已经排好序 */
		for (j = i; j <= n; j++)
			TR[j] = SR[j];
}
/* 对顺序表L作归并非递归排序 */
void MergeSort2(SqList* L)
{
	int* TR = (int*)malloc(L->length * sizeof(int));/* 申请额外空间 */
	int k = 1;
	while (k < L->length)
	{
		MergePass(L->r, TR, k, L->length);
		k = 2 * k;/* 子序列长度加倍 */
		MergePass(TR, L->r, k, L->length);
		k = 2 * k;/* 子序列长度加倍 */
	}
}
安东time
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
稳定性定义： 各算法稳定性 一、直接插入排序   二、折半插入排序  六、简单选择排序  三、希尔排序   四、冒泡排序  五、快速排序  七、堆排序   八、归并排序 
ZJQ的博客
08-28 634
稳定性定义：排序前后两个相等的数相对位置不变，则算法稳定。 稳定性得好处：从一个键上排序，然后再从另一个键上排序， 举个例子： 在数据库操作中，如下简单表格： 2(1) 4 3 8 2(2) 5 1 2 4 9 上表格第一个列，如果需要第一列排序，且使用稳定排序算法可得到 1 22(1) 4 2(2) 5 3...
数据结构：顺序栈
weixin_52485836的博客
03-24 1425
1.头文件(seqstack.h) #pragma once //不定长顺序栈:当栈满后能够扩容.利用顺序表保存数据 #define INITSIZE 10 typedef int ElemType; typedef struct { ElemType* base;//指向存放数据的指针 ElemType* top;//栈顶指针,指向当前可以存放数据的地址 int stacksize;//栈总容量 }SqStack,*PSqStack;//sizeof(SqStack)==12; //栈的初始.
[ 数据结构 -- 手撕排序算法第三篇 ] 希尔排序
CSDN博客
04-18 4488
手撕排序算法系列之：希尔排序。 从本篇文章开始，我会介绍并分析常见的几种排序，大致包括插入排序，冒泡排序，希尔排序，选择排序，堆排序，快速排序，归并排序等。 大家可以点击此链接阅读其他排序算法：排序算法_大合集（data-structure_Sort） 本篇主要来手撕希尔排序~~ 目录 1.常见的排序算法 1.1 插入排序基本思想 2.希尔排序 2.1希尔排序（缩小增量排序） 2.1.1预排序阶段 2.1.2插入排序阶段 2.2单趟希尔排序 2.2.1思路分析 3.希尔排...
数据结构与算法之希尔排序
努力让自己发光，对的人才能迎着光而来
09-12 2万+
希尔排序概念 代码实现 时间复杂度
【考研】数据结构考点——希尔排序
qq_34438969的博客
08-08 2916
本文内容源于对《数据结构（C语言版）》（第2版）、王道讲解学习所得心得、笔记整理和总结。插入排序的三种方法：直接插入排序、折半插入排序和希尔排序。直接插入排序可基于顺序表或链表操作，但后两种插入方法只能基于顺序存储结构。本文内容主要针对希尔排序。分析算法，并结合例子，以图文形式讲解希尔排序的过程。【考研】数据结构考点——直接插入排序_住在阳光的心里的博客-CSDN博客【考研复习：数据结构】查找（不含代码篇）_住在阳光的心里的博客-CSDN博客目录前言一、基本概念二、算法步骤三、算法描述。......
大话数据结构--排序算法
Professional
08-21 309
前言 这段时间阅读大话数据结构这本书的排序算法章节，对其中提到的额几个算法，交换排序、冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序等算法进行了巩固，也把该过程中的一些理解，介绍给大家。 一、冒泡排序 1.1、 最简单的冒泡排序算法  --交换排序   交换排序算法，就是对集合进行循环，依次从第一个位置开始，与后面的所有数比较，如果后者小于前者，则交换两者的位置，...
数据结构：堆排序
阿LuLu的博客
12-30 319
采用堆排序堆序对序列R={8，9，2，4，12，52，3}进行排序，并输出排序后的结果 #include <stdio.h> #include<stdlib.h> #define MAXSIZE 50 typedef int KeyType; typedef struct { KeyType key; }DataType; typedef struct { DataType data[MAXSIZE]; int length; }SqList; void AdjustHe
大话设计结构代码
11-21
《大话设计结构代码》这本书深入浅出地探讨了数据结构这一重要计算机科学主题，它在编程和软件工程中占据着核心地位。数据结构是组织和管理数据的方式，有效地使用数据结构可以极大地提高程序的效率和可维护性。以下...
数据结构课件完整版
11-04
本课件涵盖了数据结构的多个重要主题，包括线性表、栈和队列、串、数和二叉树、图、查找以及内部排序。 线性表是最基本的数据结构之一，它是一组按顺序排列的元素集合。每个元素都有一个唯一的索引，可以实现快速...
leetcode中国-algo:数据结构和算法
06-29
《图解算法》、《大话数据结构》、《啊哈算法》 2：面试 《编程之美》、《剑指offer》、《编程珠玑》 3：编程语言 《数据结构与算法分析：Java语言描述》 4：闲暇阅读 《算法帝国》、《数学之美》、《算法之美》 5：...
考研数据结构和leetcode-CS-Xmind-Note:cs基础学习
06-30
数据结构和算法--《大话数据结构》、《王道考研》、《算法》、各大博客论坛（到时候会备注地址） 计算机网络 --《计算机网络-自顶向下方法》、《王道考研》、《TCP/IP协议：卷一》 计算机组成原理-- 目前没有目标,有...
算法与数据结构c与c++描述
03-12
《算法与数据结构C与C++描述》是针对计算机科学中的核心概念——算法和数据结构进行深入探讨的教材。在编程领域，理解并熟练运用这些概念对于提升代码效率和优化程序设计至关重要。本文将详细阐述其中的关键知识点。...
大话数据结构(一)--排序
努力才会有幸福
06-17 254
文章目录1. 排序--快速排序算法（Quicksort）1.1 定义1.2. 基本思想1.3. 步骤1.4. C语言实现代码分析：1.2 那么我们该如何选取枢纽元呢？2 归并排序2.1 基本思想2.2 合并相邻有序子序列2.3 C语言代码实现3. 堆排序3.1 堆介绍3.2. 算法步骤3.3. 算法解析3.3.1 代码段一3.3.2 代码段二4. 冒泡排序4.1 介绍4.2 算法步骤4.3 C语言实现5. 选择排序5.1 选择排序介绍![在这里插入图片描述](https://img-blog.csdnimg
数据结构--希尔排序
最新发布
m0_61402375的博客
09-19 883
目录希尔排序的定义 给一个序列进行希尔排序 希尔排序的算法实现 算法性能分析1.时间复杂度2.稳定性 3.适用性 知识点回顾 第一趟d可以是元素个数/2相距为4的子表 对子表进行直接插入排序（由小到大） 得到结果是 第二趟相距为2的元素为一组 相距为2的子表 对子表进行直接插入排序（由小到大） 第二趟得到结果是 第三趟d=1，相距为1的元素为子表，正好就是所有的元素，整个表已经呈现出“基本有序”，对整体在进行一次“直接插入排序” 第三趟的子表 第三趟子表排序后的结果 不稳定仅适合于顺序表，不适用
数据结构--排序之希尔排序
qq_52363432的博客
02-03 3214
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
希尔排序详解(Shell Sort)
Wzill
05-29 1万+
直接插入排序是由两层嵌套循环组成的。外层循环标识并决定待比较的数值。内层循环为待比较数值确定其最终位置。直接插入排序将待比较的数值与它的前一个数值进行比较，所以外层循环是从第二个数值开始的。当前一数值比待比较数值大的情况下继续循环比较，直到找到比待比较数值小的并将待比较数值置入其后一位置，结束该次循环。
排序算法 —— 希尔排序（图文超详细）
热门推荐
超烦豆先森
10-29 6万+
java 实现希尔排序
数据结构基础 希尔排序 之 算法复杂度浅析
稚枭天卓
09-06 1万+
希尔排序（Shell Sort）又叫做缩小增量排序（diminishing increment sort），是一种很优秀的排序法，算法本身不难理解，也很容易实现，而且它的速度很快。 Shell排序通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数。 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序
C++ 线程同步 异步 阻塞 非阻塞概念介绍 及 C++ 实践
weixin_42376458的博客
04-28 5635
文章目录基础概念介绍c++ 11 中多线程以及异步处理 基础概念介绍 基础概念介绍参考博文：https://www.cnblogs.com/mhq-martin/p/9035640.html 我们经常看到线程同步 进程同步 有时候可能还会听到线程异步之类的说法，这些概念容易让人混淆，所以首先我们把这些概念拆开来一个一个看，然后他们组合起来应该就容易理解了 同步 就是按照顺序一件一件的做。专业一点就是如果调用了一个函数，就需要等这个函数运行结束，才能执行后面的代码。 异步 就是很多事情一起做，顺序不能确定。专
大话数据结构拓扑排序
09-19
拓扑排序是一种对有向图进行排序的算法，通过确定每个顶点的先后顺序，使得图中的所有边都是从前面的顶点指向后面的顶点。这种排序可以用来解决有依赖关系的任务调度问题，也可以用来检测有向图中是否存在环路。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值