C语言数据结构8大排序

最新推荐文章于 2022-10-04 19:20:43 发布
最新推荐文章于 2022-10-04 19:20:43 发布
阅读量169 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52485836/article/details/123223268
版权

排序难点:算法多,容易混淆
1.直接(简单)插入排序:扑克牌

      特点:越有序越快,完全有序O(n),非常重要,这个是希尔排序的基础

 2.希尔(shell)排序
        分组后利用直接插入排序
3.冒泡排序：
        两两比较，大的往后走

* 4.快速排序：
       算法： 1.从后往前找比基准小的数字，找到往前挪
                   2.从前往后找比基准大的数字，找到往后挪
                   3.重复1.2
       缺点：1.越有序，越慢                
                  2.空间复杂度大，不稳定

  5.选择排序：
        每次都从待排序中选出最小的一个和待排序的第一个进行数据交换

  6.堆排序：
        算法：1.从最后一颗子树开始，从后往前调整
                   2.每次调整，从上往下调整
                   3.调整为大根堆
                  大根堆：在二叉树中所有的父都大于子
                  小根堆：在二叉树中所有的父都小于子
                  度：就是节点的分支
                  叶子节点：度为0
                  兄弟：同一个双亲的孩子之前被称为兄弟
                  深度：就是树的层高

  7.归并排序
            1.将两段有序的数据合并成为一段有序的数据，直到所有的数据都有序
            2.把两段有序的归并成为一段有序的，也称为2路有序
  8.基数排序（桶排序）
            局限性：不能处理负数
  9.第‘9’个排序
           链表排序
           1.单链表存放数据我们用什么排序？（冒泡，选择）
           2.双向链表存放数据我们用什么排序？（快排（STL自带的list为双向链表））
 

#include <stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"listqueue.h"
//直接(简单)插入排序
//void InsertSort(int* arr, int len)//O(n^2),最好的情况,O(1),稳定
//{
//	int tmp;//存放当前处理的数字
//	int j;
//	for (int i = 1; i < len; i++)//从第二个数字开始
//	{//1 2 3 4 5
//		tmp = arr[i];
//		for (j = i - 1; j >= 0; j--)//从后往前找第一个比tmp小的数字
//		{
//			if (arr[j] > tmp)//arr[j]需要后移
//				arr[j + 1] = arr[j];
//			else
//				break;
//		}
//		arr[j + 1] = tmp;
//	}
//}
 
//gap:分组数
//void Shell(int* arr, int len, int gap)
//{
//	int tmp;//保存当前需要处理的值
//	int j;
//	for (int i = gap; i < len; i++)//从"第二个"元素开始
//	{
//		tmp = arr[i];
//		for (j = i - gap; j >= 0; j -= gap)
//		{
//			if (arr[j] > tmp)
//				arr[j + gap] = arr[j];
//			else
//				break;
//		}
//		arr[j + gap] = tmp;
//	}
//}
 
//希尔排序
//void ShellSort(int* arr, int len)//时间复杂度：O(n^1.3~n^1.5),空间复杂度O(1),不稳定
//{
//	int d[] = { 5,3,1 };//分组组数,注意最后一定是1.缩小增量
//	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++)
//	{
//		Shell(arr, len, d[i]);
//	}
//}
 
 
/*
void InsertSort(int* arr, int len)//O(n^2),完全有序O(n^2)这个程序写的有问题
{
	int tmp;
	int i;
	int j;
	for (i = 1; i < len; i++)//从第二个数字开始处理
	{
		tmp = arr[i];//需要处理的值
		for (j = 0; j < i; j++)//找合适的位置,太慢
		{
			if (arr[j] > tmp)
				break;
		}//1 2 3 4 5
		//把后面的数据往后移动
		for (int k = i - 1; k >= j; k--)
		{
			arr[k + 1] = arr[k];
		}
		//插入新数据
		arr[j] = tmp;
	}
}
*/
 
 
//希尔排序（时间复杂度：O(n^1.3~n^1.5),空间复杂度O(1),不稳定）
//void Shell(int* arr, int len, int gap)
//{
//	int tmp;int j;
//	for (int i = gap; i < len; i ++)
//	{
//		tmp = arr[i];
//		for ( j= i - gap; j >= 0; j -= gap)
//		{
//			if (arr[j] > tmp)
//			{
//				arr[j+gap] = arr[j];
//			}
//			else
//				break;
//		}
//		arr[j+gap] = tmp;
//	}
//}
//void ShellSort(int* arr, int len)
//{
//	int d[] = { 5,3,1 };
//	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++)
//	{
//		Shell(arr, len, i);
//	}
//}
 
 
//冒泡排序( O(n^2),O(1),稳定)
//void Bubbler(int* arr, int len)
//{
//	int temp;
//	for (int i= 0; i < len-1; i++)
//	{
//		for (int j = 0; j + 1 < len - i; j++)
//		{
//			if (arr[j] > arr[j+1])
//			{
//				temp = arr[j];
//				arr[j] = arr[j+1];
//				arr[j+1] = temp;
//			}
//		}
//	}
//}
 
 
//快速排序,O(nlogn),O(logn),不稳定
//int Partition(int* arr, int low, int high)//一次划分O(n),O(1)
//{
//	int tmp = arr[low];//基准
//	while (low<high)
//	{
//		while (low<high && arr[high]>tmp)
//		{
//			high--;
//		}
//		if(low<high)
//		{
//			arr[low] = arr[high];
//		}
//		while (low<high && arr[low]<=tmp)
//		{
//			low++;
//		}
//		if (low < high)
//		{
//			arr[high] = arr[low];
//		}
//	}
//	arr[low] = tmp;
//	return low;
//}
//
//void Quick(int* arr,int low,int high ) {
//	int par = Partition(arr, low, high);
//		if (low < par - 1)
//		{
//			Quick(arr, low, par - 1);
//		}
//		if (par + 1 < high)
//		{
//			Quick(arr, par + 1, high);
//		}
//}
//void QuickSort(int* arr, int len)
//{
//	Quick(arr, 0, len - 1);//加了一个马甲，目的为增加一个参数，解决参数不一致问题
//}
 
 
 
//void QuickSort(int* arr, int len)//不能直接递归，所以舍去
//{
//	int par=partition(arr,0,len-1)
//		if (0 < par - 1)
//		{
//			QuickSort(arr,len)
//		}
//}
 
 
//选择排序 （O(n^2),O(1),不稳定）
//void SelectSort(int* arr, int len)
//{
//	int minlndex;//最小值的下标
//	int tmp;
//	for (int i = 0; i < len - 1; i++)
//	{
//		minlndex = i;
//		for (int j = i + 1; j < len; j++)
//		{
//			if (arr[minlndex] > arr[j])
//			{
//				minlndex = j;
//			}
//		}
//		//最小值和待排序的第一个值交换
//		if (minlndex != i)
//		{
//			tmp = arr[minlndex];
//			arr[minlndex] = arr[i];
//			arr[i] = tmp;
//		}
//
//	}
//}
 
 
//堆排序
//父-->子：i-->2*i+1,2*i+2
//子-->父:i-->(i-1)/2
//void HeapAdjust(int* arr, int start, int end)
//{
//	int tmp = arr[start];
//	for (int i = 2 * start + 1; i <= end; i = 2*i+1)
//	{
//		if (i < end && arr[i] < arr[i + 1])//有右孩子，并且左孩子的值小于右孩子
//		{
//			i++;
//		}//i一定是左右孩子的最大值
//		if (arr[i] > tmp)
//	{
//		arr[start] = arr[i];
//		start = i;
//	}
//		else
//		{
//			break;
//		}
//	}
//	arr[start] = tmp;
//}
//
//void HeapSort(int* arr, int len)
//{
//	//第一次建立大根堆，从后往前，多次调整
//	int i;
//	for (i = (len - 1 - 1) / 2; i >= 0; i--)
//	{
//		HeapAdjust(arr, i, len - 1);
//	}
//	//每次将根和待排序的最后一个做交换，然后再做调整
//	int tmp;
//	for (i = 0; i < len; i++)
//	{
//		tmp = arr[0];
//		arr[0] = arr[len - 1 - i];
//		arr[len - 1 - i] = tmp;
//
//		HeapAdjust(arr, 0, len - 1 - i-1);
//	}
//
//}
 
 
 
//归并有序O(nlogn),O(n),稳定
// 一次归并 O（n）
//void Merge(int* arr, int len, int gap)
//{
//	int low1 = 0;//第一段起始下标，
//	int high1 = low1 + gap-1;//第一段归并段的结束下标
//	int low2 = high1 + 1;//第二个归并段的起始下标
//	int high2 = low2 + gap-1<len-1?low2+gap-1:len-1;//第二个归并段的结束下标
//	//brr,存放数据的数组
//	int* brr = (int*)malloc(len * sizeof(int));//存放归并好的数据
//	int i = 0;//brr的下标
//	assert(brr != NULL);
//	//有两个归并段
//	while (low2 < len)
//	{
//		//两个归并段都有数据
//		while (low1<=high1&&low2<=high2)
//		{
//			if (arr[low1] <= arr[low2])
//			{
//				brr[i++] = arr[low1++];
//			}
//			else {
//				brr[i++] = arr[low2++];
//			}
//		}
//		//一个归并段的数据已经完成了，另外一个还有数据
//		while (low1<=high1)
//		{
//			brr[i++] = arr[low1++];
//		}
//		while (low2<=high2)
//		{
//			brr[i++] = arr[low2++];
//		}
//		//四个变量往后走，下两个归并段
//		low1 = high2 + 1;
//		high1 = low1 + gap - 1;
//		low2 = high1 + 1;
//		high2 = low2 + gap < len ? low2 + gap - 1 : len - 1;
//	}
//		//2.只有一个归并段
//		while (low1<len)//low1存在
//		{
//			brr[i++] = arr[low1++];
//		}
//		for (i = 0; i < len; i++)//将归并好的数据拷贝到arr中
//		{
//			arr[i] = brr[i];
//		}
//		free(brr);//不要忘记
//}
//void MergeSort(int*arr,int len)  //这块的时间复杂度是O(logn),
//{
//	for (int i = 1; i < len; i*=2)
//	{
//		Merge(arr, len, i);
//	}
//}
 
//基数排序（桶排序）  适用于n很大，d较小的序列  (O(d*n)(d指的是进几次出几次)，O(n),稳定)
//获取十进制整数右树第figur位的数字
//static int  GetNum(int n,int figur)
//{
//	for (int i = 0; i < figur; i++)
//	{
//		n /= 10;
//
//	}
//	return n % 10;
//}
//static int  GetFigur(int* arr, int len)
//{
//	int max = arr[0];
//	for (int i = 1; i < len; i++)
//	{
//		if (max < arr[i])
//		{
//			max = arr[i];
//		}		
//	}
//	
//	int count = 0;
//	while (max != 0)
//	{
//		count++;
//		max /= 10;
//	}
//	return count;
//}
//void RadixSort(int* arr, int len)
//{
//	//需要10个链式队列，存放进队的数字
//	LinkQueue queArr[10];//定义了10个队头
//	for (int i = 0; i < 10; i++)
//	{
//		InitQueue(&queArr[i]);//初始化
//	}
//	//得到最大数字的位数，确定进队和出队的次数
//	int count = GetFigur(arr, len);
//	int index;//队列的下标
//	for (int i = 0; i < count; i++)//1.趟数2.处理每个数字从右往左的第i个数字
//	{
//		for (int j = 0; j < len; j++)//遍历数组并进队
//		{
//			index = GetNum(arr[j], i);//index保存arr[j]应该进入的队的队列下标
//			Push(&queArr[index],arr[j]);//将数字存放在对应的队列
//		}
//		//出队
//		int j = 0;
//		for(int k = 0; k < 10; k++)
//		{
//			while (!IsEmpty(&queArr[k]))
//			{
//				DeQueue(&queArr[k], &arr[j++]);
//			}
//		}
//		//销毁
//		for (int i = 0; i < 10; i++)
//		{
//			Destroy(&queArr[i]);
//		}
//	}
//}
 
 
void Show(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 4,6,8,9,2,34,56,7,12,66,99,36,87 };
	//InsertSort(arr,sizeof(arr)/sizeof(arr[0]));
	//ShellSort(arr, sizeof(arr) / sizeof(arr[0]));
	//Bubbler(arr, sizeof(arr) / sizeof(arr[0]));
	//QuickSort(arr, sizeof(arr) / sizeof(arr[0]));
	//SelectSort(arr, sizeof(arr) / sizeof(arr[0]));
	//HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	//MergeSort(arr, sizeof(arr) / sizeof(arr[0]));
	//RadixSort(arr, sizeof(arr) / sizeof(arr[0]));
	Show(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

1.对列头文件名命为"listqueue.h"

//这是队列的头文件
#pragma once
typedef int ElemType;
typedef struct QNode
{
	ElemType data;
	struct QNode* next;
 }QNode ,*QueuePtr;
 
typedef struct
{
	QNode* front;//队头指针
	QNode* rear;//队尾指针
}LinkQueue;//头结点的定义
 
//队列初始化
void InitQueue(LinkQueue* pq);
 
//入队
bool Push(LinkQueue* pq, ElemType val);
 
//判空
bool IsEmpty(LinkQueue* pq);
 
//获取队头元素,但不删除
bool GetHead(LinkQueue* pq, ElemType* rtval);
 
//出队,获取队头元素,且删除
bool DeQueue(LinkQueue* ps, ElemType* rtval);
 
//销毁
void Destroy(LinkQueue* ps);

2.队列函数实现名命为listqueue.cpp

//桶排序需要用到队列
//这是队列的函数实现
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"listqueue.h"
//队列初始化
void InitQueue(LinkQueue* pq)
{
	assert(pq != NULL);
	if (pq == NULL)
		return;
	pq->front = NULL;
	pq->rear=NULL;
 
}
 
//入队
bool Push(LinkQueue* pq, ElemType val)
{
	QNode* p = (QNode*)malloc(sizeof(QNode));
 
	assert(p != NULL);
	if (p == NULL)
		return false;
	p->data = val;
	p->next = NULL;
 
	if (!IsEmpty(pq))
	{
		pq->rear->next = p;
		pq->rear = p;
 
	}
		
	else
	{
		pq->rear = p;
		pq->front = p;
	}
	return true;
 
		
}
 
//判空
bool IsEmpty(LinkQueue* pq)
{
	return pq->front == NULL;//队头都没有元素
}
 
//获取队头元素,但不删除
bool GetHead(LinkQueue* pq, ElemType* rtval)
{
	assert(pq != NULL);
	if (pq == NULL)
		return false;
	*rtval = pq->front->data;
	return true;
}
 
//出队,获取队头元素,且删除
bool DeQueue(LinkQueue* pq, ElemType* rtval)
 
{
	assert(pq != NULL);
	if (pq == NULL)
		return false;
	*rtval = pq->front->data;
	QNode* p = (QNode*)malloc(sizeof(QNode));
	p = pq->front;
	pq->front = p->next;
	free(p);
	if (pq->front == NULL)
		pq->rear == NULL;
	return true;
 
}
//销毁
void Destroy(LinkQueue* pq)
{
	QNode* p ;
	while (pq->front!=NULL)
	{
		p = pq->front;
		pq->front = p->next;
		free(p);
	}
	pq->rear == NULL;
 
}

青-冥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 15种内部排序方法 --- c语言
weixin_53272394的博客
07-31 812
内部排序 排序是计算机内经常进行的一种操作，其目的是将一组"无序"的记录序列调整为"有序"的记录序列。分内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。 将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持
基于C语言的常见的8种排序的时间复杂度比较算法
11-03
基于C语言的数据结构中常见的8种排序的时间复杂度比较算法
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8132
数据结构中最全的排序算法（C语言实现）
数据结构——排序（C语言）
qq_64592049的博客
10-04 609
时间复杂度：O（N^2）最差情况：逆序最优情况：顺序有序或者接近顺序有序。123456，每个数据都是直接插入到后面，一个都没挪。最优时间复杂度：O(N)
数据结构基本排序（c语言）
m0_69023444的博客
09-23 2269
1.冒泡排序 2.插入排序 3.希尔排序 4.直接选择排序 5.堆排序 6.快速排序 7.归并排序
C语言数据结构8大排序算法完整代码（可直接上机运行）
11-11
包括：插入、希尔、冒泡、快速、选择、堆排序、归并（二路归并）、基数排序8个排序算法，完整的C语言代码，可点开直接运行，并附详细注释，方便理解和维护
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
C语言数据结构 快速排序实例详解
12-31
C语言数据结构 快速排序实例详解 一、快速排序简介 快速排序采用分治的思想，第一趟先将一串数字分为两部分，第一部分的数值都比第二部分要小，然后按照这种方法，依次对两边的数据进行排序。 二、代码实现 #...
数据结构排序算法C语言实现
11-26
包括插入排序、堆排序、归并排序、基数排序、快速排序、冒泡排序、桶排序、拓扑排序、希尔排序、选择排序。
图解，C语言数据结构，插入排序.pdf
最新发布
11-17
插入排序c语言
常见排序算法 数据结构 C语言实现
03-17
用C语言写的常见排序算法，包括直接选择排序、折半插入排序、起泡排序、快速排序、简单选择排序、归并排序等，已通过VC 6.0 测试。绝对实用。
数据结构_C语言_严蔚敏_排序
06-02
数据结构_C语言_严蔚敏 吴伟民版_排序 课程源程序
【数据结构】排序-C语言版
局部变量和全局变量
03-25 1726
各类排序算法思想是什么？如何实现？时间复杂度分别是多少？稳定吗？ 常见的排序算法有如下7种： 插入排序 插入排序基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。 直接插入排序 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，...
数据结构之八种排序(c语言)
祈心无尘的博客
11-19 774
8种排序的时间复杂度和稳定性 排序方法 平均情况 最坏情况 最好情况 稳定性 1.冒泡排序 N^2 N^2 n 稳定 2.选择排序 N ...
数据结构（C语言）-排序
czh2637750821的博客
04-03 940
排序一、排序的基本概念二、插入排序1、有序插入方法2、直接插入排序2、折半插入排序3、希尔排序( Shell's Sort )三、交换排序1、冒泡排序 ( Bubble Sort )2、快速排序四、选择排序1、简单选择排序2、堆排序五、各种排序算法比较 一、排序的基本概念 为了查找方便，通常希望查找表是按关键字有序排序的，因此学习和研究各种排序的方法和对应的算法，有助于提高计算机对数据处理的工作效率。首先了解一些和排序相关的概念。 1.排序( Sorting ) 将数越元素(或记录)的任意序列，重新排列成
C语言排序方法------快速排序
HXYDJ的博客
07-12 2040
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 算法步骤： 1 从数列中挑出一个元素，称为 "基准"（pivot）。 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之
数据结构C语言用随机数来比较冒泡排序和选择排序的时间，并打印结果
weixin_51910460的博客
03-04 1508
实验名称 通过生成随机数来比较冒泡排序和快速排序算法的复杂度 实验内容：比较冒泡排序 快速排序算法复杂度。动手撰写随机数生成算法，生成一组随机数。通过主函数调用两个排序算法，对随机数进行排序（随机数的数量不少于两万，否则体现不出时间差），要对同一组随机数分别使用两种算法进行排序，并打印结果和运行时间。根据运行时间的不同，体会算法复杂度的影响。 需要注意的几点： 1.srand和rand函数在生成随机数时的不同，rand()为伪随机数，真正的随机数为 sr...
c语言数据结构 排序（一）
shizhongruyi0606的博客
09-05 736
c语言数据结构 排序（一）
c语言排序耗时比较,七大主流排序算法时间效率比较（基于C语言）
weixin_34627088的博客
05-19 3236
这段时间在温故一些常见的排序算法，顺手便把常见的一些比较著名的排序算法对同一个目标样本做了个比较。样本存于文件中， 可以根据需要进行替换。我调试的数据量较小，发现简单算法(冒泡，选择，插入)中差异相对明显，令人诧异的是改进算法中归并排序算法的效率比其他算法效率足足低了一个一个数量级。。。是样本量小影响了归并排序效率还是实现归并排序是我的代码出了问题呢？。。。我会在接下来的学习中进一步深究，同时也欢...
c语言数据结构快速排序算法
10-23
快速排序是一种经典的排序算法，用于将一个无序的数组按照递增（或递减）的顺序进行...以上是一种基本的C语言实现快速排序算法的方法，通过选择合适的基准元素并进行递归划分，可以在平均情况下实现较高的排序效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值