C
语言版课程
设计
#include
#include 产生随机数
#include 调用计算时间的函数
#include
using namespace std;
产生随机数，输入产生随机数的个数，范围，即可产生待排数据
void Random(long p[],long n,long a,long b)
{
long max,min;
if(a>b)
{
max=a-b+1;
min=b;
}
else
{
max=b-a+1;
min=a;
}
srand((unsigned)time(NULL));
for(long i=1;i<=n;i++)
p[i]=rand()%max+min;
}
输出排序后的结果；用已检测排序的正确，是否能正确排序
void Print(long p[],long n)
{
cout<<"\n排序后的结果：";
for(long i=1;i<=n;i++)
cout<<p[i]<<' ';
}
void Initiate(long p[],long q[],long n)
{
for(long i=1;i<=n;i++)
q[i]=p[i];
}
直接插入排序：排序并测试排序过程中的时间消耗
void StraightInsertionSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
for(long i=2;i<=n;++i)
if(q[i]<q[i-1])
{
q[0]=q[i];
q[i]=q[i-1];
for(long j=i-2;q[0]<q[j];--j)
q[j+1]=q[j];
q[j+1]=q[0];
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n直接插入排序时间消耗："<<time<<" MS";
delete []q;
}
折半插入排序：排序并测试排序过程中的时间消耗
void BinaryInsertionSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
for(long i=2;i<n;i++)
{
q[0]=q[i];
long low=1;
long high=i-1;
while(low<=high)
{
long m=(low+high)/2;
if(q[0]=high+1;--j)
q[j+1]=q[j];
q[high+1]=q[0];
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n折半插入排序时间消耗："<<time<<" MS";
delete []q;
}
希尔排序：排序并测试排序过程中的时间消耗
void ShellInsert(long q[],long dk,long n)
{
for(long i=dk+1;i<=n;i++)
{
if(q[i]0&&(q[0]<q[j]);j-=dk)
q[j+dk]=q[j];
q[j+dk]=q[0];
}
}
}
void ShellSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
long t=log(n-1)/log(2);
for(long k=1;k<=t;k++)
{
long dk=1;
for(long i=1;i<=t-k;i++)
{
dk=dk*2;
}
if(t!=k)
dk+=1;
ShellInsert(q,dk,n);
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
Print(q,n);
cout<<"\n希尔排序时间消耗："<<time<<" MS";
delete []q;
}
冒泡排序：排序并测试排序过程中的时间消耗
void BubbleSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
for(long j=1;j<=n;j++)
for(long i=1;iq[i+1])
{
long t=q[i];
q[i]=q[i+1];
q[i+1]=t;
}
// Print(q,n);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n冒泡排序时间消耗："<<time<<" MS";
delete []q;
}
双向起泡排序：排序并测试排序过程中的时间消耗
void BubbleSort_2(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
long low=0;
long high=n;
int change=1;
while(low<high&&change)
{
change=0;
for(long i=low;iq[i+1])
{
long t=q[i];
q[i]=q[i+1];
q[i+1]=t;
change=1;
}
high--;
for(i=high;i>low;i--)
if(q[i]<q[i-1])
{
long t=q[i];
q[i]=q[i+1];
q[i+1]=q[i];
change=1;
}
low++;
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n双向起泡排序时间消耗："<<time<<" MS";
delete []q;
}
递归形式的快速排序：排序并测试排序过程中的时间消耗
long Partition(long a[],long low,long high)
{
int m=a[low];
while(low<high)
{
while(low=m)
--high;
a[low]=a[high];
while(low<high&&a[low]<=m)
++low;
a[high]=a[low];
}
a[low]=m;
return low;
}
void Qsort(long a[],long low,long high)
{
if(low<high)
{
int pivotloc=Partition(a,low,high);
if(pivotloc-low<high-pivotloc)//改进后的快速排序效率确实提高了
{ //先对长度短的那一部分进行排序
Qsort(a,low,pivotloc);
Qsort(a,pivotloc+1,high);
}
else
{
Qsort(a,low,pivotloc);
Qsort(a,pivotloc+1,high);
}
}
}
void QuickSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
Qsort(q,1,n);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n快速排序时间消耗："<<time<<" MS";
delete []q;
// Print(q,n);
}
非递归形式的快速排序：用栈的性质
void QuickSort(long p[],long left,long right)
{
long *q=new long[right-left+2];
Initiate(p,q,right-left+1);
struct Stack
{
long left;
long right;
};
Stack S[99999];
long top=-1,i,j,start,end,temp;
if(left0)
{
start=S[top].left;
end=S[top].right;
top--;
long pivot=q[start];
i=start;
j=end;
for(; ;)
{
while(i<j&&q[i]<=pivot)
i++;
while(i<j&&pivot<q[j])
j--;
if(i<j)
{
temp=q[i];
q[i]=q[j];
q[j]=temp;
i++;
j--;
}
else
break;
}
q[j]=pivot;
if(start<i-1)
{
top++;
S[top].left=start;
S[top].right=i-1;
}
if(i+1<end)
{
top++;
S[top].left=i-1;
S[top].right=end;
}
}
}
Print(q,right-left+1);
}
简单选择排序：排序并测试排序过程中的时间消耗
void SelectSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
for(long i=1;i<=n;i++)
{
long k=i;
for(long j=i+1;j<=n;j++)
if(q[j]<q[k])
k=j;
long t=q[k];
q[k]=q[i];
q[i]=t;
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n简单选择排序时间消耗："<<time<<" MS";
delete []q;
}
堆排序：排序并测试排序过程中的时间消耗
void HeapAdjust(long q[],long s,long m)
{
long rc=q[s];
for(long j=2*s;j<=m;j*=2)
{
if(j<m&&q[j]=q[j])
break;
q[s]=q[j];
s=j;
}
q[s]=rc;
}
void HeapSort(long p[],long n)
{
long *q=new long[n+1];
Initiate(p,q,n);
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
or(long i=n/2;i>0;i--)
HeapAdjust(q,i,n);
for(i=n;i>1;i--)
{
long t=q[1];
q[1]=q[i];
q[i]=t;
HeapAdjust(q,1,i-1);
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
// Print(q,n);
cout<<"\n堆排序时间消耗："<<time<<" MS";
delete []q;
}
基数排序：排序并测试排序过程中的时间消耗
void RadixSort(long p[],long n,int radix)
{
struct Radix 基数排序
数据结构体
{
long rc;
Radix * next;
};
long *q=new long[n+1];
Initiate(p,q,n);
int L=1;
Radix * head[11],* tail[11];
Radix * p1,* p2;
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
for(int t=1;t<=radix;t++)
{
for(int k=0;knext=0;
tail[k]=head[k];
}
for(long i=1;irc=q[i];
p1->next=0;
p2=head[k];
while(p2->next!=0)
p2=p2->next;
p2->next=p1;
tail[k]=p1;
}
for(k=0;k<10;)
{
for(long j=k+1;jnext)
{
// tail[k]->next=head[j]->next;
// k=j;
break;
}
tail[k]->next=head[j]->next;
k=j;
}
p1=head[0]->next;
i=1;
while(p1)
{
q[i]=p1->rc;
p1=p1->next;
i++;
}
L*=10;
}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
/* Print(q,n);*/
cout<<"\n基数排序时间消耗："<<time<<" MS";
delete []q;
}
int main() 主函数
{
char choice;
do{
cout<<"排序时间消耗测试\n";
cout<>n>>a>>b;
long *p=new long[n+1];
Random(p,n,a,b);
// cout<<"产生的随机数：";
// for(int i=1;i<=n;i++)
// cout<<p[i]<b)
b=a;
int radix=0;
while(b)
{
b=b/10;
radix++;
}
StraightInsertionSort(p,n);//直接插入排序
BinaryInsertionSort(p,n);//折半插入排序
// ListInsertionSort(p,n);//表插入排序
ShellSort(p,n);//希尔排序
QuickSort(p,n);//快速排序
// QuickSort(p,1,n);
BubbleSort(p,n);//冒泡排序
BubbleSort_2(p,n);//双向起泡排序
SelectSort(p,n);//简单选择排序
HeapSort(p,n);//堆排序
RadixSort(p,n,radix);//基数排序
delete []p;
cout<>choice;
}while(choice=='Y'||choice=='y');
return 0;
}
本文档详述了一位学生使用C语言进行迷宫求解的课程设计过程，包括需求分析、概要设计、详细设计、测试及使用说明。设计中实现了非递归和递归两种算法，以链表作为栈数据结构，通过输入迷宫地图、起点和终点，输出解谜路径。在遇到问题时，通过改进算法解决了路径方向的表示。课程设计总结强调了理论与实践结合的重要性，以及在编程中不断学习和积累的必要性。
数据结构c语言课程设计报告之迷宫 
扫一扫
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
