数据结构-线性表-顺序表和单链表的基本操作

//顺序表结点结构体
typedef struct
 {
 	ElemType data[MaxSize];//存放线性表的元素 
 	int length;//存放线性表的长度 
 }SqList;//顺序表的类型

//单链表结点结构体
typedef struct LNode
 {
 	ElemType data;
 	struct LNode *next;
 }LinkNode;

线性表的创建

//顺序表
void CreateList(Sqlist *&L,ElemType a[],int n)//y由a中的n个元素建立顺序表 
 {
 	int i=0,k=0;
 	L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间 
 	while(i<n)
 	{
 		L->data[k]=a[i];
 		k++;
 		i++;
	 }
	L->length=k;

//单链表头插法
 void CreateListF(LinkNode *&L,ElemType a[],int n)
 {
 	LinkNode *s;
 	L=(LinkNode *)malloc(sizeof(LinkNode));
 	L->next=NULL;//头结点

 	for(int i=0;i<n;i++)
 	{
 		s=(LinkNode*)malloc(sizeof(LinkNode));
 		s->data=a[i];
 		
 		s->next=L->next;
		L->next=s;
	 }
 }

//单链表尾插法
 void CreateListR(LinkNode *&L,ElemType a[],int n)
 {
 	LinkNode *s,*tail;
 	L=(LinkNode *)malloc(sizeof(LinkNode));
 	tail=L;
 	for(int i=0;i<n;i++)
 	{
 		s=(LinkNode*)malloc(sizeof(LinkNode));
 		s->data=a[i];
 		s->next=NULL;
 		tail->next=s;
 		tail=s;
	 }
	 r->next=NULL;
 }

 初始化

 //初始化顺序表 
 void InitList(Sqlist *&L)
 {
 	L=(Sqlist *)malloc(sizeof(SqList));
 	L->length=0;
  } 

//初始化线性表
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));
	L->next=NULL;
  }  

 销毁

//销毁顺序表 
void DestoryList(SqList *&L)
{
	free(L);
}


//销毁单链表  双指针法 
void DestoryList(LinkNode *&L)
{
	LinkNode *pre=L,*p=L->next;//pre指向头结点，p指向首结点
	while(p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	 } 
	 free(pre);
 } 

 判断表是否为空

//判断顺序表是否为空 
bool ListEmpty(SqList *L)
{
	return(L->length0==0);
}


//判断单链表是否为空
bool ListEmpty(LinkNode *L)
{
	return(L->next==NULL);
 } 

求表的长度 

//求顺序表的长度 
int ListLength(SqList *L)
{
	return(L->length);
}


//求单链表的长度 
int ListLength(LinkNode *L)
{
	int n=0;
	ListNode *p=L;
	while(p->next!=NULL)
	{
	   n++;
	   p=p->next;
	}
	return(n);
 } 
 

输出表

//输出顺序表 
void DispList(SqList *L)
{
	for(int i=0;i<L->length;i++)
	{
		printf("%d",L->data[i]);
	}
	printf("\n");
}


//输出单链表
void DispList(LinkNode *L)
{
	LinkNode *p=L->next;
	while(p!=NULL)
	{
		printf("%d",p->data);
		p=p->next;
	}
	printf("\n");
 } 

 在表中按序号查找元素

//顺序表按序号来查找元素 
bool GetElem(SqList *L,int i,ElemType &e)
{
	if(i<1||i>L->length)
	{
		return false;
	}
	e=L->data[i-1];
	return true;
}


//单链表按照序号来查找元素
bool GetElem(LinkNode *L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L;
	if(i<=0)return false;
	while(j<i&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
	{
		return false;
	}
	else
	{
		e=p->data;
		return true;
	}
 } 
 

 在表中按元素来查找

//顺序表按元素值来查找元素 
int LocateElem(SqList *L,ElemType e)
{
	int i=0;
	while(i<L->length&&L->data[i]!=e)
	{
		i++;
	}
	if(i>=L->length)
	{
		return 0;
	}
	else return i+1;//找到后返回其逻辑序号 
}


//单链表按元素值来查找元素
int LocateElem(LinkNode *L,ElemType e)
{
	int i=1;
	LinkNode *p=L->next;
	while(p!=NULL&&p->data!=e)
	{
		p=p->next;
		i++;
	}
	if(p==NULL)
	{
		return 0;
	}
	else return i;
 } 
 

向表中插入数据元素 

//顺序表插入数据元素 
bool ListInsert(SqList *&L,int i,ElemType e)
{
	int j;
	if(i<1||i>L->length+1||L->length==Maxsize)
	   return false;
	i--;
	for(j=L->length;j>i;j--)
	{
		L->data[j]=L->data[j-1];
	}
	L->data[i]=e;
	L->length++;
	return true;
 } 


 //单链表插入数据元素
 bool ListInsert(LinkNode *&L,int i,ElemType e)
 {
 	int j=0;
 	LinkNode *p=L,*s;
 	if(i<=0)return false;
 	while(j<i-1&&p!=NULL)
 	{
 		j++;
 		p=p->next;
	 }
	if(p=NULL)
	{
		return false;
	}
	else
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=e;
		s->next=p->next;
		p->next=s;
		return true;
	}
  } 

删除表中的数据元素

//顺序表删除数据元素 
 bool ListDelete(SqList *&L,int i,ElemType &e)
 {
 	int j;
 	if(i<1||i>L->length)
 	{
 		return false;
	 }
	i--;
	e=L->data[i];//?
	for(j=i;j<L->length-1;j++)
	{
		L->data[j]=L->data[j+1];
	}
	L->length--;
	return true;
 }


 //单链表删除数据元素
 bool ListDelete(LinkNode *&L,int i,ElemType &e)
 {
 	int j=0;
 	LinkNode *p=L,*q;
 	if(i<=0)return false;
 	while(j<i-1&&p!=NULL)
 	{
 		j++;
 		p=p->next;
	 }
	if(p==NULL)
	{
		return false;
	}
	else
	{
		q=p->next;
		if(q==NULL)
		{
			return false;
		}
		e=q->data;
		p->next=q->next;
		free(q);
		return true;
	}
  }