静态顺序表的实现及相关操作源代码（插入，删除，排序，逆置，超详细）

导读：今晚先上传所有的源代码，日后进行详细解读

//2018/1/14  22:11
//顺序表(借用一个一维数组来表示,静态顺序表) 
#include<stdio.h>
#define Maxsize 100
typedef struct
{
	int data[Maxsize];
	int  length;
}Seqlist;

Seqlist * creat(Seqlist * L);                 //创建顺序表，第一种写法
void printfdata(Seqlist * L);                 //打印顺序表
Seqlist *initseq(Seqlist *L);                 //初始化顺序表
Seqlist *delet_number(Seqlist *L);            //删除顺序表第i个元素
Seqlist *delet_data(Seqlist *L);              //删除顺序表所有值为x的元素
Seqlist *delet_datast(Seqlist *L,int s,int t);//删除顺序表值为是s和t之间的元素
Seqlist *insert_number(Seqlist *L);           //插入顺序表第i个元素
Seqlist *reverse1(Seqlist *L);                //逆置顺序表1
Seqlist *reverse2(Seqlist *L);                //逆置顺序表1

Seqlist *bubble(Seqlist *L);                  //冒泡排序
Seqlist *bubble1(Seqlist *L);                 //冒泡排序优化

Seqlist *zheban_insertsort(Seqlist *L);       //折半插入排序
Seqlist *zheban_insertsort1(Seqlist *L);      //折半插入排序优化

Seqlist *zhijie_insertsort(Seqlist *L);       //直接插入排序
Seqlist *zhijie_insertsort1(Seqlist *L);      //直接插入排序优化

Seqlist *quik_sort(Seqlist *L,int left,int right);//快速排序

Seqlist *Select_sort(Seqlist *L);             //选择排序

Seqlist *merge_sort(Seqlist *L,int low,int high);//归并排序
Seqlist *merge_sort_zi(Seqlist *L,int low,int mid,int high);

Seqlist *shell_sort(Seqlist *L);              //希尔排序


//Seqlist *bubble(Seqlist *L);//冒泡排序顺序表

Seqlist  creat2(Seqlist * L);//第二种写法
//void printfdata2(Seqlist L);
Seqlist  initseq2(Seqlist *L);


int main()
{
	printf("--------------------------------------------------------------------------------\n");
	printf("            *顺序表的实现及相关操作*             \n");
	printf("\n");
	printf("              0.顺序表的初始化                   \n");
	printf("              1.删除第i个元素                    \n");
	printf("              2.删除所有元素为x的元素            \n");
	printf("              3.删除其值在s与t之间的所有元素     \n");
    printf("              4.插入第i个位置                    \n");
	printf("              5.排序（从小到大）                 \n");
	printf("              6.逆置                             \n");
	printf("              7.创建顺序表                       \n");
	printf("              8.打印顺序表                       \n");
	printf("              9.退出                             \n");

	//测试
	//int ff;
    //scanf("%d",&ff);
    //printf("%d",ff);

	Seqlist L,L2;
	int number,number0;
	printf("请输入功能序号: ");
	scanf("%d",&number);
	while(number>=0 && number<=9)
	{
	switch(number)
	{
	case 0:
		printf("-----初始化开始啦\n");
		printf("\n");
		initseq(&L);
		printf("-----初始化结束啦\n");
		printf("\n");
		break;
	case 1:
		printf("\n");
		delet_number(&L);//删除第i个元素
		printf("\n");
		break;
	case 2:
		printf("\n");
		delet_data(&L);//删除所有元素为x的元素
		printf("\n");
		break;
	case 3:
		printf("\n");
		int s,t;
		printf("请输入下限值s:");
		scanf("%d",&s);
        printf("请输入上限值t:");
		scanf("%d",&t);
		delet_datast(&L,s,t);//删除其值在s与t之间的所有元素
		printf("\n");
		break;
	case 4:
		printf("\n");
		insert_number(&L);//插入第i个位置
		printf("\n");
		break;
	case 5:
		printf("\n");
		//bubble(&L);
		//bubble1(&L);
		//zhijie_insertsort1(&L);
		//zheban_insertsort(&L);
		//zheban_insertsort1(&L);
		//shell_sort(&L);
		//Select_sort(&L);             //选择排序
		quik_sort(&L,1,L.length);
		printf("\n");
		break;
	case 6:
		printf("\n");
		printf("6");
		reverse1(&L);//逆置
		printf("\n");
		break;
	case 7:
		printf("\n");
		printf("-----创建顺序表开始啦\n");//
		creat(&L);
		//printfdata(&L);
		printf("-----创建顺序表结束啦\n");//
		printf("\n");
		break;
	case 8:
		printf("\n");
		printf("-----打印顺序表开始啦\n");//
		printfdata(&L);
		printf("-----打印顺序表结束啦\n");//
		printf("\n");
		break;
	case 9:
	default:
		break;
	}
	    printf("\n");
	    printf("请输入功能序号：");
		scanf("%d",&number0);
		number = number0;
		printf("\n");
	}


	/*Seqlist L,L2;//第一种写法
	initseq(&L);
    initseq2(&L2);
//	creat(&L);
//  creat2(&L2);

//	printf("%d\n",L2.data[4]);
	printfdata(&L);
//	printfdata(L2);*/

	return 0;
}

Seqlist *initseq(Seqlist *L)
{
	//链表初始化1
	int i;
	L->length = 0;
	for(i=1;i<=Maxsize;i++)
		L->data[i] = 0;
	return L;
}
Seqlist  initseq2(Seqlist *L)
{
	//顺序表初始化
	int i;
	L->length = 0;
	for(i=1;i<=Maxsize;i++)
		L->data[i] = 0;
	return *L;
}

Seqlist * creat(Seqlist *L)
{//创建顺序表
	int n,data0,i;
	printf("请输入顺序表的元素个数: ");
	scanf("%d",&n);
	for (i=1;i<=n;i++)
	{
		printf("请输入第%d个顺序表的元素值：",i);
		scanf("%d",&L->data[i]);
		//L->data[i] = data0;
	}
	L->length = n;
	return  L;
}
Seqlist  creat2(Seqlist *L)
{//创建顺序表
	int n,data0,i;
	printf("请输入顺序表的元素个数: ");
	scanf("%d",&n);
	for (i=1;i<=n;i++)
	{
		printf("请输入第%d个顺序表的元素值：",i);
		scanf("%d",&L->data[i]);
		//L->data[i] = data0;
	}
	L->length = n;
	return * L;
}
void printfdata(Seqlist * L)
{//打印顺序表
	//printf("开始打印数据了\n");
	int i;
	for (i = 1;i<=L->length;i++)
		printf("%d  ",L->data[i]);
	printf("\n");
}
Seqlist *delet_number(Seqlist *L)
{//删除顺序表第i个元素
	int number;
	printf("开始删除了\n");
	printf("请输入要删除的元素序号：");
	scanf("%d",&number);
	int i,temp;
	for(i = number;i<=L->length+1;i++)
	{
		L->data[number] = L->data[number+1];
		number++;
	}
	L->length--;
	return L;
	printf("删除结束了\n");
}
Seqlist *delet_data(Seqlist *L)
{//删除顺序表所有值为x的元素
	int data,i,j;
	printf("请输入所要删除的元素值：");
	scanf("%d",&data);
	for(i=L->length;i>=1;i--)
	{
		if(L->data[i]==data)
		{
			for(j=i;j<=L->length;j++)
			{
				L->data[i] = L->data[i+1];
				i++;
			}
			L->length--;
		}
	}
	return L; 
}
Seqlist *delet_datast(Seqlist *L,int s,int t)
{//删除顺序表值为是s和t之间的元素
	int i,j;
	for(i=L->length;i>=1;i--)
	{
		if(L->data[i]>s && L->data[i]<t)
		{
			for(j=i;j<=L->length;j++)
			{
				L->data[i] = L->data[i+1];
				i++;
			}
			L->length--;
		}
	}
	return L;
}
Seqlist *insert_number(Seqlist *L)
{//插入顺序表第i个元素
	int number,i,l = L->length,data;
	printf("请输入要插入的位置序号：");
	scanf("%d",&number);
	printf("请输入要插入的元素值：");
	scanf("%d",&data);

	for(i=l;i>=number;i--)
	{
		L->data[i+1] = L->data[i];
		l--;
	}
	L->data[number] = data;
	L->length++;
	return L;
}
Seqlist *reverse1(Seqlist *L)
{//逆置顺序表1
	int l = L->length,i,temp;
	for (i=1;i<=l/2;i++)
	{
		temp = L->data[i];
		L->data[i] = L->data[L->length-i+1];
		L->data[L->length-i+1] = temp;
	}
	return L;
}
Seqlist *bubble(Seqlist *L)
{//冒泡排序顺序表(复杂写法)
	int temp,i,j;
	for (i=1;i<=L->length;i++)
	{
		for(j=1;j<L->length;j++)
		if(L->data[j]>L->data[j+1])
		{
			temp = L->data[j];
			L->data[j] = L->data[j+1];
			L->data[j+1] = temp;
		}
	}
	return L;
}

Seqlist *bubble1(Seqlist *L)
{//冒泡排序顺序表(优化版本)
	int temp,i,j;
	for (i=1;i<=L->length;i++)
	{
		for(j=1;j<=L->length-i;j++)
		if(L->data[j]>L->data[j+1])
		{
			temp = L->data[j];
			L->data[j] = L->data[j+1];
			L->data[j+1] = temp;
		}
	}
	return L;
}
Seqlist *zhijie_insertsort(Seqlist *L)
{      //直接插入排序顺序表
	int i,j;
	for (i=1;i<L->length;i++)
	{
		if(L->data[i+1]<L->data[i])
		{
			int temp = L->data[i+1];
			for(j=i;j>0&&L->data[j]>temp;j--)
				L->data[j+1] = L->data[j];
			L->data[j+1] = temp;
		}
	}
	return L;
}


Seqlist *zhijie_insertsort1(Seqlist *L)
{      //直接插入排序顺序表(优化版)
	int i,j;
	for (i=2;i<=L->length;i++)
	{
		L->data[0] = L->data[i];
		j = i-1;
		while(L->data[0]<L->data[j])
		{
			L->data[j+1] = L->data[j];
			j--;
		}
		L->data[j+1] = L->data[0];
	}
	return L;
}
Seqlist *zheban_insertsort(Seqlist *L)
{       //折半插入排序
	int i,j,low,high,mid;
	for(i=2;i<=L->length;i++)                     //逐步扩大有序表
	{
		L->data[0] = L->data[i];
		low = 1;high = i-1;
		while(low<=high)                          //利用折半查找寻找插入位置
		{
			mid = (low+high)/2;
			if(L->data[0]<L->data[mid])
				high = mid-1;
			else
				low = mid+1;
		}
		for(j=i-1;j>=low;j--)//for(j=i-1;j>=high+1;j--)//成块移动
		{
			L->data[j+1] = L->data[j];
		}
		L->data[high+1] = L->data[0];
	}

	return L;
}
Seqlist *zheban_insertsort1(Seqlist *L)
{       //折半插入排序（优化）
	int i,j,low,high,mid;
	for(i=2;i<=L->length;i++)                     //逐步扩大有序表
	{
		if(L->data[i-1]>L->data[i])               //加了一个if做判断，是发生逆序才插入，否则就跳过
		{
		L->data[0] = L->data[i];
		low = 1;high = i-1;
		while(low<=high)                          //利用折半查找寻找插入位置
		{
			mid = (low+high)/2;
			if(L->data[0]<L->data[mid])
				high = mid-1;
			else
				low = mid+1;
		}
		for(j=i-1;j>=low;j--)//for(j=i-1;j>=high+1;j--)//成块移动，后一种写法也可以，可以想想为什么
		{
			L->data[j+1] = L->data[j];
		}
		L->data[high+1] = L->data[0];
		}
	}

	return L;
}
Seqlist *shell_sort(Seqlist *L)            
{ //希尔排序
    int gap = 4,start=1,i,j;
	while(gap>=1)
	{
		for(i=start+gap;i<=L->length;i++)
		{
			if(L->data[i-gap]>L->data[i])//
			{
				L->data[0] = L->data[i];
				j=i;
				for(j=i;j>=1&&L->data[j-gap]>L->data[0];j=j-gap)
				{
					L->data[j] = L->data[j-gap];
				}
				L->data[j] = L->data[0];
			}
		}
		gap = gap/2;
	}
	return L;
}
Seqlist *Select_sort(Seqlist *L)
{             //选择排序
	int i,j,min=L->data[1],jj,k;
	for(i=1;i<=L->length;i++)
	{
		min = L->data[i];
		for (j=i+1;j<=L->length;j++)
		{
			if(min>L->data[j])
				min = L->data[j];
		}
		for (jj=i;jj<=L->length;jj++)
		{
			if(L->data[jj] == min )
			{
				k = jj;
				break;
			}
		}
		L->data[k] = L->data[i];
		L->data[i] = min;
	}
	return L;
}
Seqlist *quik_sort(Seqlist *L,int left,int right)
{     //*****快速排序(递归)
	int i,j;
	if(left<right)	
	{
		int key = L->data[left];
		int low = left;
		int high = right;
		while(low<high)
		{
			while(low<high&&L->data[high]>key)
			{
				high--;
			}
			L->data[low] = L->data[high];
			while(low<high&&L->data[low]<key)
			{
				low++;
			}
			L->data[high] = L->data[low];
		}
		L->data[low] = key;
		quik_sort(L,left,low-1);//知道为什么是L,而不是&L吗？
		quik_sort(L,low+1,right);//
	}
	return L;
}
Seqlist *merge_sort(Seqlist *L,int low,int high)
{//归并排序	
	if(low<high)
	{
		int mid = (low+high)/2;
		merge_sort(L,low,mid);
	    merge_sort(L,mid+1,high);
        merge_sort_zi(L,low,mid,high);
	}
	return L;
}
Seqlist *merge_sort_zi(Seqlist *L,int low,int mid,int high)
{//归并(两个有序表的合并)
	Seqlist *M;
	M = L;
	int i,j,k;
	//printfdata(M); 
	for(i=low,j=high,k=i;i<=mid&&j<=high;k++)
	{
		if(M->data[i]<L->data[j])
			L->data[k] = M->data[i++];
		else
			L->data[k] = M->data[j++];
		while(i<=mid)
			L->data[k++] = M->data[i++];
		while(j<=high)
			L->data[k++] = M->data[j++];
	}
	return L;
}