链表的定义和基本操作

单链表

定义

要表示一个单链表时，只需要声明一个头指针L，指向单链表的第一个节点

LNode *L
//或者
LinkList L

#include <iostream>

using namespace std;
typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkList;

bool InitList(LinkList &L){
    L=(LNode *) malloc(sizeof(LNode));
    if (L==NULL)
        return false;
    L->next=NULL;
    return true;
}

int main() {
    LinkList L;
    InitList(L);
}

插入操作

按位序在第i个位置插入元素时，需要找到第i-1个元素，修改其next指针，指向要插入的元素，然后将该元素的next指针指向下一个元素，时间复杂度O(n)

带头节点：

bool ListInsert(LinkList &L,int i,int e){
    if (i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while (p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if (p==NULL)
        return false;
    LNode *s=(LNode *) malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

当不带头节点的链表插入元素时，需要将头指针指向插入的元素

bool ListInsert(LinkList &L,int i,int 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;
    int j=1;
    p=L;
    while (p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if (p==NULL)
        return false;
    LNode *s=(LNode *) malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

当给定一个新节点，需要将其插入到链表中某节点的后面时

bool InsertNextList(LNode *p,int e){
    if (p==NULL)
        return false;
    LNode *s=(LNode *) malloc(sizeof(LNode));
    if (s==NULL)
        return false;
    s->data=e;
    s->next=p->next;
    p->next=s;
}

当给定一个新节点，需要将其插入到链表中某节点的前面时，由于没有头指针，无法知道该节点的前驱节点，因此先将新节点插入到指定节点的后面，然后交换这两个节点data值即可。

bool InsertPriorList(LNode *p,LNode *s){
    //p节点之前插入节点s
    if (p==NULL||s==NULL)
        return false;
    s->next=p->next;
    p->next=s;
    int temp=p->data;
    p->data=s->data;
    s->data=temp;
    return true;
}

删除操作

按位置删除节点和前面按位置插入节点类似，多了一个释放空间的步骤

bool ListDelete(LinkList &L,int i,int e){
    if (i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while (p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if (p==NULL)
        return false;
    if (p->next==NULL)
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

指定节点删除

bool DeleteNode(LNode *p){
    if (p==NULL)
        return false;
    LNode *q=p->next;
    p->data=p->next->data;
    p->next=q->next;
    free(q);
    return true;
}

查找操作

按位查找，时间复杂度O(n)

LNode * GetElem(LinkList L,int i){
    if (i<0)
        return NULL;
    LNode *p;
    int j=0;
    p=L;
    while (p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    return p;
}

按值查找

LNode * LocateElem(LinkList L,int e){
    LNode *p=L->next;
    while (p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}

单链表的建立

1. 初始化一个单链表
2. 每次取一个数据元素，插入到表尾/表头

尾插法

LinkList List_TailInsert(LinkList &L){
    int x;
    L=(LinkList) malloc(sizeof(LinkList));
    LNode *s,*r=L;
    cin>>x;
    while (x!=9999){
        s=(LNode *) malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        cin>>x;
    }
    r->next=NULL;
    return L;
}

头插法

LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L=(LinkList) malloc(sizeof(LinkList));
    cin>>x;
    while (x!=9999){
        s=(LNode *) malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
    return L;
}

双链表

初始化

#include <iostream>

using namespace std;
typedef struct DNode {
    int data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

bool InitList(DLinkList &L){
    L=(DNode *) malloc(sizeof(DNode));
    if (L==NULL)
        return false;
    L->prior=NULL;
    L->next=NULL;
    return true;
}

int main() {
    DLinkList L;
    InitList(L);
}

插入

后插操作，在节点p之后插入s节点

在插入节点时，要注意先判断p节点是否有后继节点

bool InsertNextNode(DNode *p, DNode *s) {
    if (p == NULL || s == NULL)
        return false;
    s->next = p->next;
    if (p->next != NULL)
        p->next->prior = s;
    p->next = s;
    s->prior = p;
    return true;
}

删除

删除p节点的后继节点q

bool DeleteNextNode(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;
}

如果想销毁一个双链表，只需要一直调用这个函数。

void DestoryList(DLinkList &L){
    while (L->next!=NULL){
        DeleteNextNode(L);
    }
    free(L);
    L=NULL;
}

遍历

//后项遍历
while(p!=NULL){
	p=p->next;
}
//前项遍历
while(p!=NULL){
	p=p->prior;
}

循环链表

循环链表是尾节点的next指针指向头节点的链表，从一个节点出发可以找到任意其他节点。

初始化

在初始循环链表为空时，头节点的next指针指向自己，在判断循环链表是否为空时也是以这个为依据

#include <iostream>

using namespace std;
typedef struct LNode {
    int data;
    struct LNode *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;
}

//是否为尾节点
bool isTail(LinkList L,LNode *p){
    if (p->next==L){
        return true;
    } else
        return false;
}

int main() {
    LinkList L;
    InitList(L);
}