1_线性表

一、线性表（Linear List）:由同类型的数据元素构成的有序列的线性结构

•  表中元素个数称为线性表长度。
•  无元素时称为空表。
•  表起始位置为表头，结束位置为表尾。
• 线性表采用链式存储结构，链表来实现，不需要连续的地址空间，便于插入和删除。
• 线性表采用顺序存储结构称为顺序表，需要连续的地址空间，基本上是用数组实现的，使用空间有限，会造成浪费，但是便于随机存取，主要是进行查找，很少做插入和删除操作时顺序表。

顺序表与线性表

•   线性表是逻辑概念，只要所有的数据在逻辑上是一维的都可以认为是线性表。线性表包括顺序表（栈，队列等），链表（栈，队列等）。跟线性表相对的概念应该是树或者堆。
• 顺序表是空间概念，指的是所有的数据在存储空间上顺序排列，而跟具体的操作方式无关。与顺序表相对的概念只有链表。

二、基本操作

1.     List MakeEmpty():初始化一个空线性链表。
2.     ElementType Findkth(int k,List L):返回线性表第K个位置的元素。
3.     int Find(ElementType X,List L):在线性表L中查找X第一次出现的位置。
4.     void Insert（ElementType X,int i,List L）：在位序i前插入一个新元素X。
5.     void Delete(int i,List L):删除第i个位置的元素。
6.     int Length(List L):返回线性表长度。

 

三、存储方式

3_1.利用数组的连续存储空间实现线性表的顺序存储结构

访问下标为 i 的元素：L.Data[i] 或 PtrL->Data[i]
线性表的长度：L.Last+1 或 PtrL->Last+1

 

-3.11初始化（建立空的线性表） 

 

    

List MakeEmpty( )
{ List PtrL; 
PtrL = (List )malloc( sizeof(struct LNode) );//申请地址空间
PtrL->Last = -1;//表空
return PtrL;
}

-3.12查找

int Find( ElementType X, List PtrL )
{ int i = 0;
while( i <= PtrL->Last && PtrL->Data[i]!= X )
i++;
if (i > PtrL->Last) return -1; /* 如果没找到，返回-1 */
else return i; /* 找到后返回的是存储位置 */
}

查找成功的平均比较次数为(n +1)/2，平均时间性能为 O(n)。

-3.13插入（第 i (1≤i≤n+1)个位置上插入一个值为X的新元素)

void Insert( ElementType X, int i, List PtrL )
{ int j;
if ( PtrL->Last == MAXSIZE-1 ){ /* 表空间已满，不能插入*/
printf(＂表满＂);
return;
}
if ( i < 1 || i > PtrL->Last+2) { /*检查插入位置的合法性*/
printf(＂位置不合法＂);
return;
}
for ( j = PtrL->Last; j >= i-1; j-- )
PtrL->Data[j+1] = PtrL->Data[j]; /*将 ai～ an倒序向后移动*/
PtrL->Data[i-1] = X; /*新元素插入*/
PtrL->Last++; /*Last仍指向最后元素*/
return;
}
平均移动次数为 n /2，平均时间性能为 O(n)

-3.14删除（删除表的第 i (1≤i≤n)个位置上的元素)

void Delete( int i, List PtrL )
{ int j;
if( i < 1 || i > PtrL->Last+1 ) { /*检查空表及删除位置的合法性*/
printf (“不存在第%d个元素”, i );
return ;
}
for ( j = i; j <= PtrL->Last; j++ )
PtrL->Data[j-1] = PtrL->Data[j]; /*将 ai+1～ an顺序向前移动*/
PtrL->Last--; /*Last仍指向最后元素*/
return;
}
平均移动次数为 (n-1) /2，平均时间性能为 O(n)

3_2 .线性表的链式存储实现

   不要求逻辑上相邻的两个元素物理上也相邻；通过“链”建立起数据元素之间的逻辑关系。
•插入、删除不需要移动数据元素，只需要修改“链”。

-3_21.初始化

typedef struct LNode *List;
struct LNode{
ElementType Data;
List Next;
};
struct Lnode L;
List PtrL;

-3.22.求表长

int Length ( List PtrL )
{ List p = PtrL; /* p指向表的第一个结点*/
int j = 0;
while ( p ) {
p = p->Next;
j++; /* 当前p指向的是第 j 个结点*/
}
return j;
}

-3.23.查找

（1）按序号查找: FindKth;

List FindKth( int K, List PtrL )
{ List p = PtrL;
int i = 1;
while (p !=NULL && i < K ){
p = p->Next;
i++;
}
if ( i == K ) return p;
/* 找到第K个，返回指针 */
else return NULL;
/* 否则返回空 */
}

（2）按值查找: Find

List Find( ElementType X, List PtrL )
{
List p = PtrL;
while ( p!=NULL && p->Data != X )
p = p->Next;
return p;
}
平均时间性能为 O(n)

-3.24 插入（在第 i-1(1≤i≤n+1)个结点后插入一个值为X的新结点)
（1）先构造一个新结点，用s指向；
（2）再找到链表的第 i-1个结点，用p指向；

（3）然后修改指针，插入结点 ( p之后插入新结点是 s)

List Insert( ElementType X, int i, List PtrL )
{ List p, s;
if ( i == 1 ) { /* 新结点插入在表头 */
s = (List)malloc(sizeof(struct LNode)); /*申请、填装结点*/
s->Data = X;
s->Next = PtrL;
return s; /*返回新表头指针*/
}
p = FindKth( i-1, PtrL ); /* 查找第i-1个结点 */
if ( p == NULL ) { /* 第i-1个不存在，不能插入 */
printf(＂参数i错＂);
return NULL;
}else {
s = (List)malloc(sizeof(struct LNode)); /*申请、填装结点*/
s->Data = X;
s->Next = p->Next; /*新结点插入在第i-1个结点的后面*/
p->Next = s;
return PtrL;
}
}
平均查找次数为 n /2，平均时间性能为 O(n

-3.25删除（删除链表的第 i (1≤i≤n)个位置上的结点)

 （1）先找到链表的第 i-1个结点，用p指向；

（2）再用指针s指向要被删除的结点（p的下一个结点）;
（3）然后修改指针，删除s所指结点;

（4）最后释放s所指结点的空间。

List Delete( int i, List PtrL )
{ List p, s;
if ( i == 1 ) { /* 若要删除的是表的第一个结点 */
s = PtrL; /*s指向第1个结点*/
if (PtrL!=NULL) PtrL = PtrL->Next; /*从链表中删除*/
else return NULL;
free(s); /*释放被删除结点 */
return PtrL;
}
p = FindKth( i-1, PtrL ); /*查找第i-1个结点*/
if ( p == NULL ) {
printf(“第%d个结点不存在”, i-1); return NULL;
} else if ( p->Next == NULL ){
printf(“第%d个结点不存在”, i); return NULL;
} else {
s = p->Next; /*s指向第i个结点*/
p->Next = s->Next; /*从链表中删除*/
free(s); /*释放被删除结点 */
return PtrL;
}
}
平均查找次数为 n /2，平均时间性能为 O(n)

4、广义表(Generalized List)
 广义表是线性表的推广
 对于线性表而言， n个元素都是基本的单元素；

 广义表中，这些元素不仅可以是单元素也可以是另一个广义表。

typedef struct GNode *GList;
struct GNode{
int Tag; /*标志域：0表示结点是单元素，1表示结点是广义表 */
union { /*子表指针域Sublist与单元素数据域Data复用，即共用存储空间*/
ElementType Data;
GList SubList;
} URegion;
GList Next; /* 指向后继结点 */
};

5.多重链表：链表中的节点可能同时隶属于多个链
 多重链表中结点的指针域会有多个，如前面例子包含了Next和SubList两个指针域；
 但包含两个指针域的链表并不一定是多重链表，比如在双向链表不是多重链表。

多重链表有广泛的用途：基本上如树、图这样相对复杂的数据结构都可以采用多重链表方式实现存储。