一个很好的数据结构排序系统

最新推荐文章于 2023-12-23 20:02:39 发布
最新推荐文章于 2023-12-23 20:02:39 发布
阅读量2k 收藏 9
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 integer 测试 ini system struct

这是我的一个同学给我修改的排序系统,我觉得挺好的,就分享一下

 原创若看到请留一下名字

// Sort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdio.h> 
#include <iostream>
#include <ctime>
#include <windows.h>
#include <cmath>
#define MAXSIZE 50 
using namespace std;
typedef struct 
{ int key; 
}RECNODE; 
int b,t; //b为记录交换的次数，t为记录排序的趟数
int MakeList(RECNODE *r) 
{    
	int j,k; 
	printf("请输入初始数据(每个数据以空格隔开，-1结束)： "); 
	k=0; 
	scanf("%d",&j); 
	while(j!=-1) 
	{
		k++; 
	    r[k].key=j; 
	    scanf("%d",&j); 
	} 
	return k; 
}//输入要排序的一组数据，并且返回数据的个数，以-1为结束标志
void UndealoutList(RECNODE *r,int n) 
{  
	int i; 
	printf("未排序前的数据 ： "); 
	for(i=0;i<n;i++) 
	printf(" %d",r[i+1].key); 
	printf("\n"); 
} 
void DealoutList(RECNODE*r,int n) 
{   
	int i; 
	printf("排序后的数据 ： "); 
	for(i=0;i<n;i++) 
	printf(" %d",r[i+1].key); 
	printf("\n"); 
	printf("交换或比较的次数： %d\n",b); 
	printf("排序的趟数： %d\n",t); 
} 
void InsertSort(RECNODE*r,int n)//直接插入排序// 
/*实现"直接插入排序"可分三步进行：1．利用 "顺序查找"实现在R[1..i-1]中
查找R[i]的插入位置，R[1..j].key ? R[i].key < R[j+1..i-1].key；
2．将R[j+1..i-1]中的所有记录均后移一个位置；
3．将R[i] 插入(复制)到R[j+1]的位置上。*/
{   
	int i,j; 
        b=0,t=0; //b为记录交换的次数，t为记录排序的趟数
	for(i=2;i<=n;i++) 
	{ 
		r[0]=r[i]; //r[0]的作用是暂存空间
		j=i-1; 
		while(r[0].key<r[j].key) //如果目标数比源数小
		{ 
			r[j+1]=r[j]; //则让大的数从后往前依次往后挪一个位置，然后让小数插入到恰当置
			j--; b++;
		}
		r[j+1]=r[0]; 
		b++; t++; 
    } 
} 
void BiInsertionSort (RECNODE*r, int n)
{// 对记录序列R[1..n]作折半插入排序
	int low,high,i,j,m;
	for ( i=2; i<=n; ++i )
	{
		r[0] = r[i]; // 将R[i]暂存到R[0]/
		low = 1; high = i-1;
		while (low<=high) 
		{ //在R[low..high]中折半查找插入的位置
			m = (low+high)/2; // 折半
			if (r[0].key < r[m].key)
				high = m-1; // 插入点在低半区
			else low = m+1; // 插入点在高半区
		}
		for ( j=i-1; j>=high+1; --j )
			r[j+1] = r[j]; // 记录后移
		r[high+1] = r[0]; // 插入
	}
} // BInsertSort
void BubleSort(RECNODE *r,int n) //冒泡排序
{   
	int i,j; b=0,t=0; //b为记录交换的次数，t为记录排序的趟数
    RECNODE temp; //暂寸空间
	for(i=1;i<n;i++) 
	{ 
	    	for(j=n-1;j>=i;j--)//目标数是从第一个数开始，被比较数从最后一个开始 
			if(r[j+1].key<r[j].key) //如果目标数比其下一个数要大
			{ //则两数交换，下一趟比较则还是用原目标数与其下一个书比较 
				temp=r[j+1];
				r[j+1]=r[j]; 
				r[j]=temp; 
				b++; 
			} 
			else b++; //否则不用交换，继续和下一个数比较
			t++;  
	}
} 
void BubleSort(double a[]) //时间数组的冒泡排序
{   
	int i,j; b=0,t=0; 
	double temp; 
	for(i=1;i<7;i++) 
	{ 
		for(j=5;j>=i;j--) 
		if(a[j+1]<a[j]) 
		{ 
			temp=a[j+1]; 
			a[j+1]=a[j]; 
			a[j]=temp; 
			b++; 
		} 
		else b++; 
		t++; 
	}
} 
int Partition(RECNODE*r,int*low,int*high)//一躺快速排序// 
/*找一个记录，以它的关键字作为"枢轴"，凡其关键字小于枢轴的记录均移动至该记录之前，
反之，凡关键字大于枢轴的记录均移动至该记录之后。*/
{   
	int i,j; static int w=0; 
	RECNODE temp; 
	i=*low; //i指向第一个数
	j=*high; 
	temp=r[i]; //暂存单元，存着目标数
	do 
	{ //当目标数小于等于要比较的数，并且目标数在左边
		while((r[j].key>=temp.key)&&(i<j))	
		{ 
			j--; //则不用换，只要让指向要比较的数的位置左移一位
		    w++; 
		} 
		if(i<j) //若遇到一个在目标数右边的小数
		{
			r[i]=r[j]; //则将小数赋给目标数原来所在的位置
		    i++; //要比较的数的位置右移一位
		    w++;
		} 
		while((r[i].key<=temp.key)&&(i<j))//同理比较，只是现在要比较的数在目标数的右边
		{ 
			i++; w++; 
		} 
		if(i<j) 
		{ 
			r[j]=r[i]; 
		    j--; w++; 
		} 
	}while(i!=j); 
	r[i]=temp; 
	b=w; //b为记录交换的次数
 return i; 
} 
void QuickSort(RECNODE*r,int start,int end)//快速排序 
{    
	int i;  static int q=0; 
     if(start<end) 
     { 
		i= Partition(r,&start,&end); 
		q++; 
		QuickSort(r,start,i-1); //对低子表递归排序，i为中间位置
		QuickSort(r,i+1,end); //对高子表递归排序} 
		t=q;//t为记录排序的趟数 
	 }
}

void SeleSort(RECNODE*r,int n)//直接选择排序// 
//每次都是将无序序列中的最小的数找到，然后依次放到有序序列的最后
{    
	int i,j,z; 
	b=0,t=0; //b为记录交换的次数，t为记录排序的趟数
	RECNODE temp; 
	for(i=1;i<n;i++) 
	{  
		z=i; 
		for(j=i+1;j<=n;j++) //从第i个后的序列中选出最小的一个数
		if(r[j].key<r[z].key) 
		{  
			z=j;  b++;
		} 
		else b++; 
		if(z!=i) 
		{
			temp=r[i]; 
		    r[i]=r[z]; 
		    r[z]=temp;
		} 
		t++;
	}
} 
void ShellSort(RECNODE *r,int n)//希尔排序// 
{
	int i,j,dk; //dk记录前后位置的增量
	b=0,t=0; dk=n/2; 
	while(dk>0) //一趟增量为dk的插入排序
	{ 
		for (i=dk+1;i<=n;++i) 
		if(r[i].key<r[i-dk].key) //将r[i]插入有序增量子表
		{ 
			r[0]=r[i]; //r[0]为暂存单元
			for(j=i-dk;j>0&&r[0].key<r[j].key;j-=dk) 
			{r[j+dk]=r[j]; b++;//记录后移，查找插入位置 } 
			r[j+dk]=r[0]; } 
			dk=dk/2; //增量改为原来的一半
			t++; 
		}
	}
}
void Sift(RECNODE*r,int i,int m) 
{      
	int j; static int x=0; 
    RECNODE temp; 
    temp=r[i];  j=2*i; 
    while(j<=m) //沿key较大的孩子结点向下筛选
    { 
		if(j<m&&(r[j].key<r[j+1].key)) //j为key较大的记录的下标
        {
			j++; 
			x++; 
		} 
        if(temp.key<r[j].key) 
        {
			r[i]=r[j]; 
            i=j; j=2*i; 
            x++;
		} 
        else 
		x++;
		break;
	} 
    r[i]=temp; 
	b=x;
} 
void HeapSort(RECNODE*r,int n)//堆排序 
{    
	RECNODE temp; 
    int i; t=0; 
    for(i=n/2;i>=1;--i) 
    Sift(r,i,n); // 建大顶堆
	for(i=n;i>=2;--i) // 将堆顶记录和当前未经排序子序列
	//  H.r[1..i]中最后一个记录相互交换   
	{ 
		temp=r[1]; 
		r[1]=r[i]; 
		r[i]=temp; 
		Sift(r,1,i-1); // 对 H.r[1] 进行筛选
		t++;
	} 
} 
double TInsertSort(int len,RECNODE *a,int p)
{

	if(p!=8) 
	{
		len=MakeList(a); UndealoutList(a,len);
	}
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	InsertSort(a,len); 
	if(p!=8)
	{DealoutList(a,len);}
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"直接插入排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //直接插入排序时间测试
double TBiInsertionSort(int len,RECNODE *a,int p)
{
	if(p!=8) 
	{
		len=MakeList(a); UndealoutList(a,len); 
	}
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	InsertSort(a,len); 
	if(p!=8)
	{DealoutList(a,len);}
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"折半插入排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //直接插入排序时间测试
double TBubleSort(int len,RECNODE *a,int p)
{
	if(p!=8)
		//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	{
		len=MakeList(a);     UndealoutList(a,len); 
	}
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	BubleSort(a,len); 
	if(p!=8)
	{DealoutList(a,len);}
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"冒泡排序序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //冒泡排序时间测试
double TQuickSort(int len,RECNODE *a,int p)
{
	if(p!=8)
	{
		len=MakeList(a);     UndealoutList(a,len); 
	}
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	QuickSort(a,1,len); 
	if(p!=8){DealoutList(a,len); }
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"快速排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //快速排序时间测试
double TSeleSort(int len,RECNODE *a,int p)
{
	if(p!=8)
	{
		len=MakeList(a);     UndealoutList(a,len);
	}
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	SeleSort(a,len); 
	if(p!=8) {DealoutList(a,len);} 
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"直接选择排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //直接选择排序时间测试
double TShellSort(int len,RECNODE *a,int p)
{
	if(p!=8)
	{
		len=MakeList(a); UndealoutList(a,len); 
	}
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	ShellSort(a,len); 
	if(p!=8) {DealoutList(a,len); }
	//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"希尔排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //希尔排序时间测试
double THeapSort(int len,RECNODE *a,int p)
{
	if(p!=8)
		//若为时间效率全比较，则不用把比较的具体过程输出，只需输出排序时间
	{
		len=MakeList(a); UndealoutList(a,len);
	}
	LARGE_INTEGER m_liPerfFreq={0};
	QueryPerformanceFrequency(&m_liPerfFreq);     
	LARGE_INTEGER m_liPerfStart={0};
	QueryPerformanceCounter(&m_liPerfStart);
	HeapSort(a,len); 
	if(p!=8)
	{DealoutList(a,len); }
	LARGE_INTEGER liPerfNow={0};
	QueryPerformanceCounter(&liPerfNow);
	double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
	time/=m_liPerfFreq.QuadPart;
	cout<<"堆排序时间消耗："<<time<<" MS"<<"\n";
	return (time);
} //堆排序时间测试
void main() 
{ 
	double TIMES[8],TIMES1[8];
	RECNODE a[MAXSIZE]; 
	int len,p;
	do   
	{ 
		system("cls");//清屏
		printf("(1)---直接插入排序:\n");
		printf("(2)---折半插入排序:\n");
		printf("(3)---冒泡排序:\n");
		printf("(4)---快速排序:\n");
		printf("(5)---直接选择排序:\n");
		printf("(6)---堆排序:\n");
		printf("(7)---希尔排序:\n");
		printf("(8)---时间效率比较:\n");
		printf("(0)---退出.\n"); 
		printf("【请在上述序号中选择其中的一个并输入:】\n"); 
		scanf("%d",&p); 
	    switch(p) 
		{
			case 1:printf("[直接插入排序]\n");TInsertSort(len,a,p);	break; //直接插入排序
			case 2:printf("[折半插入排序]\n");TBiInsertionSort(len,a,p);	break; //折半插入排序
			case 3:printf("[冒泡排序]\n");TBubleSort(len,a,p);     break; //冒泡排序
			case 4:printf("[快速排序]\n");TQuickSort(len,a,p);     break; //快速排序
			case 5:printf("[直接选择排序]\n");TSeleSort(len,a,p);  break; //直接选择排序
			case 6:printf("[堆排序]\n");THeapSort(len,a,p);      break; //堆排序
			case 7:printf("[希尔排序]\n");TShellSort(len,a,p);     break; //希尔排序
			case 8:printf("[时间效率比较]\n");
				   {len=MakeList(a); UndealoutList(a,len);
					TIMES1[1]=TIMES[1]=TInsertSort(len,a,p);TIMES1[2]=TIMES[2]=TBiInsertionSort(len,a,p);
					TIMES1[3]=TIMES[3]=TBubleSort(len,a,p);TIMES1[4]=TIMES[4]=TQuickSort(len,a,p);TIMES1[5]=TIMES[5]=TSeleSort(len,a,p); 
					TIMES1[6]=TIMES[6]=THeapSort(len,a,p); TIMES1[7]=TIMES[7]=TShellSort(len,a,p);
					BubleSort(TIMES);
					printf("\n");
					if(TIMES[1]==TIMES1[1]) printf("排序这组数据用直接插入排序时间最短!\n");
					if(TIMES[1]==TIMES1[2]) printf("排序这组数据用折半插入排序时间最短!\n");   
					if(TIMES[1]==TIMES1[3]) printf("排序这组数据用冒泡排序时间最短!\n");  
					if(TIMES[1]==TIMES1[4]) printf("排序这组数据用快速排序时间最短!\n");     
					if(TIMES[1]==TIMES1[5]) printf("排序这组数据用直接选择排序时间最短!\n");  
					if(TIMES[1]==TIMES1[6]) printf("排序这组数据用堆排序时间最短!\n");       
					if(TIMES[1]==TIMES1[7]) printf("排序这组数据用希尔排序时间最短!\n");                                    
					break;
					} //时间效率全比较
			 case 0:                   break; //退出
			 default:printf("输入错误!请重新输入!\n");break; 
        } 
	    system("pause");//系统暂停，提示按任意键继续。。。。
   }while(p!=0); //for do
}

 


 

bizhu12
关注
专栏目录
Unity 面试篇|（六）数据结构和算法篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-20 5万+
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样遍历完后，堆中的10000个数就是所需的最大的10000个。桶排序是计数排序的升级版。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出1000*10000中的最终的结果。
数据结构——排序（十种常用内排序算法）
qq_2210007943的博客
09-12 3444
数据结构——排序一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构排序算法演示系统
06-04
多种排序演算及原代码
数据结构排序系统C实现（低时间、空间复杂度）
xjzjyx_的博客
04-07 666
一、需求 1.实现插入排序有关算法（直接插入排序、折半插入排序、希尔排序） 2.实现交换排序有关算法（冒泡排序、快速排序） 3.实现选择排序有关算法（简单选择排序、堆排序） 4.其他排序算法（归并排序、基数排序） 二、解决方案 1.采用顺序存储结构，待排关键字个数可变 2.采用顺序表判空函数和清空函数，实现一块内存多次使用，实现最低空间复杂度 三、代码 #include "pch.h" #incl...
排序系统
墨海灬流弈的博客
12-29 383
备注： 内部包含6种排序方式。 #include<iostream> using namespace std; typedef int ElementType; //交换 void Swap(ElementType *a,ElementType *b) { ElementType t=*a; *a=*b; *b=t; } //输出 void puts(ElementType A[],int N) { int i=0; for(i=0;i<N;i++) { cout&lt
数据结构-排序线性表实现学生管理系统
aids1990的博客
07-18 507
1. 树的定义 由n（n>=0）个结点的有限集。n=0表示空树。 n>1 满足： (1) 有且只有一个根结点。 (2) 其余结点分成互不相交的m个子集T1、T2、...、Tm,每个集合又都是一颗树。 注意：1）树可以是空树。 1）树的定义具有递归性 （树中有树）。 2. 树的术语 (1) 根：即根结点...
数据结构：排序
sinat_35803474的博客
04-19 380
一、排序按照待排序的记录数量不同，使得排序过程中涉及的存储器不同，排序方法分为两大类： 【内部排序】：待排序记录存放在计算机随机存储器中进行排序 【外部排序】：待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需要外存进行访问按照稳定性，排序方法分为 【稳定性排序】： 通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单化一下
数据结构--排序之快速排序
qq_52363432的博客
02-08 7634
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。快排每一趟都会有一个元素回到它真正的位置。
数据结构课程设计----综合排序
wsswsswss123的博客
03-30 4402
《数据结构课程设计》报告 日期： 项目名称： 综合排序 一、项目简介和需求分析 排序（sorting是计箅机程序设计的一种重要操作，它的功能是将一组任意顺序数据元素（记录），根据某一个（或几个）关键字按一定的顺序里新排列成为有序的序列。由于待排序的记录数量不同，使得排序过程中涉及的存储器的不同，可将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序记录的数量很大，以致内存一次不能容纳全部记
【数据结构入门精讲 | 第九篇】考研408排序算法专项练习（一）
最新发布
等风来
12-23 3747
1.希尔排序是稳定的算法。（错） 解析：稳定性是指如果两个元素在排序前后的相对顺序保持不变，那么这个排序算法就是稳定的。对于具有相同关键字的元素，排序后它们的相对位置应该保持不变。 2.仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。（对） 3.对N个记录进行归并排序，归并趟数的数量级是O(NlogN)。（错） 答案：O(logN) 4.对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。（错）
数据结构--五种排序
11-14
南开大学计算机科学与技术数据结构辛运帏老师五种排序代码
数据结构课程设计-排序综合系统
07-04
本程序的编程使用了友好的交互界面，用户可以通过交互界面轻松选择所要进行的操作，执行结果在界面显示的同时也输出到文件。算法当面对直接插入排序、快速排序、希尔排序、选择排序、堆排序、冒泡排序的操作。
排序子系统 C语言版
12-14
这是一个我们数据结构课程设计做的排序子系统，当时我们学的是c语言，很适合于大学生作为课程设计之用，当然也可以做为毕业设计的参考，真心希望对你的课程设计有所帮助！！！
南邮 数据结构 实验四 各排序方法时间测试
12-26
使用随机数产生器产生大数据集合，运行上述各种排序算法，使用系统时钟测量各个算法所需的实际时间，并分析程序的运行结果。（常见内排序算法实际排序所需时间测试及比较）
航班管理系统 c++代码
10-03
航班管理系统航班管理系统航班管理系统航班管理系统航班管理系统航班管理系统c++代码 仅供参考学习
数据结构（排序算法总结）（C语言）
x18261294286的博客
08-03 7557
排序算法常见的有八种： 算法一：插入排序 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 算法步骤： 1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某...
数据结构之排序大综合
HPU_FRDHR的博客
12-13 488
冗杂了：           直接插入排序           折半插入排序           希尔排序           冒泡排序           快速排序           选择排序           堆排序           归并排序 的一个程序。。。 #include&lt;bits/stdc++.h&gt; #include &lt;windows.h&gt; ...
数据结构--排序(中)
weixin_43935646的博客
04-07 640
目录1、堆排序1.1代码实现1.2总结2、交换排序2.1 冒泡排序2.1.1代码实现2.1.2总结2.2快速排序2.2.1 hoare版本2.2.1.1 例子2.2.1.2 代码实现2.2.2 挖坑法2.2.2.1 例子2.2.2.2 代码实现2.2.3 前后指针法2.2.3.1 例子2.2.3.2 代码实现2.3 快排优化2.2.4 总结 1、堆排序   　堆排序(Heapsort)是指利用堆积...
排序算法 数据结构
weixin_58464994的博客
05-30 256
排序算法 数据结构
数据结构排序习题与解答
排序是数据结构中的一个重要概念，涉及到如何有效地对一组数据进行排列。本资源提供的习题集涵盖了多种排序算法及其特性，旨在帮助学习者巩固和理解排序算法的基础知识。 1. 稳定性：稳定排序算法是指在排序过程中...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值