ツ【数据结构_线性表】顺序表_单链表

数据结构（C语言）（第2版） 严蔚敏 人民邮电

定义

• 线性表
  由n(n≥0)个数据特性相同的元素构成的有限序列。
• 空表
  n=0
• 数据域+指针域=结点
• 线性链表/单链表
  每个结点只包含一个指针域
• 指针
  p->data = “R”
  (*p).data=“R”

顺序存储表示

//只要确定了存储线性表的起始位置，线性表的任意数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的数据结构。

//----------存储结构
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
	ElemType *elem; // 基地址
	int length; //当前长度
}SqList;

//----------初始化
Status InitList(SqList &L)
{//构造一个空的顺序表L
	L.elem=new ElemType[MAXSIZE];
	if(!L.elem) exit(OVERFLOW);//存储分配失败退出
	L.length=0;
	return OK;
}

//----------取值O(1)
Status GetElem(SqList L,int i,ElemType &e)
{
	if (i<1||i>L.length) return ERROR; //判断i值是否合理
	e=L.elem[i-1];
	return OK;
}

//----------查找O(n)
int LocateElem(SqList L,ElemType e)
//在顺序表L中查找值为e的数据元素，返回其序号
	for(i=0;i<L.length;i++)
		if(L.elem[i]==e) return i+1;
	retun 0;//查找失败
}

//----------插入O(n)
Status ListInsert(SqList &L,int i,ElemType e)
{//在第i个位置之前插入新的元素e，1≤i≤L.length+1
	if((i<1)||(i>L.length+1)) return ERROR;
	if(L.length==MAXSIZE)return ERROR;//当前存储空间已满
	for(j=L.length-1;j>=i-1;j--)
		L.elem[j+1]=L.elem[i];
	L.elem[i-1]=e;
	++L.length;
	return OK;
}

//----------删除O(n)
Status ListDelete(SqLsit &L,int i)
{//删除第i个元素，1≤i≤L.length
	if((i<1)||(i>L.length)) return ERROR;
	for(j=i;j<=L.length-1;j++)
		L.elem[j-1]=L,elem[j];
	--L.length;
	retuen OK;
}

查找的时间复杂度=O（ASL）
//平均查找长度Average Search Length，ASL

顺序表的缺点
1.插入/删除时，移动大量元素
2.长度相对固定的静态特性
3.浪费存储空间

链式存储表示

头指针->头节点->首元结点
头节点的数据域可用于存放该线性表的长度，不计入链表长度
单链表是一种顺序存取的存取结构

//----------存储结构
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;//LinkList为指向结构体LNode的指针类型

//----------初始化
Status InitList(LinkList &L)
{//构造一个空的单链表L
	L=new LNode;//生成新结点作为头结点，用头指针L指向头结点
	L->next=NULL;//头结点指针域置空
	return OK;
}

//----------取值O(n)
Status GetElem(LinkList L,int i,ElemType &e)
{//在带头结点的单链表L中根据序号i获取元素的值，用e返回L中第i个数据元素的值
	p=L->next;j=1;//p指向首元结点，计数器j赋值为1
	while(p&&j<i)
	{
		p=p->next;
		++j;
	}
	if(!p||j>i)return ERROR;
	e=p->data;
	return OK;
}

//-----------查找O(n)
Status *LocateElem(LinkList L,ElemType e)
{//在带头结点的单链表L中查找值为e的元素
	p=L->next;
	while(p&&p->data!=e)
		p=p->next;
	return p;//成功为地址，失败为NULL
}

//----------插入O(n)
Status ListInsert(LinkList &L,int i,ElemType e)
{//在带头结点的单链表L中第i个位置插入值为e的新结点
	p=L;
	j=0;
	while(p&&(j<i-1))
		{p=p->next;++j;}
	if(!p||j>i-1)return ERROR;
	s=new LNode;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return OK;
}

//----------删除O(n)
Status ListDelete(LinkList &L,int i)
{//在带头结点的单链表L中，删除第i个元素
	p=L;
	j=0;
	while((p->next)&&(j<i-1)) //查找第i-1个结点，p指向该结点
		{p=p->next;++j;}
		if(!(p->next)||(j>i-1)) return ERROR;
		q=p->next;//临时保存被删结点地址以备释放
		p->next=q->next;
		delete q;
		return OK;
}

//---------前插法创建单链表O(n)
void CreateList_H(LinkList &L,int n)
{//逆序输入n个元素的值，建立带头结点的链表L
	 L=new LNode;
	 L->next=NULL;
	 for(i=0;i<n;++i)
	 {
	 	p=new LNode;
	 	cin>>p->data;
	 	p->next=L->next;L->next=p;
	 }
}

//----------后插法创建单链表O(n)
void CreateList_R(LinkList &L,int n)
{//正序输入n个元素的值，建立带头结点的单链表L
	L=new LNode;
	L->next=NILL;
	r=L;
	for(i=0;i<n;++i)
	{
		p=new LNode;
		cin>>p->data;
		p->next=NULL;
		r->next=p;//将新结点*p插入尾结点*r之后
		r=p;
	}
}

//为了提高程序的可读性，对同一结构体指针类型起了两个名称：
LinkList 和 LNode *
两者本质上等价。通常用LinkList定于单链表：LinkList L,则L为单链表的头指针
用LNode *定义指向单链表中任意结点的指针变量：LNode *p，则p为指向单链表中某个结点的指针