循环双向链表

循环双向链表

1、简介

​ 单链表，总是从头到尾找结点，难道就不可以正反遍历都可以吗?当然可以，只不过需要加点东西而已。

​ 有了 next 指针，这就使得我们要查找下 结点的时同复杂度为 (1) 。可是如果我们要查找的是上一结点的话，那最坏的时间复杂度就是 O(n)了，因 为我们每次都要从头开始遍历查找。

2、循环双向链表是什么样子呢?

​ 双向链表是在单链表的每个结点中，再设 一个指向其前驱结点的指针 。所以在双向链表中的结点都有两个指针域，一个指向直接后继，另一个指向直接前驱。

typedef struct DulNode
{
    int data;
    struct DulNode *prior;
    struct DulNode *next;
} DulNode, *DulList;

3、创建n个元素的循环双向链表

/* 创建n元素的新结点 */
DulList createDulList(DulList *L, int n)
{
    DulList p, s;
    (*L) = (DulList)malloc(sizeof(DulNode));
    p = (*L);

    for (int i = 1; i <= n; i++)
    {
        s = (DulList)malloc(sizeof(DulNode));
        s->data = i;

        p->next = s;
        s->prior = p;
        p = s;
    }
    //跟单链表的创建条件一样，只不过这两条是收尾工作
    p->next = (*L);//最后一个结点的next指针指向了头结点
    (*L)->prior = p;//头结点的prior指针指向了最后一个结点
}

4、插入元素操作

/* 循环双向链表插入操作 找到待插入位置i的前一个结点，注意p的赋值*/
int DulInsert(DulList *L, int i, int e)
{
    DulList p = (*L), s;
    int j = 1;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }

    if (!p || j > i)
        return ERROR;

    s = (DulList)malloc(sizeof(DulNode));
    s->data = e;

    s->prior = p;   // 1 一般按照如图的顺序不会错的，当然 1 2 也可以换顺序
    s->next = p->next;// 2 如图 
    p->next->prior = s;// 3 如图
    p->next = s;// 4 只要在 2 3 之后就行，这一步会改变p->next的值;

    return OK;
}

5、删除操作

/* 循环双向链表删除操作 找到待删除位置i的结点，注意p的赋值*/
int DulDelete(DulList *L, int i, int *e)
{
    DulList p = (*L)->next;
    int j = 1;
    while ((p->next) != (*L) && j < i)//当找到最后一个结点时，停止遍历
    {
        p = p->next;
        j++;
    }

    if (!p || j > i) //p 不为空
        return ERROR;

    p->prior->next = p->next; // 1
    p->next->prior = p->prior; // 2
    
    *e = p->data;
    free(p);

    return OK;
}

总代码展示

主要是自己慢慢debug

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct DulNode
{
    int data;
    struct DulNode *prior;
    struct DulNode *next;
} DulNode, *DulList;

DulList createDulList(DulList *L, int n);
int DulInsert(DulList *L, int i, int e);
int DulDelete(DulList *L, int i, int *e);
int DulLength(DulList L);
void traverse(DulList L);

/* 创建n元素的新结点 */
DulList createDulList(DulList *L, int n)
{
    DulList p, s;
    (*L) = (DulList)malloc(sizeof(DulNode));
    p = (*L);

    for (int i = 1; i <= n; i++)
    {
        s = (DulList)malloc(sizeof(DulNode));
        s->data = i;

        p->next = s;
        s->prior = p;
        p = s;
    }
    //跟单链表的创建条件一样，只不过这两条是收尾工作
    p->next = (*L);//最后一个结点的next指针指向了头结点
    (*L)->prior = p;//头结点的prior指针指向了最后一个结点
}

/* 循环双向链表插入操作 找到待插入位置i的前一个结点，注意p的赋值*/
int DulInsert(DulList *L, int i, int e)
{
    DulList p = (*L), s;
    int j = 1;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }

    if (!p || j > i)
        return ERROR;

    s = (DulList)malloc(sizeof(DulNode));
    s->data = e;

    s->prior = p;   // 1 一般按照如图的顺序不会错的，当然 1 2 也可以换顺序
    s->next = p->next;// 2 如图 
    p->next->prior = s;// 3 如图
    p->next = s;// 4 只要在 2 3 之后就行，这一步会改变p->next的值;

    return OK;
}


/* 循环双向链表删除操作 找到待删除位置i的结点，注意p的赋值*/
int DulDelete(DulList *L, int i, int *e)
{
    DulList p = (*L)->next;
    int j = 1;
    while ((p->next) != (*L) && j < i)//当找到最后一个结点时，停止遍历
    {
        p = p->next;
        j++;
    }

    if (!p || j > i) //p 不为空
        return ERROR;

    p->prior->next = p->next; // 1
    p->next->prior = p->prior; // 2
    
    *e = p->data;
    free(p);

    return OK;
}

/* 循环双向链表求长度 */
int DulLength(DulList L)
{
    int i = 0;
    DulList p = L->next;

    while (p != L)
    {
        i++;
        p = p->next;
    }
    return i;
}

/* 循环双向链表遍历 */
void traverse(DulList L)
{
    DulList p = L->next;
    while (p != L)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    DulList L;
    int e;
    createDulList(&L, 2);
    traverse(L);

    DulInsert(&L, 2, 22);
    traverse(L);

    // DulDelete(&L, 2, &e);
    // traverse(L);

    return 0;
}