王道2022-2.2.6
#include<stdio.h>
#include<stdlib.h>
//对应插入的前插与后插两种方法,删除也有头指针遍历法与偷天换日法
//前插与后插区别主要问题出在: p的前驱结点是否为神秘区域 (是否给出头结点)
//前插与后插区别主要表现在于: 平均时间复杂度O(1)与O(n)
//前插与后插区别主要手法比较: 前后正常连接与在正常连接基础上进行数据交换,造成真的进行了前插的假象 (实际新结点是后插的)
typedef int ElemType;
typedef struct LNode {
ElemType data;
struct LNode* next;
}LNode, * LinkList;
//不带头结点的单链表 空表初始化
bool InitList(LinkList& L) {
L = NULL;
return true;
}
//判断链表是否为空
bool Empty(LinkList L) {
return (L == NULL);
}
//带头结点的单链表 空表初始化
bool InitList(LinkList& L) {
L = (LNode*)malloc(sizeof(LNode));
if (L == NULL) { //内存不足,分配失败
return false;
}
L->next = NULL;
return true;
}
//判断链表是否为空
bool Empty(LinkList L) {
if (L->next == NULL) {
return true;
}
else
return false;
}
//返回单链表指定位置结点
LNode* GetElem(LinkList L, int i) {
int j = 1;
LNode* p = L->next;
if (i == 0) {
return L;
}
if (i < 0) {
return NULL;
}
while (j < i && p != NULL) {
p = p->next;
j++;
}
return p;
}
//单链表插入
//按位序插入
//后插:
//在第i个位置插入元素e(带头结点): 最坏时间复杂度O(n) 平均时间复杂度O(n)
bool ListInsert(LinkList& L, int i, ElemType e) {
if (i < 1) { //头结点及其前面序号不可被插入
return false;
}
LNode* p;
int j = 0; //头结点是第0个结点,不储存数据
p = L;
while (j < i - 1 && p != NULL) {
j++;
p = p->next;
}
if (p == NULL) { //i值不合法
return false;
}
LNode* s = (LNode*)malloc(sizeof(LNode));
//一般来说,malloc分配内存,不会出现分配为NULL的情况
//故这里使用s->data,不会出现NULL->data的情况
s->data = e;
//下面两行顺序不能颠倒
s->next = p->next;
p->next = s;
return true;
}
//在第i个位置插入元素e(不带头结点): 最坏时间复杂度O(n) 平均时间复杂度O(n)
bool ListInsert(LinkList L, int i, ElemType e) {
if (i < 1) { //头结点及其前面序号不可被插入
return false;
}
if (i == 1) {
LNode* s = (LNode*)malloc(sizeof(LNode));
s->data = e;
s->next = L;
L = s; //头指针指向新的头结点
return true;
}
LNode* p;
p = L;
int j = 1;
while (j < i - 1 && p != NULL) {
p = p->next;
j++;
}
if (p == NULL) { //i值不合法
return false;
}
LNode* s = (LNode*)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
//前插:
//时间复杂度为O(n)的前插
//已知头结点,从头结点开始遍历至目标位置的结点
//时间复杂度为O(1)的前插
//给定条件:已知目标位置的结点p,在结点p前插入元素e
bool InsertPriorNode(LNode* p, ElemType e) {
if (p == NULL) {
return false;
}
LNode* s = (LNode*)malloc(sizeof(LNode));
if (s == NULL) { //内存分配失败
return false;
}
//核心为接下来的两行:注意,本题目标是时间复杂度为O(1)的前插,
//同时,本题条件将造成,p的前驱结点未知,故p的位置不可以改变,
//解决方法:让p的值转移到p结点新的后继结点s(p的后继可知,故将p的后继赋值给s的后继) 即命令: s->next=p->next;
//同时,将p与s连接 即命令: p->next=s;
//此时,新结点s完全替代了结点p,结点p的值已被安全转移,其值可以转换成目标值,即e
//这样不会干涉到p的前驱,也在链表内添加了新结点
s->next = p->next;
p->next = s; //本行与上一行命令,构建了新结点s的前驱和后继
s->data = p->data;
p->data = e;
//总结:如果函数前驱难以提取,还需要使用前插法,可以使用结点数据域信息交换
}
//王道书:在p结点前插入结点s(不是元素e)
bool InsertPriorNode(LNode* p, LNode* s) {
if (p == NULL || s == NULL) {
return false;
}
s->next = p->next;
p->next = s;
//接下来交换数据域
ElemType temp = p->data;
p->data = s->data;
s->data = temp;
return true;
}
//按位序删除(带头结点):最好时间复杂度O(1) 最坏时间复杂度O(n) 平均时间复杂度O(n)
//删除第i个位置的元素,并用e返回删除元素的值
bool ListDelete(LinkList& L, int i, ElemType& e) {
if (i < 1) {
return false;
}
LNode* p;
int j = 0;
p = L;
while (j < i - 1 || p != NULL) {
p = p->next;
j++;
}
//不可以直接写成:p->next = (p->next)->next;
//因为需要free掉所删除结点的空间,故需要用将该位置数据赋值给一个结点
LNode* q = p->next;
e = q->data; //在下一行链表重新链接前,将目标位置数据域数据提出给e
p->next = q->next; //即p->next = (p->next)->next;
free(q);
return true;
}
//偷天换日法删除目标结点 (类似结点前插) 平均时间复杂度为O(1)
bool ListDelete(LNode* p) {
if (p == NULL) {
return false;
}
//偷天换日核心: 即p的前驱不知,故删除其后,无法将p的前驱与其后继连接,转而删除p的后继q,同时将p与q的数据域交换,用p的位置储存q的数据
//综上所述,此时p的数据从链表消失,并且此时链表少了一个结点
LNode* q = p->next;
p->next = q->next;
p->data = q->data;
free(q);
return true;
}
void test() {
LinkList L; //声明一个指向单链表的指针
InitList(L); //初始化一个空表(分为带头指针与不带头指针两种)
}
int main() {
test();
}