数据结构笔记（1）线性表

2.1线性表的定义及特点

线性结构： 一个数据元素的有序(次序)序列。
基本特点：

• 存在唯一的一个被称作“第一个”的数据元素；
• 存在唯一的一个被称作“最后一个”的数据元素；
• 除第一个之外，集合中的每个数据元素均只有一个前驱；
• 除最后一个之外，集合中的每个数据元素均只有一个后继

线性结构包括：线性表，栈，队列，串，数组，广义表

线性表是n个数据元素的有限序列。
基本概念：

2.2案例引入

案例2.1 一元多项式的运算
Pn(x)=p0 + p1x + p2x2 + … + pnxn

将n+1个系数抽象为n+1个元素组成的有序序列，用线性表表示，指数隐含在系数的序号中，即表中第1—n+1项分别对应x0—xn项的系数。

案例2.2 稀疏多项式的运算
S(x)=1+3x10000+2x20000
将非零项的系数和指数抽象为线性表，表中每个元素为(系数，指数)。
案例2.3 图书信息管理系统
将图书表抽象成线性表，图书信息即为数据元素。

2.3线性表的类型定义

//抽象数据类型线性表的定义
ADT List{
	数据对象：D={ai|ai∈ElemSet, i=1,2,…,n, n≥0}
	数据关系：R={<ai-1, ai >| ai-1, ai ∈D, i=2,…,n}
	基本操作：
		InitList(&L)	//初始化结构
		  操作结果：构造一个空的线性表L。
		DestroyList(&L)		//销毁结构
		  初始条件：线性表L已存在。
		  操作结果：销毁线性表L。
		ListEmpty(L)	//判断线性表是否为空
  		  初始条件：线性表L已存在。
  		  操作结果：若L为空表，则返回TRUE，否则返回FALSE。
	    ListLength(L)	//求线性表中数据元素个数
 		  初始条件：线性表L已存在。
 		  操作结果：返回L中数据元素的个数。
		GetElem(L, i, &e)	//求线性表中指定位置元素
  		  初始条件：线性表L已存在, 1≤i ≤ ListLength(L) 。
	      操作结果：用e返回L中第i个数据元素的值。
	    LocateElem(L, e, compare())	//判断指定元素在线性表中的位序
		  初始条件：线性表L已存在，compare()是数据元素判定函数。
 		  操作结果：返回L中第1个与e满足compare( )的数据元素的位序。若这样的元素不存在，则返回值为0。
		PriorElem(L, cur_e, &pre_e )	//返回指定元素在线性表中的前驱
 	      初始条件：线性表L已存在。
  		  操作结果：若cur_e是L中的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
  		 NextElem(L, cur_e, &next_e)	//返回指定元素在线性表中的后继
		  初始条件：线性表L已存在。
		  操作结果：若cur_e是L中的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义。
		ListTraverse(L, visit( ))	//遍历线性表
  	   	  初始条件：线性表L已存在。
  		  操作结果：依次对L中的每个数据元素调用函数visit( )。一旦visit( )失败，则操作失败。
		/* 以上除了初始化和销毁操作其他都是引用型操作 */

		ClearList(&L) 	//清空线性表
		  初始条件：线性表L已存在。
 		  操作结果：将L重置为空表。
		ListInsert(&L, i, e)	//在线性表的指定位置前插入新的元素
	      初始条件：线性表L已存在，1≤i≤Listlength(L)+1。
          操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。
	   ListDelete(&L, i, &e)	//删除线性表指定位置上的元素
  		  初始条件：线性表L已存在且非空，1≤i≤Listlength(L)。
		  操作结果：删除L中第i个数据元素，并用e返回其值，L的长度减1。
		  /* 以上是加工型操作 */
		  
}ADT  List

2.4 线性表的顺序表示和实现

2.4.1 线性表的顺序存储表示

顺序表的存储结构
#define  MAXSIZE	100 //顺序表的最大容量
typedef  struct{
	ElemType  *elem;	//顺序表在内存的基址
	            int 	length;	//当前顺序表的长度，即表中存放元素的个数
}SqList;	//顺序表的结构类型名为SqList

2.4.2 顺序表中基本操作的实现★

1. 初始化：创建一个空的顺序表
Status  InitList(SqList &L) {	//构造一个空的顺序表L
	L.elem=new ElemType[MAXSIZE];
	if(!L.elem) exit(OVERFLOW);	//分配失败
	L.length=0;	//空表长度为0
	return OK;
} //InitList

2. 取值：获取表中第i个数据元素的值
Status GetElem(SqList L, int i, ElemType &e){
 //若i<1或i大于表长，返回ERROR；否则用e返回第i个元素的值，并返回OK
 if(i<1||i>L.length) return ERROR; //i值不合法，返回ERROR
 e=L.elem[i-1]; //将第i个元素值赋给e
 return OK;
}//GetElem

基本操作：元素的赋值
赋值次数：1
时间复杂度：O(1)

*修改：将表中第i个数据元素的值改为指定值
status ModifyElem(SqList &L, int i, ElemType e){
 //在顺序表L中修改第i个元素，且1≤i≤ListLength_Sq(L)
 if(i<1||i>L.length) return ERROR; //i值不合法，返回ERROR
 *(L.elem+i-1) =e; //将指定元素值赋给第i个元素
 return OK;
}//ModifyElem

基本操作：元素的赋值
赋值次数：1
时间复杂度：O(1)

3. 查找：查找指定元素e
int LocateElem(SqList L, ElemType e){
 //在顺序表L中查找第1个值与e相等的元素的位序，若找到，返回其在L中的位序，否则返回0。
	for(i=0;i<L.length;i++) if(e==L.elem[i])  return i+1;
	return 0;
} //LocateElem

基本操作：元素的比较
最坏情况下比较的次数：n
平均比较次数：(n+1)/2
时间复杂度：O(n)

4. 插入：将指定元素e插入到指定位置
   操作特点：插入位置后面的元素均需前后移一个位置
   合法的插入位置：1≤i≤ListLength(L)+1
   Status  ListInsert ( SqList &L, int i, ElemType e) {
//在顺序表L的第i个位置插入新的数据元素e，且1≤i≤ListLength(L)+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[j];   //插入位置及其后的元素后移
	L.elem[i-1]=e;	//插入元素e
	L.length++；		//表长加1
	return OK；
} //ListInsert

基本操作：元素的移动
最坏情况下移动的次数：n
平均移动次数：2/n
时间复杂度：O(n)

5. 删除：将指定位置元素e删除
   操作特点：插入位置后面的元素均需前移一个位置
   合法的删除位置：1≤i≤ListLength(L)
Status  ListDelete(SqList &L, int i) {
//在顺序表L中删除第i个元素并用e返回其值，且1≤i≤ListLength_Sq(L)
	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; 	//表长减1
	return OK；
} //ListDelete

基本操作：元素的移动
最坏情况下的移动次数：n-1
平均移动次数：(n-1)/2
时间复杂度：O(n)