数据结构--线性结构(二)--线性表

一、什么是线性表

线性表：由同类型数据元素构成有序序列的线性结构；

• 表中元素个数称为线性表的长度
• 线性表没有元素时，称为空表
• 表起始位置称表头，表结束位置称表尾

二、线性表的抽象数据类型描述

 三、线性表的顺序存储：利用数组的连续存储空间顺序存放线性表的各元素

线性表的顺序表示：
typedef stuct LNode *List;
struct LNode{
    ElementType Data[Maxsize];
    int last;
};
struct LNode L;
List PtrL;

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

 1.初始化（建立空的顺序表）----MakeEmpty( )

List MakeEmpty( )
{ List PtrL;
 PtrL = (List )malloc( sizeof(struct LNode) );
 PtrL->Last = -1;
 return PtrL;
}

2. 查找----Find( ElementType X, List PtrL )

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.插入（第 i (1≤i≤n+1)个位置上插入一个值为X的新元素)----Insert( ElementType X, int i, List PtrL )

方法：先移动，再插入；

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)

4. 删除（删除表的第 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;
}

四、线性表的链式存储实现

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

线性表的链式表示：
typedef struct LNode *List;
struct LNode{
 ElementType Data;
 List Next;
};
struct Lnode L;
List PtrL;

1.求表长

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

时间性能为 O(n)。

2. 查找

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;
 /* 否则返回空 */
} 

平均时间性能为 O(n)

2）按值查找: Find；

List Find( ElementType X, List PtrL )
{
 List p = PtrL;
 while ( p!=NULL && p->Data != X )
 p = p->Next;
 return p;
} 

3.插入--（在第 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;
 }

4. 删除（删除链表的第 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个元素都是基本的单元素； 广义表中，这些元素不仅可以是单元素也可以是另一个广义表。

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

结构：

例如：

五、多重链表

 多重链表：链表中的节点可能同时隶属于多个链

1. 多重链表中结点的指针域会有多个，如前面例子包含了Next和 SubList两个指针域；
2. 但包含两个指针域的链表并不一定是多重链表，比如在双向链表 不是多重链表。