数据结构 C语言 综合排序问题

一、实验目的和要求

1、掌握各种内排序算法的实现方法；

2、学会分析各种内排序算法的时间复杂度；

二、实验环境

软件：Dev-C++

三、实验原理及内容

#include<stdio.h>

#include<stdlib.h>
#include<time.h>


#define MaxSize 100000
//const int MaxSize=100000;
#define FALSE 0
#define TRUE 1


typedef int KeyType;
typedef int DataType;
typedef int Status; 
typedef int BOOL; 


typedef struct entry//数据元素 
{
KeyType key;//排序关键字，KeyType应该为可比较类型 
DataType data;//data包含数据元素中的其他数据项 
}Entry;


typedef struct list//顺序表 
{
int n;//待排序数据元素数量 
Entry D[MaxSize];//静态数组存储数据元素 
}List;


typedef struct maxheap//
{
int n;//,MaxHeap;
Entry D[MaxSize];//静态数组存储数据元素 
}MaxHeap;


Status Init(List *list)
{
int i;
list->n=MaxSize;
//list->D=(Entry *)malloc(sizeof(Entry)*list->n);  //(ElemType *)
for(i=0;i<list->n;i++)
{
list->D[i].key=0;
//printf("%d ",list->D[i].key);
}
//printf("\n");
}


Status Init(MaxHeap *heap)
{
int i;
heap->n=MaxSize;
//list->D=(Entry *)malloc(sizeof(Entry)*list->n);  //(ElemType *)
for(i=0;i<heap->n;i++)
{
heap->D[i].key=0;
//printf("%d ",list->D[i].key);
}
//printf("\n");
}


Status Output(List list)
{
int i;
for(i=0;i<list.n;i++)         //i从0到n-1 
{
printf("%d ",list.D[i].key);
} 
printf("\n");
return 1;
}


Status Output(MaxHeap heap)
{
int i;
for(i=0;i<heap.n;i++)         //i从0到n-1 
{
printf("%d ",heap.D[i].key);
} 
printf("\n");
return 1;
}


int FindMin(List list,int startIndex)
{
int i,minIndex=startIndex;
for(i=startIndex;i<list.n;i++)
{
if(list.D[i].key<list.D[minIndex].key)
{
minIndex=i;
}
}
return minIndex;
} 


void Swap(Entry *D,int i,int j)
{
if(i==j)
return ;
Entry temp=*(D+i);
*(D+i)=*(D+j);
*(D+j)=temp;
}


void SelectSort(List *list)
{
int minIndex,startIndex=0;
while(startIndex<list->n-1)
{
minIndex=FindMin(*list,startIndex);
Swap(list->D,startIndex,minIndex);
startIndex++;
//printf("第%d次: ",startIndex);
//Output(*list);//*??
}
}


void InsertSort(List *list)
{
int i,j;
for(i=1;i<list->n;i++)
{
Entry insertItem=list->D[i];
for(j=i-1;j>=0;j--)
{
//
if(insertItem.key<list->D[j].key)
list->D[j+1]=list->D[j];
else break;
}
list->D[j+1]=insertItem;//
//printf("第%d次: ",i);
//Output(*list); 
}
}


void BubbleSort(List *list)
{
int i,j;
BOOL isSwap=FALSE;
for(i=list->n-1;i>0;i--)
{
isSwap=FALSE;//
for(j=0;j<i;j++)
{
if(list->D[j].key>list->D[j+1].key)
{
Swap(list->D,j,j+1);
isSwap=TRUE;
}
}
if(isSwap==0) break;//???
//else
//{
//printf("第%d次: ",MaxSize-j);
    //Output(*list); 
//} 
}
}


int Partition(List *list,int low,int high)
{
int i=low,j=high+1;
Entry pivot=list->D[low];
do{
do i++;
while(list->D[i].key<=pivot.key);
do j--;
while(list->D[j].key>pivot.key);
if(i<j)
Swap(list->D,i,j);
}while(i<j);
Swap(list->D,low,j);
return j;
}


void QuickSort(List *list,int low,int high)
{
int k;
if(low<high)
{
k=Partition(list,low,high);
//printf("第%d次: ",startIndex);
//Output(*list);//*??
QuickSort(list,low,k-1);
QuickSort(list,k+1,high);
}
}


void QuickSort(List *list)
{
QuickSort(list,0,list->n-1);
}


void Merge(List *list,Entry *temp,int low,int n1,int n2)
{
int i=low,j=low+n1;
int k=0;//
while(i<=low+n1-1&&j<=low+n1+n2-1)
{
if(list->D[i].key<=list->D[j].key)
{
*(temp+k)=list->D[i++];
k++;//
}
else
{
*(temp+k)=list->D[j++];
k++;//
}
}
while(i<=low+n1-1)
{
*(temp+k)=list->D[i++];
k++;//
}
while(j<=low+n1+n2-1)
{
*(temp+k)=list->D[j++];
k++;//
}
//
for(i=0;i<k;i++)
{
list->D[low++]=temp[i];
}
}


void MergeSort(List *list)
{
Entry temp[MaxSize];
int low,n1,n2,size=1;
while(size<list->n)
{
low=0;
while(low+size<list->n)
{
n1=size;
if(low+size*2<list->n)
{
n2=size;
}
else
{
n2=list->n-low-size;
}
Merge(list,temp,low,n1,n2);
low+=n1+n2;
}
//for(i=0;i<list->n;i++)
//{
//list->D[i]=temp[i];
//}
size*=2;
}
}


void AdjustDown(Entry *Heap,int s,int m)
{//
Entry Temp=*(Heap+s);
int j=0;
for(j=2*s+1;j<=m;j=s*2+1)
{
if(j+1<=m&&Heap[j].key<Heap[j+1].key)
j++;
if(Temp.key>=Heap[j].key)
break;
Heap[s]=Heap[j];
s=j;
}
Heap[s]=Temp;
}


void HeapSort(MaxHeap *heap)
{
int i;
//Entry temp;
for(i=heap->n/2-1;i>=0;i--)
AdjustDown(heap->D,i,heap->n-1);
for(i=heap->n-1;i>0;i--)
{
Swap(heap->D,0,i);
AdjustDown(heap->D,0,i-1);
}
}


void rand(List *list)
{
int i;
srand((unsigned)time(NULL));
printf("初始 : ");
for(i=0;i<list->n;i++)
{
list->D[i].key=rand();
printf("%d ",list->D[i].key);
}
printf("\n");
}


void rand(MaxHeap *heap)
{
int i;
srand((unsigned)time(NULL));
printf("初始 : ");
for(i=0;i<heap->n;i++)
{
heap->D[i].key=rand();
printf("%d ",heap->D[i].key);
}
printf("\n");
}


int main()
{
int a[6],b[6],c[6]; 
List l;
MaxHeap h;
Init(&l);
Init(&h);

rand(&l);
//Output(l);
a[0]=clock();
SelectSort(&l);
b[0]=clock();//到这结束
    c[0]=b[0]-a[0];//算出来的单位是毫秒
printf("最终 : ");
Output(l);
//printf("时间 : %dms\n",c[0]);

rand(&l);
a[1]=clock();
InsertSort(&l);
b[1]=clock();//到这结束
    c[1]=b[1]-a[1];//算出来的单位是毫秒
printf("最终 : ");
Output(l);
//printf("时间 : %dms\n",c[1]);

rand(&l);
a[2]=clock();
BubbleSort(&l);
b[2]=clock();//到这结束
    c[2]=b[2]-a[2];//算出来的单位是毫秒
printf("最终 : ");
Output(l);
//printf("时间 : %dms\n",c[2]);

rand(&l);
a[3]=clock();
QuickSort(&l);
b[3]=clock();//到这结束
    c[3]=b[3]-a[3];//算出来的单位是毫秒
printf("最终 : ");
Output(l);
//printf("时间 : %dms\n",c[3]);


rand(&l);
a[4]=clock();
MergeSort(&l);
b[4]=clock();//到这结束
    c[4]=b[4]-a[4];//算出来的单位是毫秒
printf("最终 : ");
Output(l);
//printf("时间 : %dms\n",c[4]);

rand(&h);
a[5]=clock();
HeapSort(&h);
b[5]=clock();//到这结束
    c[5]=b[5]-a[5];//算出来的单位是毫秒
printf("最终 : ");
Output(h);
//printf("时间 : %dms\n",c[5]);

printf("\n");
printf("时间 : %dms\n",c[0]);
printf("时间 : %dms\n",c[1]);
printf("时间 : %dms\n",c[2]);
printf("时间 : %dms\n",c[3]);
printf("时间 : %dms\n",c[4]);
printf("时间 : %dms\n",c[5]);
return 0;

}

四、实验总结

当排序数据十分大时，会导致栈空间不足导致爆栈而报错；

解决方法：在Dev-C++中菜单中找到“编译选项”把“-wl,-stack,10000000000”贴到“编译时输入一下命令”；