数据结构复习——第二章：线性表

1.线性表：是由n(n≥0)个数据元素组成的有限序列。

 

2.线性表的基本运算有：

   1）InitList(L),构造空表，即表的初始化；

   2）ListLength(L),求表的结点个数，即表长；

   3）GetNode(L,i),取表中第i个结点，要求1≤i≤ListLength(L)；

   4）LocateNode(L,x)查找L中值为x的结点并返回结点在L中的位置，有多个x则返回首个，没有则返回特殊      值表示查找失败。

   5）InsertList(L,x,i)在表的第i个位置插入值为x的新结点，要求1≤i≤ListLength(L)+1；

   6）DeleteList(L,i)删除表的第i个位置的结点，要求1≤i≤ListLength(L)；

 

3.顺序表：把线性表的结点按逻辑次序存放在一组地址连续的存储单元里。

 

4.顺序表结点的存储地址计算公式：Loc(ai)=Loc(a1)+(i-1)*C；1≤i≤n

 

5.顺序表上的基本运算

 

（1）插入

<pre name="code" class="cpp"><pre name="code" class="cpp">Status ListInsert_Sq(SqList &L, int i, ElemType e){
	if (i<1 || i>L.length + 1) return ERROR;	     //i值不合法
	if (L.length == MAXSIZE) return ERROR;
	//当前存储空间已满     
	for (j = L.length - 1; j >= i - 1; j--)
		L.elem[j + 1] = L.elem[j]; //插入位置及之后的元素后移
	L.elem[i - 1] = e;                  //将新元素e放入第i个位置
	++L.length;		    //表长增1
	return OK;
}

在顺序表上插入要移动表的n/2结点，算法的平均时间复杂度为O(n)。

（2）删除

<pre name="code" class="cpp"><pre name="code" class="cpp">Status ListDelete_Sq(SqList &L,int i,ElemType &e){
   if((i<1)||(i>L.length)) return ERROR;	 //i值不合法
   e=L.elem[i-1];                    //将欲删除的元素保留在e中
  for (j=i;j<=L.length-1;j++)                   
　  　L.elem[j-1]=L.elem[j];  
                                             //被删除元素之后的元素前移  
   --L.length;               	    //表长减1
  return OK;
}

在顺序表上删除要移动表的（n+1）/2结点，算法的平均时间复杂度为O(n)。

 

6.单链表：只有一个链域的链表称单链表。

  在结点中存储结点值和结点的后继结点的地址，data  next  data是数据域，next是指针域。

 （1）建立单链表。时间复杂度为O(n)。

  加头结点的优点：

1）链表第一个位置的操作无需特殊处理；

2）将空表和非空表的处理统一。

 （2）查找运算。时间复杂度为O(n)。

1） 按序号查找。

<pre name="code" class="cpp">Status GetElem(LinkList &L, int i, ElemType &e){
	p = L->next; j = 1;                    //初始化
	while (p&&j<i){
		//向后扫描，直到p指向第i个元素或p为空 
		p = p->next; ++j;
	}
	if (!p || j>i)return ERROR;     //第i个元素不存在 
	e = p->data;         //取第i个元素 
	return OK;
}

2） 按值查找。

LNode *LocateELem(LinkList &L，Elemtype e)
{
	p = L->next;
	while (p &&p->data != e)
		p = p->next;
	return p;
	//返回L中值为e的数据元素的位置，查找失败返回NULL 
}

（3）插入运算。时间复杂度为O(n)。

Status ListInsert_L(LinkList &L, int i, ElemType e){
	p = L;   j = 0;
	while (p&&j<i−1){ p = p->next; ++j; }
	//寻找第i−1个结点 
	if (!p || j>i−1)return ERROR;//i大于表长 + 1或者小于1  
	s = new LNode;			  //生成新结点s 
	s->data = e;      		            //将结点s的数据域置为e 
	s->next = p->next;	   	  //将结点s插入L中 
	p->next = s;
	return OK;
}//ListInsert_L 

（4）删除运算。时间复杂度为O(n)。

Status ListDelete_L(LinkList &L, int i, ElemType &e){
	p = L; j = 0;
	while (p->next &&j<i - 1){
		//寻找第i个结点，并令p指向其前驱 
		p = p->next; ++j;
	}
	if (!(p->next) || j>i - 1) return ERROR; //删除位置不合理 
	q = p->next;           //临时保存被删结点的地址以备释放 
	p->next = q->next; //改变删除结点前驱结点的指针域 
	e = q->data; 	    //保存删除结点的数据域 
	delete q; 	              //释放删除结点的空间 
	return OK;
}//ListDelete_L 

7.循环链表：是一种首尾相连的链表。特点是无需增加存储量，仅对表的链接方式修改使表的处理灵活方便。

8.空循环链表仅由一个自成循环的头结点表示。

9.很多时候表的操作是在表的首尾位置上进行，此时头指针表示的单循环链表就显的不够方便，改用尾指针     rear来表示单循环链表。

  用头指针表示的单循环链表查找开始结点的时间是O(1),查找尾结点的时间是O(n)；

  用尾指针表示的单循环链表查找开始结点和尾结点的时间都是O(1)。

 

10.在结点中增加一个指针域，prior|data|next。形成的链表中有两条不同方向的链称为双链表。

  1) 双链表的前插操作。时间复杂度为O(1)。

Status ListInsert_DuL(DuLinkList &L, int i, ElemType e){
	if (!(p = GetElemP_DuL(L, i))) return ERROR;
	s = new DuLNode;
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return OK;
}

  2) 双链表的删除操作。时间复杂度为O(1)。

Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e){
	if (!(p = GetElemP_DuL(L, i)))     
		return ERROR;
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	delete p;
	return OK;
}

11.顺序表和链表的比较

  1）基于空间的考虑：顺序表的存储空间是静态分配的，链表的存储空间是动态分配的。顺序表的存储密度比链表大。因此，在线性表长度变化不大，易于事先确定时，宜采用顺序表作为存储结构。

  2）基于时间的考虑：顺序表是随机存取结构，若线性表的操作主要是查找，很少有插入、删除操作时，宜用顺序表结构。对频繁进行插入、删除操作的线性表宜采用链表。若操作主要发生在表的首尾时采用尾指针表示的单循环链表。

 

12.存储密度=（结点数据本身所占的存储量）/（整个结点结构所占的存储总量）

存储密度：顺序表=1，链表<1。