一、双链表
1.要访问某个结点的前驱结点(插入、删除操作时),只能从头遍历,访问后续结点的时间复杂度O(1),访问前驱结点的时间复杂度O(n)
2.引入双链表,双链表结点中有两个指针prior 和next
3.双链表中的按值查找和按位查找的操作和单链表相同,但双链表在插入和删除操作的实现上,与单链表有较大不同
4.双链表的建立以及初始化
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;
}DNode,*DLinkList;
// 初始化双链表
bool InitDLinkList(InitDList){
L=(DNode *)malloc(sizeof(DNode));
if(L==NULL)
return false;
L->prior = NULL;
L->next=NUll;
return true;
}
//判断双链表是否为空
bool Empty(DLinkList L){
if (L->next == NULL)
return true;
else
return false;
}
int main()
{
DLinkList L;
InitDLinkList(L);
return 0;
}
5.双链表的插入操作
(1)//给结点,前插:在p结点之后插入s结点
bool InserNextDNode(DNode *p,DNode *s){
if(p==NULL|| s== NULL)
return false;
s->next=p->next; ---------①
if(p->next!=NULL)
p->next->prior=s; ----------② 如果p结点之后没有后继,则没有
s->prior = p; -------- ③ 判断的话就会出错
p->next=s; ---------④
return true;
}
注意:1 2步骤必须在4前面
(2)给值,后插
//插入操作-指定结点后插2-给元素值
bool InsertNextDNode2(DNode* p, ElemType e) {
if (p == NULL) //非法参数
return false;
DNode* q = p->next; //q为p原先的后继结点
DNode* s = (DNode*)malloc(sizeof(DNode)); //s为p新的后继结点
if (s == NULL)
return false; //内存不足,分配失败
s->data = e; //为新结点赋值
s->next = q;
if(q!=NULL) //判断q是不是最后一个结点
q->prior = s; //如果是,则跳过此句,因为q为NULL,没有前驱
s->prior = p;
p->next = s;
return true;
}
(3)给定结点前插操作
bool InsertPriorDNode(DNode* p, DNode* s) {
DNode* q = p->prior; //先找到p的前驱结点q
return InsertNextDNode1(q, s); //对q进行后插操作
}
(4)按位前插
bool InsertDLinkList(DLinkList& L, int i, ElemType e) {
DNode* p = GetElem(L, i-1); //按位查找i-1个结点p
return InsertNextDNode2(p, e); //对p结点进行后插操作
}
6.双链表的删除操作
//删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
if(p==NULL) return false;
DNode *q=p->next;
if(q==NULL) return false;
p->next=q->next;
if(q->next!=NULL)
q->next->prior=p;
free(q);
return true;
}
7.链表销毁
//链表销毁
void DestoryList(DLinkList &L){
//循环释放各个数据结点
while(L->next!= NUll){
DeleteNextDNode(L);
free(L);
L=NULL;
}
8.链表遍历
//双链表的遍历
//后向遍历
while(p!=NULL){
p=p->next;
}
//前向遍历
while(p!=NULL){
p=p->prior;
}
//前向遍历(跳过头结点)
while (p->prior!=NULL){
p=p->prior;
}
9.求表长
int Length(DLinkList L) {
int len = 0;
DNode* p = L->next;
while (p != NULL) {
p = p->next;
len++;
}
return len;
}
二、循环链表
1.初始化循环链表以及判断为空
typedef struct DNode{
ElemType data;
struct DNode *next;
}LNode,*LinkList;
// 初始化循环链表
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if(L==NULL)
return false;
L->next=L;
return true;
}
//判断是否为空
bool Empty(LinkList L){
if (L->next ==L)
return true;
else
return false;
}
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
if(p->next==L)
return true;
else
return false;}
2.循环双链表
//初始化空的循环双链表
bool InitDLinkList(DLinkList &L){
L=(DNode *)malloc(sizeof(DNode));
if (L==NULL)
return false;
L->prior=L;
L->next=L;
return true;
}
//判断循环双链表是否为空
bool Empty(DLinkList L){
if (L->next == L)
return true;
else
return false;
}
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p){
if(p->next==L)
return true;
else
return false;
}
1.循环单链表与单链表的区别在于,表中最后一个结点的指针不是NULL,而是改为指向头结点,形成一个环
2.循环单链表的判空条件不是头结点的指针是否为空,而是它是否等于头结点
3.循环单链表的插入、删除、与单链表几乎一致,不同的是表尾操作
4.单链表只能从头结点开始遍历后续结点,但是循环单链表可以从表中任意一个结点开始遍历整个链表。因此有时候对于循环单链表不设头指针而设尾指针,有时候会更加高效。
5.如果设的是头指针,那么对表尾操作需要O(n),设的是尾指针r,r->next表示的是表头,对表头表尾操作只需要O(1)
6.循环双链表,当结点为尾结点,->next= L,当循环双链表为空表,其头结点的prior next都等于L
三、静态链表
1.静态链表借助数组来描述线性表的链式存储结构。
2.需要事先分配一块连续的内存空间
3.每个数据元素4B,每个游标4B(每个结点共8B)设起始地址为addr,e1的存放地址为addr +8*2
4.描述
struct Node{
Elemtype data;
int next;
};
Typedef struct Node SlinkList[MaxSize];
5.课本上的
typedef struct{
Elemtype data;
int next;
}SLinkList[MaxSize];
int main()
{
SLinkList a;
return 0;
}
6.初始化静态链表:把a[0]的next设为-1
7.查找:从头结点出发挨个往后遍历结点O(n)
8.插入位序为i的结点:
①找到一个空结点,存放数据元素
②从头结点出发找到位序为i-1的结点
③修改新结点的next
④修改i-1号结点的next
9.初始化时就把每一个的next设为-2等特定数据
10.优点:增删操作不需要大量移动元素
11.缺点:不能随机存储,只能从头结点开始一次往后查找:容量固定不可变
12.适用场景:
①不支持指针的低级语言
②数据元素数量固定不变的场景(操作系统的文件分配表FAT)