数据结构（链表——双向链表的实现）
Posted The August
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构（链表——双向链表的实现）相关的知识，希望对你有一定的参考价值。
链表——双向链表的实现
链表的概念及结构
概念： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
结构：
链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
带头双向循环链表的介绍（重点）
双向链表的实现
模型
思路（独一份）
双链表的各种方法实现
创建结构体并创建结构体指针变量
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* next;
struct ListNode* prev;
LTDataType data;
}LTNode;
注意：
我们并不知道要存储什么数据,以int为例. 之所以用 LTDataType是为了以后修改int类型或其他类型方便。
实现双向表初始化
LTNode* BuyListNode(LTDataType x)//写一个结点
{
LTNode* new = (LTNode*)malloc(sizeof(LTNode));
if (new == NULL)
{
perror("BuyListNode");
}
new->data = x;
new->next = NULL;
new->prev = NULL;
return new;
}
LTNode* ListInit()//将双向表初始化
{
LTNode* phead = BuyListNode(0);
phead->next = phead;
phead->prev = phead;
return phead;
}
实现双向链表销毁
void ListDestroy(LTNode* phead)
{
assert(phead);
size_t i = ListSize(phead);
while (i--)
{
ListPopBack(phead);
}
//free(phead);
//phead = NULL;
}
ListDestroy(list);
free(list);
list = NULL;
实现双向链表打印
void ListPrint(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\\n");
}
双向链表打印已经没什么可说的了，无非是遍历这里要注意的点是：双向链表实现的是双向带头循环链表，因此当循环指向头结点时循环结束。
实现双向链表在任意位置的前面进行插入
void ListInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* p = pos->prev;
LTNode* new = BuyListNode(x);
p->next = new;
new->prev = p;
new->next = pos;
pos->prev = new;
}
实现双向链表在任意位置进行删除
void ListErase(LTNode* pos)
{
assert(pos);
LTNode* p = pos->prev;
LTNode* n = pos->next;
free(pos);
pos = NULL;
p->next = n;
n->prev = p;
}
实现双向链表的头删和尾删、头插和尾插
注意：双向链表的头删和尾删、头插和尾插的实现时，要注意pos的位置
void ListPopBack(LTNode* phead)
{
assert(phead);
ListErase(phead->prev);
}
void ListPopFront(LTNode* phead)
{
assert(phead);
ListErase(phead->next);
}
void ListPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
ListInsert(phead, x);
}
void ListPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
ListInsert(phead->next, x);
}
实现双向链表查找
经历过上方的增删的实现这个查的实现就相对简单，只需遍历（但注意指针到头结点时停止循环）
LTNode* ListFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (x == cur->data)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
实现双向链表的判空
bool ListEmpty(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
if (cur == phead)
{
return true;
}
else
{
return false;
}
}
实现求双向链表的元素数量
这个是实现方法与双向链表打印相似，都是遍历（但注意指针到头结点时停止循环）
size_t ListSize(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
size_t i = 0;
while (cur != phead)
{
i++;
cur = cur->next;
}
return i;
}
原码
List.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include <stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* next;
struct ListNode* prev;
LTDataType data;
}LTNode;
void ListPrint(LTNode* phead);
LTNode* BuyListNode(LTDataType x);
//void ListInit(LTNode** pphead);
LTNode* ListInit();
void ListDestroy(LTNode* phead);
bool ListEmpty(LTNode* phead);
size_t ListSize(LTNode* phead);
void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);
void ListErase(LTNode* pos);
void ListInsert(LTNode* pos, LTDataType x);
List.c
#include"List.h"
void ListPrint(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\\n");
}
LTNode* BuyListNode(LTDataType x)
{
LTNode* new = (LTNode*)malloc(sizeof(LTNode));
if (new == NULL)
{
perror("BuyListNode");
}
new->data = x;
new->next = NULL;
new->prev = NULL;
return new;
}
LTNode* ListInit()
{
LTNode* phead = BuyListNode(0);
phead->next = phead;
phead->prev = phead;
return phead;
}
bool ListEmpty(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
if (cur == phead)
{
return true;
}
else
{
return false;
}
}
size_t ListSize(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
size_t i = 0;
while (cur != phead)
{
i++;
cur = cur->next;
}
return i;
}
LTNode* ListFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (x == cur->data)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
void ListInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* p = pos->prev;
LTNode* new = BuyListNode(x);
p->next = new;
new->prev = p;
new->next = pos;
pos->prev = new;
}
void ListPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
ListInsert(phead, x);
}
void ListPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
ListInsert(phead->next, x);
}
void ListErase(LTNode* pos)
{
assert(pos);
LTNode* p = pos->prev;
LTNode* n = pos->next;
free(pos);
pos = NULL;
p->next = n;
n->prev = p;
}
void ListPopBack(LTNode* phead)
{
assert(phead);
ListErase(phead->prev);
}
void ListPopFront(LTNode* phead)
{
assert(phead);
ListErase(phead->next);
}
void ListDestroy(LTNode* phead)
{
assert(phead);
size_t i = ListSize(phead);
while (i--)
{
ListPopBack(phead);
}
//free(phead);
//phead = NULL;
}
test.c
#include"List.h"
int main()
{
LTNode* list= ListInit();
ListPushBack(list, 1);
ListPushBack(list, 2);
ListPushBack(list, 3);
ListPushBack(list, 4);
ListPushBack(list, 5);
ListPrint(list);
ListPopBack(list);
ListPrint(list);
ListPopFront(list);
ListPrint(list);
ListDestroy(list);
free(list);
list = NULL;
//ListPrint(list);
return 0;
}
运行结果
终于~结束了
以上是关于数据结构（链表——双向链表的实现）的主要内容，如果未能解决你的问题，请参考以下文章