线性表的链式表示和实现解析

头结点 复习：
a1
a2
p 结点
… ...
an ^
p 指针和 p 结点的区别： L是带头结点的链表的头指针，即L指向头结点，p为指针变 量，写出语句 p指向头结点： p指向第一个结点： p指向p结点的下一个结点： p=L p=L->next p=p->next
头指针
L
空指针
头结点
a1
a2
… ...
P=L; while (P!= NULL ) p=p->next; p=NULL
改进的 ClearList(L) :
p
L
///
…
^
void ClearList(LinkList L) { while (L->next) { p=L->next;
int LListlen(LinkList L ) { n=0; p=L ; while ( p->next ) { p=p->next; L->next=p->next; n++; } free(p) ; 算法时间复杂度： return n; } } } // ClearList O(ListLength(L))
Typedef struct LNode {ElemType data; // 数据域 struct Lnode *next; // 指针域 } LNode, *LinkList;
// LNode 为结构变量类型名, LinkList 为结构指针类型名 LinkList p；// p 为指针变量, 分配给 p 一个指针变量; p = (LinkList) malloc (sizeof (LNode)); p 或 p = (LNode*) malloc (sizeof (LNode));
2.3 线性表的链式表示和实现 顺序存储 优点：可随机存取 缺点：作插入和删除时，需移动大量元素
2.3.1 线性链表(单链表) 一. 单链表的概念 二、结点和单链表的 C 语言描述 三、线性表的操作在单链表中的实现 2.3.2 循环链表 2.3.3 双向链表
2.3.1 线性链表(单链表) 一. 单链表的概念
复习：数据结构在计算机中的表示(或映象)包括 “数据元素”的映象和“数据元素的关系”的映象。 用一组地址任意的存储单元(可连续可不连续) 存放线性表中的数据元素。 以 数据元素+ 指针(指示后继元素存储位置) = 结点 表示 数据元素的存储映象； n个结点链结成一个链表即为线性表的链式存储
结构。 若每个结点只包含一个指针域，则称为 （ 线性链表 ）或 ( 单链表 )。
//直到p 指向第i-1个元素或p ->next为空
if (!( p->next ) || j > i-1 ) // i 大于表长或者小于1 return ERROR; // 删除位置不合理 q = p->next; p->next = q->next; // 删除q结点 *e = q->data; free(q); // 释放q结点
while (p && j < i-1) { p = p->next; ++j; }
if (!p || j > i-1)
// p 为空 ( i 大于表长+1)或者 i 小于1
return ERROR; s = (LinkList) malloc ( sizeof (LNode)); s->data = e; s->next = p->next; p->next = s; return OK; } // ListInsert_L (算法2.9)
所以算法2.8中有一条语句
if ( !p || j>i ) return ERROR; //第i个元素不存在
三、单链表操作的实现
GetElem(L, i, *e) // 取第i个数据元素 ListInsert(L, i, e) // 插入数据元素 ListDelete(L, i, e) // 删除数据元素 ClearList(L) // 重置线性表为空表 CreateList(L, n)
头指针
头结点
线性表为空表时， 头指针 头结点的指针域为空
空指针


a1
a2
图2.7
… ...
an ^
以线性表中第一个数据元素a1的存储地址作为线 性表的地址，称作线性表的头指针。 有时为了算法简单，在第一个结点之前增加一个 “头结点”，以指向头结点的指针为链表的头指针。
二、结点和单链表的 C 语言描述
算法的时间复杂度为: O(ListLength(L))
线性表的操作ListDelete (L, i, e)在链表中的实现: 在单链表中删除第 i 个结点的基本操作为: 1.找到线性表中第i-1个结点: p = L; j=0; while (p->next&& j < i-1) { p = p->next; ++j; }
二、输入数据元素an， 建立 p 结点并插入； p->next = L->next; L->next = p; 三、输入数据元素an-1， 建立 p 结点并插入； p->next = L->next; L->next = p; 四、依次类推，直至输入a1为止。 从 n 到 1 循环 n 次,可用 for 循环。
建立一个单链表。 逆序输入建立单链表分析: 1.建立一个空表(只有一个头结点)； 2. i = n 到 1 { 输入 第i 个数据; 申请一个新结点并存放第 i 个数据值; 把该结点插入在头结点后; }
逆序输入 n 个数据元素的值， 建立带头结点的单链表。
操作步骤：
一、建立一个“空表”； L = (LinkList) malloc (sizeof (LNode)); L->next = NULL;
4. 插入: s->next = p->next; p->next = s;
ai-1 p
S
ai e
Status ListInsert_L(LinkList L, int i, ElemType e) { // L 为带头结点的单链表的头指针，本算法在链表中第i 个结点
// 之前插入新的元素 e
p = L; j = 0;
// 顺指针向后查找,直到p 指向第i个元素或p 为空
if ( !p || j > i ) return ERROR;
//第i个元素不存在,i太大 *e=p->data // 第i个元素赋给 e
return OK; } // GetElem_L(算法2.8)
问：若为顺序存储，如何实现？ 只有一条语句：e = L.elem[i-1]
// 用p 指针申请一个 p 结点;
访问 p 结点内容
(*p).data , (*p).next 或 p->data , p->next
data next
A
LNode A;
//A为结点变量,分配给 A一个结点;
访问A 结点内容 A.data , A.next
data next
头指针
L
p
p 指针
空指针
while (p && j<i) { p = p->next; ++j; }
// 顺指针向后查找,直到p 指向第i个元素或p 为空
if ( !p) return ERROR;
*e=p->data
//第i个元素不存在,i太大
// 第i个元素赋给 e
return OK; } // GetElem_L
线性表的操作 ListInsert(L, i, e)在单链表中的实现： 在带头单链表中第 i 个结点之前进行插入的基本操作为:
// 顺指针向后查找,直到p 指向第 i 个元素或p 为空
while ( p && j < i-1 ) { p = p->next; ++j; }
//直到p 指向第i-1个元素或p 为空
while (p->next && j < i-1) { p = p->next; ++j; }
//直到p 指向第i-1个元素或p ->next为空
an ^
p
遍历单链表： P=L; while (P->next != NULL )
p=p->next; p 指针指向最后一个结点。 问循环结束时p 指针指向？
头指针
L
头结点
p
空指针
a1
a2
… ...
an ^
找单链表第 i 个结点: (1 <= i <=表长） P=L->next; j= 1; // p指向第一个结点，j为计数变量 while (P!= NULL && j < i ) { p=p->next; ++j ; } 有两种情况: (1) i < 1时没有循环，此时 j > i ; (2) i > 表长， 循环结束时 p=NULL ；或 !p;
算法2.8 j 的初值为1, 算法2.9和算法2.10 j 的初值为0 .
操作 ClearList(L) (重置L为空表)在链表中的实现: p
L
///
…
^
void ClearList(LinkList L) //将单链表L重新置为一个空表 { p = L->next ; L->next =NULL; while ( p ) { q = p->next; free( p ) ; p=q; } } // ClearList