0
点赞
收藏
分享

微信扫一扫

大学数据结构实验(七.内部排序算法的应用一)


大学程序实验.数据结构.内部排序算法的应用一.排序

  • ​​0 目录​​
  • ​​7 内部排序算法的应用​​
  • ​​7.1 排序​​
  • ​​7.1.1 题目​​
  • ​​7.1.2 源码​​
  • ​​1.1.3 下载​​

  • ​​2 下一章​​

0 目录

7 内部排序算法的应用

7.1 排序

7.1.1 题目

1、常见排序算法实现(1-6选择几个算法练习)
1)问题描述:输入一组关键字序列分别实现下列排序。
(1)实现简单选择排序、直接插入排序和冒泡排序。
(2)实现希尔排序算法。
(3)实现折半插入排序。
(4)实现快速排序算法。
(5)实现堆排序算法。
(6)合并排序算法。
2) 实现提示:
数据输入后,每选择一种算法,把数据拷贝后再排序,保证原始数据不破坏.

7.1.2 源码

// 排序.cpp : Defines the entry point for the console application.
//

#include "stdlib.h"
#include "stdio.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 10
#define MAX_LENGTH_INSERT_SORT 7

typedef int Status;
typedef int ElemType;

typedef struct
{
ElemType r[MAXSIZE+1];
ElemType length;
}SqList;

Status ListCreate(SqList *&L)
{
int i;
int value;

L=(SqList*)malloc(sizeof(SqList));
L->length=0;

printf("---<顺序表的创建>---\n");
printf("请输入顺序表的元素数:");
label:
scanf("%d",&value);

if(value>0&&value<MAXSIZE)
{
printf("\n");
printf("请输入%d个整型数据\n",value);

for(i=1;i<=value;i++,L->length++)
{
printf("第%d个元素:",i);
scanf("%d",&L->r[i]);
}
}
else
{
printf("\n");
printf("输入的值域不合法或超出!\n");
printf("请重新输入:");
goto label;
}

return OK;
}

void swap(SqList *L,int i,int j)
{
int temp=L->r[i];
L->r[i]=L->r[j];
L->r[j]=temp;
}

//简单选择排序
void SelectSort(SqList *L)
{
int i,j,min;
printf("\n");
printf("简单选择排序--->\n");

for(i=1;i<L->length;i++)
{
min=i;
for(j=i+1;j<=L->length;j++)
{
if(L->r[min]>L->r[j])
{
min=j;
}
}
if(i!=min)
{
swap(L,i,min);
}
}
}
//简单选择排序


//直接插入排序
void InsertSort(SqList *L)
{
int i,j;
printf("\n");
printf("直接插入排序--->\n");

for(i=2;i<=L->length;i++)
{
if(L->r[i]<L->r[i-1])
{
L->r[0]=L->r[i];
for(j=i-1;L->r[j]>L->r[0];j--)
{
L->r[j+1]=L->r[j];
}
L->r[j+1]=L->r[0];
}
}
}
//直接插入排序


//冒泡排序改进算法
void BubbleSort(SqList *L)
{
int i,j;
ElemType Flag=TRUE;
printf("\n");
printf("冒泡算法排序--->\n");

for(i=1;i<L->length&&Flag;i++)
{
Flag=FALSE;
for(j=L->length-1;j>=i;j--)
{
if(L->r[j]>L->r[j+1])
{
swap(L,j,j+1);
Flag=TRUE;
}
}
}
}
//冒泡排序改进算法


//希尔排序
void ShellSort(SqList *L)
{
int i,j;
printf("\n");
printf("希尔算法排序--->\n");

int increment=L->length;
do
{
increment=increment/3+1;
for(i=increment+1;i<=L->length;i++)
{
if(L->r[i]<L->r[i-increment])
{
L->r[0]=L->r[i];
for(j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment)
{
L->r[j+increment]=L->r[j];
}
L->r[j+increment]=L->r[0];
}
}
}
while(increment>1);
}
//希尔排序


//折半插入排序
void BInsertSort(SqList *L)
{
int low,high,m;
printf("\n");
printf("折半插入排序--->\n");

for(int i=2;i<=L->length;i++)
{
L->r[0]=L->r[i];
low=1;
high=i-1;
while(low<=high)
{
m=(low+high)/2;
if(L->r[0]<L->r[m])
{
high=m-1;
}
else
{
low=m+1;
}
}
for(int j=i-1;j>=high+1;--j)
{
L->r[j+1]=L->r[j];
}
L->r[high+1]=L->r[0];
}
}
//折半插入排序


//快速排序优化算法
Status Partition(SqList *L,int low,int high)
{
int pivotkey;

pivotkey=L->r[low];
L->r[0]=pivotkey;
while(low<high)
{
while(low<high&&L->r[high]>=pivotkey)
{
high--;
}
L->r[low]=L->r[high];
while(low<high&&L->r[low]<=pivotkey)
{
low++;
}
L->r[high]=L->r[low];
}
L->r[low]=L->r[0];
return low;
}

void QSort(SqList *L,int low,int high)
{
int pivot;
if((high-low)>MAX_LENGTH_INSERT_SORT)
{
while(low<high)
{
pivot=Partition(L,low,high);

QSort(L,low,pivot-1);
low=pivot+1;
}
}
else
{
InsertSort(L);//考虑到性能的问题,小于阈值采用插入排序
printf("考虑到性能的问题,小于阈值采用插入排序:\n");
}
}

void QuickSort(SqList *L)
{
printf("\n");
printf("快速算法排序--->\n");
QSort(L,1,L->length);
}
//快速排序优化算法


//堆排序
void HeapAdjust(SqList *L,int s,int m)
{
int temp,j;
temp=L->r[s];

for(j=2*s;j<=m;j*=2)
{
if(j<m&&L->r[j]<L->r[j+1])
{
++j;
}
if(temp>=L->r[j])
{
break;
}
L->r[s]=L->r[j];
s=j;
}
L->r[s]=temp;
}

void HeapSort(SqList *L)
{
int i;
printf("\n");
printf("堆排序--->\n");

for(i=L->length/2;i>0;i--)
{
HeapAdjust(L,i,L->length);
}

for(i=L->length;i>1;i--)
{
swap(L,1,i);
HeapAdjust(L,1,i-1);
}
}
//堆排序


//归并排序算法
void Merge(int SR[],int TR[],int i,int m,int n)
{
int j,k,l;
for(j=m+1,k=i;i<=m&&j<=n;k++)
{
if(SR[i]<SR[j])
{
TR[k]=SR[i++];
}
else
{
TR[k]=SR[j++];
}
}
if(i<=m)
{
for(l=0;l<=m-i;l++)
{
TR[k+l]=SR[i+l];
}
}
if(j<=n)
{
for(l=0;l<=n-j;l++)
{
TR[k+l]=SR[j+l];
}
}
}

void MSort(int SR[],int TR1[],int s,int t)
{
int m;
int TR2[MAXSIZE+1];
if(s==t)
{
TR1[s]=SR[s];
}
else
{
m=(s+t)/2;
MSort(SR,TR2,s,m);
MSort(SR,TR2,m+1,t);
Merge(TR2,TR1,s,m,t);
}
}

void MergeSort(SqList *L)
{
printf("\n");
printf("归并算法排序(递归)--->\n");
MSort(L->r,L->r,1,L->length);
}
//归并排序算法


//非递归归并算法
void MergePass(int SR[],int TR[],int s,int n)
{
int i=1;
int j;
while(i<=n-2*s+1)
{
Merge(SR,TR,i,i+s-1,i+2*s-1);
i=i+2*s;
}
if(i<n-s+1)
{
Merge(SR,TR,i,i+s-1,n);
}
else
{
for(j=i;j<=n;j++)
{
TR[j]=SR[j];
}
}
}

void MergeSort2(SqList *L)
{
int *TR=(int *)malloc(L->length*sizeof(int));
int k=1;
printf("\n");
printf("归并算法排序(非递归)--->\n");

while(k<L->length)
{
MergePass(L->r,TR,k,L->length);
k=2*k;
MergePass(TR,L->r,k,L->length);
k=2*k;
}
}
//非递归归并算法


Status SqListTraver(SqList *L)
{
int i;
printf("遍历顺序表--->\n");

for(i=1;i<=L->length;i++)
{
printf("%3d",L->r[i]);
}
printf("\n");

return OK;
}

Status DataSave(SqList *L,int *a)
{
int i;
for(i=1;i<=L->length;i++)
{
a[i]=L->r[i];
}

return OK;
}

Status SqListMenu()
{
int value;

printf("\n");
printf(" _______>>>排序算法<<<______\n");
printf("| |\n");
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("| 9.归并算法排序(非递归) |\n");
printf("| 10.遍历顺序表 |\n");
printf("| 11.退出 |\n");
printf("|___________________________|\n");

printf("请选择你要执行的排序操作:");
label:
scanf("%d",&value);

if(value>0&&value<12)
{
return value;
}
else
{
printf("你输入的操作有误,请重新输入:");
goto label;
}
}

Status main()
{
SqList *L;
int i;
int value;
int array[MAXSIZE];

ListCreate(L);
DataSave(L,array);

label:
printf("\n");
printf("\n");
printf(" ----<<<重新加载顺序表>>>----");
for(i=1;i<=L->length;i++)
{
L->r[i]=array[i];
}
value=SqListMenu();

if(value==1)
{
SqListTraver(L);
SelectSort(L);
SqListTraver(L);
goto label;
}
else if(value==2)
{
SqListTraver(L);
InsertSort(L);
SqListTraver(L);
goto label;
}
else if(value==3)
{
SqListTraver(L);
BubbleSort(L);
SqListTraver(L);
goto label;
}
else if(value==4)
{
SqListTraver(L);
ShellSort(L);
SqListTraver(L);
goto label;
}
else if(value==5)
{
SqListTraver(L);
BInsertSort(L);
SqListTraver(L);
goto label;
}
else if(value==6)
{
SqListTraver(L);
QuickSort(L);
SqListTraver(L);
goto label;
}
else if(value==7)
{
SqListTraver(L);
HeapSort(L);
SqListTraver(L);
goto label;
}
else if(value==8)
{
SqListTraver(L);
MergeSort(L);
SqListTraver(L);
goto label;
}
else if(value==9)
{
SqListTraver(L);
MergeSort2(L);
SqListTraver(L);
goto label;
}
else if(value==10)
{
SqListTraver(L);
goto label;
}
else if(value==11)
{
printf("\n");
printf("退出!\n");
}
else
{
printf("\n");
printf("请输入正确的操作!\n");
goto label;
}

return OK;
}

1.1.3 下载

链接地址: ​​7.1_内部排序算法排序.CPP​​



举报

相关推荐

0 条评论