严蔚敏《数据结构》2.1线性表代码实现

如果帮到了你，请评论一下，谢谢！

#include
#include
#include
#include
#include
#include

#define TRUE 1      //是
#define FALSE 0     //否
#define OK 1  	    //完成
#define ERROR 0	    //错误
#define Warnning 0  //警告
#define FAILED 0    //失败
#define OVERFLOW -2 //内存溢出
/* 上述7个变量本质都一样，只是取个名字方便理解 */

#define LIST_INIT_SIZE 10  	//分配大小

typedef int Order;			//排序方式
typedef int Status;  		//完成状态
typedef int ElemType;		//代表元素
/*  上述三个都是int类型，取个别名方便理解  */

typedef struct
{
	ElemType *Elem;
	int Length;
	int ListSize;
}pList;

Status InitList(pList *L)	
{	//初始化线性表
	// 操作结果：构造一个空的顺序线性表L
	L->Elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);
	if(!L->Elem)
	{
		printf("内存分配请求失败，你脸真的是太黑了！\n");
		exit(OVERFLOW);// 存储分配失败
	}
	L->Length=0;					// 空表长度为0
	L->ListSize=LIST_INIT_SIZE;		// 初始存储容量
	printf("线性表初始化成功！\n");
	return OK;
}

void DestroyList(pList *L)
{	// 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L
	if(L->Elem)
	{	
		free(L->Elem);
		L->Elem=NULL;
		L->Length=NULL;
		L->ListSize=NULL;
		printf("线性表销毁成功！\n");
	}
}

void ClearList(pList *L)
{	// 初始条件：顺序线性表L已存在。操作结果：将L重置为空表
	L->Length=0;
	printf("线性表置空成功！\n");
}

Status ListEmpty(pList *L)
{	// 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
	if(L->Length)
		return TRUE;
	else
		return FALSE;
}

Status ListLength(pList *L)
{	// 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数
	return L->Length;
}

ElemType GetElem(pList *L,int i,ElemType *e)
{	// 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)。操作结果：用e返回L中第i个数据元素的值
	int Len=ListLength(L);
	if(i < 1 || i > Len)
	{
		printf("当前线性表范围为%d，输入范围不在此范围中！\n",Len);
		return Warnning;
	}
	*e=L->Elem[i-1];
	return *e;
}

int LocateElem(pList *L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
   // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
   //           若这样的数据元素不存在，则返回值为0。算法2.6
   ElemType *p;
   int i=1; // i的初值为第1个元素的位序
   p=L->Elem; // p的初值为第1个元素的存储位置
   while(i <= L->Length && !compare(*p++,e))
	 ++i;
   if(i<=L->Length)
	 return i;
   else
	 return 0;
}

ElemType PriorElem(pList *L,ElemType cur_e,ElemType *pre_e)
{  // 初始条件：顺序线性表L已存在
   // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
   //           否则操作失败，pre_e无定义
	int i=2;
	ElemType *p=L->Elem+1;
	while(i < L->Length  && *p != cur_e)
	{
		p++;
		i++;
	}
	if(i > L->Length)
	{
		printf("当前线性表中并无此元素：%d！\n",cur_e);
		return FAILED;
		exit(0);
	}
	else
	{
		*pre_e = *--p;
		return *pre_e;
	}
}

ElemType NextElem(pList *L,ElemType cur_e,ElemType *next_e)
{  // 初始条件：顺序线性表L已存在
   // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
   //           否则操作失败，next_e无定义
	int i=1;
	ElemType *p=L->Elem;
	while(i < L->Length  && *p != cur_e)
	{
		p++;
		i++;
	}
	if(i == L->Length)
	{
		printf("当前线性表中并无此元素：%d！\n",cur_e);
		return FAILED;
		exit(0);
	}
	else
	{
		*next_e = *++p;
		return *next_e;
	}
}

Status InsertList(pList *L,int i,ElemType e)
{  // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
   // 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
	if(i < 1 || i > L->Length+1)
	{
		printf("您要插入的位置不在当前线性表范围！\n");
		return ERROR;
	}
	if(L->Length == L->ListSize) // 当前存储空间已满,增加分配
	{
		ElemType *newbase = (ElemType *)realloc(L->Elem,sizeof(ElemType)*(L->ListSize + LIST_INIT_SIZE));
		if(!newbase)
		{
			printf("内存分配请求失败，你脸真的是太黑了！\n");
			return ERROR;
		}
		L->Elem=newbase;
		L->ListSize += LIST_INIT_SIZE;
	}
	ElemType *q = &(L->Elem[i-1]); //q存储插入位置
	ElemType *p;
	for(p = &(L->Elem[L->Length  - 1]);p >= q; p--)
		*(p+1) = *p;
	*q = e;
	L->Length++;
	return OK;
}

Status DeleteList(pList *L,int i,ElemType *e)
{  // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
   // 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
	if(i < 1 || i > L->Length)
	{
		printf("需要删除的位置不存在！\n");  
		return ERROR;
	}
	ElemType *p = &(L->Elem[i-1]);
	*e = *p;
	ElemType *q=L->Elem + L->Length-1;
	for(p = p + 1;p <= q;p++)
		*(p-1) = *p;
	L->Length--;
	return OK;
}

void TraverseList(pList *L)
{	// 初始条件：顺序线性表L已存在
	// 操作结果：输出线性表所有元素
	int i;
	if(L->Length == 0)
	{
		printf("当前线性表为空！\n");
	}
	else
	{
		printf(	"当前线性表为：");
		for(i = 1; i <= L->Length ; i++)  
			printf("%d ", L->Elem[i-1]);  
		printf("\n");
	}
}

void SortList(pList *L)
{	//选择排序法
	if(L->Length == 0)
	{
		printf("当前线性表为空或不存在，无法排序！\n");
		exit(0);
	}
	Order order;
	printf("请输入排序方式，0表示从小到大排序，1表示从大到小排序：");
	scanf("%d",&order);
	int i,j,tmp,max,min;
	switch (order)
		{
		case 0:	 //从小到大排序
			for(i = 0;i < L->Length-1;i++)
			{
			   min = i;
			   for(j = i;j < L->Length;j++)
			   {
				   if(L->Elem[min] > L->Elem[j])
					   min = j;
			   }
			   tmp = L->Elem[i];
			   L->Elem[i] = L->Elem[min];
			   L->Elem[min] = tmp;
			}
			break;
		case 1:	 //从大到小排序
			for(i = 0;i < L->Length-1;i++)
			{
			   max = i;
			   for(j = i;j < L->Length;j++)
			   {
				   if(L->Elem[max] < L->Elem[j])
					   max = j;
			   }
			   tmp = L->Elem[i];
			   L->Elem[i] = L->Elem[max];
			   L->Elem[max] = tmp;
			}
			break;
		default:
			break;
		}
	
}

void InvertList(pList *L)  
{  	//前后倒置
	int i,j,k=L->Length,tmp;
	for(i=0,j=k-1;iElem[i];
		L->Elem[i]=L->Elem[j];
		L->Elem[j]=tmp;
	}
}

void Init()
{	//初始化函数
	printf("输入数字以完成操作\n");
	printf("初始化线性表：1\n");
	printf("销毁线性表：2\n");
	printf("置空线性表：3\n");
	printf("判断是否为空：4\n");
	printf("返回线性表长度：5\n");
	printf("获取第i个值：6\n");
	printf("数据元素判定：7\n");
	printf("获取某元素的前驱：8\n");
	printf("获取某元素的后继：9\n");
	printf("在第i个位置插入元素：10\n");
	printf("删除第i个位置的元素：11\n");
	printf("遍历输出当前线性表：12\n");
	printf("排序当前线性表：13\n");
	printf("倒置当前线性表：14\n");
	printf("退出：0\n");
}

int main(void)
{
	pList L;
	ElemType e; //e表示元素，用来存储对线性表操作的元素
	int i;      //i表示对线性表操作的位置
	srand((unsigned int)time(NULL));  //用于产生随机数，此句话加上可使每次产生的随机数都不一样

	Init();
	int j=1;	//j指示进行哪一种操作

	while(j!=0)
	  {
		  scanf("%d",&j);
		  switch (j)
		  {
		  case 0:
			  exit(0);
			  break;
		  case 1:
			  if(InitList(&L))
			  {
				  printf("开始赋值\n");
				  for(i=1;i<=8;++i)
				  {
					  e=rand()%100+1;
					  InsertList(&L,i,e);
				  }
				  TraverseList(&L);
			  }
				break;
		  case 2:
			  DestroyList(&L);
			  TraverseList(&L);
			  break;
		  case 3:
			  ClearList(&L);
			  TraverseList(&L);
			  break;
		  case 4:
			  if(ListEmpty(&L) == 0)
				  printf("当前线性表为空！\n");
			  else
			  {
				  printf("当前线性表不为空！\n");
				  TraverseList(&L);
			  }
				  break;
		  case 5:
			  i=ListLength(&L);
			  printf("当前线性表长度为%d\n",i);
			  break;
		  case 6:
			  printf("请输入获取第几个元素的值：");
			  scanf("%d",&i);
			  e=GetElem(&L,i,&e);
			  printf("第%d个元素是：%d\n",i,e);
			  break;
		  case 7:
			  printf("我还不知道这个函数啥意思呢，compare我也不知道是什么，你如果知道告诉下我！\n");
			  break;
		  case 8:
			  printf("请输入要获取哪个元素的前驱：");
			  scanf("%d",&i);
			  e=PriorElem(&L,i,&e);
			  printf("第%d个元素的前驱是：%d\n",i,e);
			  break;
		  case 9:
			  printf("请输入要获取哪个元素的后继：");
			  scanf("%d",&i);
			  e=NextElem(&L,i,&e);
			  printf("第%d个元素的后继是：%d\n",i,e);
			  break;
		  case 10:
			  printf("请输入要插入的位置及值：");
			  scanf("%d %d",&i,&e);
			  InsertList(&L,i,e);
			  TraverseList(&L);
			  break;
		  case 11:
			  printf("请输入要删除第几个元素：");
			  scanf("%d",&i);
			  DeleteList(&L,i,&e);
			  printf("删除的元素都是:%d\n",e);
			  break;
		  case 12:
			  TraverseList(&L);
			  break;
		  case 13:
			  SortList(&L);
			  TraverseList(&L);
			  break;
		  case 14:
			  InvertList(&L);
			  TraverseList(&L);
			  break;
		  default:
			  break;
		  }
	  }
	return 0;
}