五双向链表

Posted 2021-05-21 Alone0710

1. 改进

1.单链表的局限：
单链表的结点都只有一个指向下一个结点的指针
单链表的数据元素无法直接访问其前驱元素
2.双向链表的定义：
在单链表的结点中增加一个指向前驱的pre指针

1.1 插入操作

1.2 删除操作

2. 语言描述

#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
    DLinkListNode* next;
    DLinkListNode* pre;
};

DLinkList* DLinkList_Create();

void DLinkList_Destroy(DLinkList* list);

void DLinkList_Clear(DLinkList* list);

int DLinkList_Length(DLinkList* list);

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);

DLinkListNode* DLinkList_Reset(DLinkList* list);

DLinkListNode* DLinkList_Current(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

#endif

#include <stdio.h>
#include <malloc.h>
#include "DLinkList.h"

typedef struct _tag_DLinkList
{
    DLinkListNode header;
    DLinkListNode* slider;
    int length;
} TDLinkList;


DLinkList* DLinkList_Create() // O(1)
{
    TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));

    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->header.pre = NULL;
        ret->slider = NULL;
    }

    return ret;
}

void DLinkList_Destroy(DLinkList* list) // O(1)
{
    free(list);
}

void DLinkList_Clear(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;

    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->header.pre = NULL;
        sList->slider = NULL;
    }
}

int DLinkList_Length(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->length;
    }

    return ret;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;

    if( ret )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;

        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }

        next = current->next;

        current->next = node;
        node->next = next;

        if( next != NULL )
        {
            next->pre = node;
        }

        node->pre = current;

        if( sList->length == 0 )//如果第一次插入，前面没有结点pre为NULL
        {
            node->pre = NULL;
            sList->slider = node;
        }

        sList->length++;
    }

    return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
    }

    return ret;
}

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
        next = ret->next;

        current->next = next;

        if( next != NULL )
        {
            next->pre = current;

            if( current == (DLinkListNode*)sList )
            {
                next->pre = NULL;
            }
        }

        if( sList->slider == ret )
        {
            sList->slider = next;
        }

        sList->length--;
    }

    return ret;
}

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;

    if( sList != NULL )
    {
        DLinkListNode* current = (DLinkListNode*)sList;

        for(i=0; i<sList->length; i++)
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }

            current = current->next;
        }

        if( ret != NULL )
        {
            DLinkList_Delete(sList, i);
        }
    }

    return ret;
}

DLinkListNode* DLinkList_Reset(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;

    if( sList != NULL )
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }

    return ret;
}

DLinkListNode* DLinkList_Current(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;

    if( sList != NULL )
    {
        ret = sList->slider;
    }

    return ret;
}

DLinkListNode* DLinkList_Next(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;

    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }

    return ret;
}

DLinkListNode* DLinkList_Pre(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;

    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->pre;
    }

    return ret;
}

插入第一个元素：

测试：

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

struct Value
{
    DLinkListNode header;
    int v;
};
int main()
{
    int i=0;
    DLinkList* list = DLinkList_Create();
    struct Value* pv = NULL;

    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;

    v1.v=1;
    v2.v=2;
    v3.v=3;
    v4.v=4;
    v5.v=5;

    DLinkList_Insert(list,(DLinkListNode*)&v1,DLinkList_Length(list));
    DLinkList_Insert(list,(DLinkListNode*)&v2,DLinkList_Length(list));
    DLinkList_Insert(list,(DLinkListNode*)&v3,DLinkList_Length(list));
    DLinkList_Insert(list,(DLinkListNode*)&v4,DLinkList_Length(list));
    DLinkList_Insert(list,(DLinkListNode*)&v5,DLinkList_Length(list));

    for(i=0;i<DLinkList_Length(list);i++)
    {
        pv = (struct Value*)DLinkList_Get(list,i);

        printf("%d\\n",pv->v);
    }

    printf("\\n");

    DLinkList_Delete(list,DLinkList_Length(list)-1);
    DLinkList_Delete(list,0);

    for(i=0;i<DLinkList_Length(list);i++)
    {
        pv = (struct Value*)DLinkList_Get(list,i);

        printf("%d\\n",pv->v);
    }

    printf("\\n");

    DLinkList_Reset(list);
    DLinkList_Next(list);

    pv = (struct Value*)DLinkList_Current(list);

    printf("%d\\n",pv->v);

    DLinkList_DeleteNode(list,(DLinkListNode*)pv);

    pv = (struct Value*)DLinkList_Current(list);

    printf("%d\\n",pv->v);

    DLinkList_Pre(list);

    pv = (struct Value*)DLinkList_Current(list);

    printf("%d\\n",pv->v);

    printf("Length: %d\\n",DLinkList_Length(list));


    DLinkList_Destroy(list);

    return 0;
}

3. 小结

双向链表在单链表的基础上增加了指向前驱的指针。
功能上双向链表可以完全取代单链表的使用。
循环链表的Next，pre和Current操作可以高效的遍历链表的中的所有元素。

进阶剖析有C语言复习指针专题
柔性数组，边界对齐等知识点可以回过头看看