2-3线性表链式映像 数据结构PPT(课件)

// 顺指针向后查找，直到 p 指向第 i 个元素 // 或 p 为空
if ( !p || j>i )
return ERROR; // 第 i 个元素不存在
e = p->data;
// 取得第 i 个元素
return OK; } // GetElem_L
算法时间复杂度为:
O(ListLength(L))
操作步骤：
一、建立一个“空表”；
二、输入数据元素an， 建立结点并插入；
三、输入数据元素an-1， 建立结点并插入；
an
an an-1
四、依次类推，直至输入a1为止。
void HCreateList_L(LinkList &L, int n) {
// 逆序输入 n 个数据元素，建立带头结点的单链表
if (!p || j > i-1)
return ERROR;
……
// i 大于表长或者小于1
} // LinstInsert_L
算法的时间复杂度为: O(ListLength(L))
s = new LNode; s->data = e; s->next = p->next; return OK;
}
练习：写出表尾插入法建立单链表的算法。
} // HCreateList_L
算法的时间复杂度为: O(Listlength(L))
void TCreateList_L(LinkList &L, int n) {
// 顺序输入 n 个数据元素，建立带头结点的单链表 L = (LinkList) malloc (sizeof (LNode));
本操作为：移动指针，比较 j 和 i .
Status GetElem_L(LinkList L, int i, ElemType &e) { // L是带头结点的链表的头指针，以 e 返回第 i 个元素
p = L->next; j = 1; // p指向第一个结点，j为计数器
while (p && j<i) { p = p->next; ++j; }
L->next = NULL; // 先建立一个带头结点的空单链表
q= L;
// q始终指向表尾结点
for (i =1; i ≤ n ; ++i) { p = (LinkList) malloc (sizeof (LNode)); scanf(&p->data); // 输入元素值 p->next = NULL; q->next = p; // 插入 q=p; // q始终指向表尾结点
2.3 线性表类型的实现 ----链式映象
头指针
头结点
头头线指结性点针表的为指空针表域时为，空
空指针
a1 a2 … ... an ^
以线性表中第一个数据元素 a 1 的存 储地址作为线性表的地址，称作线性表 的头指针。
有时为了操作方便，在第一个结点之前 虚加一个“头结点”，以指向头结点的 指针为链表的头指针。
空”，而是“后继是否为头结点”。
2. 双向链表
typedef struct DuLNode { ElemType data; // 数据域 struct DuLNode *prior; // 指向前驱的指针域 struct DuLNode *next; // 指向后继的指针域
} DuLNode, *DuLinkList;
指向后继的指针。
q = p->next; p->next = q->next;
e = q->data; free(q);
p
q
ai-1
ai
ai+1
Status ListDelete_L(LinkList L, int i, ElemType &e) { // 删除以 L 为头指针(带头结点)的单链表中第 i 个结点
找到线性表中第i-1个结点，然后修改 其指向后继的指针。
Status ListInsert_L(LinkList L, int i, ElemType e) { // L 为带头结点的单链表的头指针，本算法 // 在链表中第i 个结点之前插入新的元素 e p = L; j = 0;
while (p && j < i-1) { p = p->next; ++j; } // 寻找第 i-1 个结点
若在指针p所指结点之前插入结点,如何实现此插入算法？
p
ai-1
ai
e
s s->prior = p-> prior ; p-> prior = s;
s->next =p ; s-> prior ->next = s;
双向链表插入结点时算法有多种，关键是不要断链： 只要不先执行 p-> prior = s 语句 即可。
双向循环链表
空表
非空表
a1
a2 … ... an
双向链表的操作特点：
“查询” 和单链表相同
“插入” 和“删除”时需要同时 修改两个方向上的指针。
插入
p
ai-1
ai
e
s s->next = p->next; p->next = s; s->next->prior = s; s->prior = p;
算法的时间复杂度为: O(ListLength(L))
单链表的生成
链表是一个动态的结构，它不需要 预分配空间，因此生成链表的过程 是一个结点“逐个插入” 的过程。
1、由表头插入：得到逆序 --- 头插法 2、由表尾插入：得到正序 --- 尾插法
例如：逆位序输入 n 个数据元素的值， 建立带头结点的单链表。
1．增加“表长”、“表尾指针” 和 “当前 位置的
2．指将针基”本操三作个中数的据“域位；序 i ”改变为“指针 p ”。
四、其它形式的链表
1. 循环链表
最后一个结点的指针域的指针又指 回第一个结点的链表。
a1 a2 … ... an
和单链表的差别在于，判别链表中最
后一个结点如的条何件判不再空是？“后继是否为
p = L; j = 0; while (p->next && j < i-1) { p = p->next; ++j; }
// 寻找第 i 个结点，并令 p 指向其前趋
if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理
q = p->next; p->next = q->next; // 删除并释放结点 e = q->data; free(q); return OK; } // ListDelete_L
// 生成新结点 p->next = s; // 插入
ai-1
ai
p
e
s
线性表的操作ListDelete (&L, i, &e)
在链表中的实现:
有序对<ai-1, ai> 和 <ai, ai+1> 改变为 <ai-1, ai+1>
ai-1
ai
ai+1
在单链表中删除第 i 个结点的基本操
作为:找到线性表中第i-1个结点，修改其
} //} TCreateList_L
算法的时间复杂度为: O(Listlength(L))
用上述定义的单链表实现线性表的操作时， 存在的问题：
1．单链表的表长是一个隐含的值； 2．在单链表的最后一个元素之后插入元素时，
需遍历整个链表； 3．在链表中，元素的“位序”概念淡化，结点的
“位置”概念加强。 改进链表的设置：
// 生成含 n 个数据元素的链表
线性表的操作
GetElem(L, i, &e)
在单链表中的实现:
L
21 18 30 75 42 56 ∧
pp p
i=3
j 123 j=i,则p->data e
分析：单链表是一种 顺序存取 的结
构，为找第 i 个数据元素，必须先找到 第 i-1 个数据元素。
因此，查找第 i 个数据元素的基
L = (LinkList) malloc (sizeof (LNode));
L->next = NULL; // 先建立一个带头结点的空单链表
for (i = n; i > 0; --i) {
p = (LinkList) malloc (sizeof (LNode)); scanf(&p->data); // 输入元素值 p->next = L->next; L->next = p; // 插入
线性表的操作 ListInsert(&L, i, e)
在单链表中的实现：
有序对 <ai-1, ai> 改变为 <ai-1, e> e
可见，在链表中插入结点只需要修改 指针。但同时，若要在第 i 个结点之前 插入元素，修改的是第 i-1 个结点的指 针。
因此，在单链表中第 i 个结点之前进 行插入的基本操作为:
删除 ai-1
ai
ai+1
p
ai-1
ai
ai+1
p->next = p->next->next; p p
p->next->prior = p;
p->next ->next -> prior = p; p->next = p->next->next;