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

最新推荐文章于 2022-05-30 16:40:57 发布
最新推荐文章于 2022-05-30 16:40:57 发布
阅读量1.9k 收藏 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
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构排序算法演示系统
06-04
多种排序演算及原代码
数据结构排序系统C实现（低时间、空间复杂度）
xjzjyx_的博客
04-07 557
一、需求 1.实现插入排序有关算法（直接插入排序、折半插入排序、希尔排序） 2.实现交换排序有关算法（冒泡排序、快速排序） 3.实现选择排序有关算法（简单选择排序、堆排序） 4.其他排序算法（归并排序、基数排序） 二、解决方案 1.采用顺序存储结构，待排关键字个数可变 2.采用顺序表判空函数和清空函数，实现一块内存多次使用，实现最低空间复杂度 三、代码 #include "pch.h" #incl...
排序系统
墨海灬流弈的博客
12-29 333
备注： 内部包含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 483
1. 树的定义 由n（n>=0）个结点的有限集。n=0表示空树。 n>1 满足： (1) 有且只有一个根结点。 (2) 其余结点分成互不相交的m个子集T1、T2、...、Tm,每个集合又都是一颗树。 注意：1）树可以是空树。 1）树的定义具有递归性 （树中有树）。 2. 树的术语 (1) 根：即根结点...
数据结构：排序
sinat_35803474的博客
04-19 359
一、排序按照待排序的记录数量不同，使得排序过程中涉及的存储器不同，排序方法分为两大类： 【内部排序】：待排序记录存放在计算机随机存储器中进行排序 【外部排序】：待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需要外存进行访问按照稳定性，排序方法分为 【稳定性排序】： 通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单化一下
动画演示swf-数据结构+排序
05-16
数据结构与排序是计算机科学中的基础且至关重要的概念，它们对于理解如何有效地存储和处理大量信息至关重要。在“动画演示swf-数据结构+排序”这个压缩包中，包含了一系列生动形象的SWF动画，旨在帮助学习者通过视觉...
数据结构排序ppt.pptx
最新发布
12-18
数据结构排序ppt 在本章节中，我们将探讨数据结构中的排序算法，包括插入排序、冒泡排序、快速排序、选择排序、堆排序和归并排序等。本章节的教学目标是掌握排序的基本概念，掌握插入排序、冒泡排序、快速排序、...
数据结构实验：八个排序算法的实现与比较
11-07
排序在计算机软件系统设计中占有相当重要的地位，特别是在事务处理系统中，需要经常对有关的数据排序，以便提高检索等操作的效率。 本实验将进行以下工作： 1、用代码实现排序的8个排序算法（直接插入、希尔、冒泡...
JAVA数据结构排序动态演示
06-08
在这个"JAVA数据结构排序动态演示"项目中，开发者通过实现一系列经典的排序算法并配合动态界面展示，使学习者能直观地理解各种排序算法的工作原理。 首先，我们来详细解析每个排序算法： 1. **直接插入排序（直接...
合工大数据结构实验 排序
04-14
本实验的焦点是“排序”，这是数据结构中的一个核心主题，广泛应用于各种软件系统中。排序算法的目标是将一组无序的数据元素按照特定的顺序排列。 在大数据背景下，排序变得更加重要，因为有序数据可以极大地提高...
数据结构--五种排序
11-14
南开大学计算机科学与技术数据结构辛运帏老师五种排序代码
数据结构课程设计-排序综合系统
07-04
本程序的编程使用了友好的交互界面，用户可以通过交互界面轻松选择所要进行的操作，执行结果在界面显示的同时也输出到文件。算法当面对直接插入排序、快速排序、希尔排序、选择排序、堆排序、冒泡排序的操作。
排序子系统 C语言版
12-14
这是一个我们数据结构课程设计做的排序子系统，当时我们学的是c语言，很适合于大学生作为课程设计之用，当然也可以做为毕业设计的参考，真心希望对你的课程设计有所帮助！！！
南邮 数据结构 实验四 各排序方法时间测试
12-26
使用随机数产生器产生大数据集合，运行上述各种排序算法，使用系统时钟测量各个算法所需的实际时间，并分析程序的运行结果。（常见内排序算法实际排序所需时间测试及比较）
航班管理系统 c++代码
10-03
航班管理系统航班管理系统航班管理系统航班管理系统航班管理系统航班管理系统c++代码 仅供参考学习
数据结构（排序算法总结）（C语言）
x18261294286的博客
08-03 7502
排序算法常见的有八种： 算法一：插入排序 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 算法步骤： 1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某...
数据结构之排序大综合
HPU_FRDHR的博客
12-13 450
冗杂了：           直接插入排序           折半插入排序           希尔排序           冒泡排序           快速排序           选择排序           堆排序           归并排序 的一个程序。。。 #include&lt;bits/stdc++.h&gt; #include &lt;windows.h&gt; ...
数据结构--排序(中)
weixin_43935646的博客
04-07 370
目录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 233
排序算法 数据结构
数据结构课程设计：排序算法比较
这个设计的主要目的是比较各种排序算法的优劣，对于学习数据结构的学生来说是一个很好的实践机会。同时，通过这个设计，学生可以掌握模块化编程的思想，并了解不同算法和数据结构的应用场景。在具体实现的过程中，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值