双向列表（C语言版）

最新推荐文章于 2023-03-07 16:12:46 发布
最新推荐文章于 2023-03-07 16:12:46 发布
阅读量748 收藏 1
点赞数
分类专栏： c 文章标签： c 双向列表

双向链表

大神的基操

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

typedef struct NodeTag Node;
typedef struct LinkedListTag LinkedList;

struct NodeTag
{
 Node* prev;
 Node* next;
 void* data;
};

struct LinkedListTag
{
 Node* head;
 Node* tail;
 Node* cur;
 int size;
};

// 创建一个链表 成功返回该链表的指针 否则返回NULL
LinkedList* Create( void )
{
 // 创建一个新节点
 LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));
 // 创建不成功，返回NULL
 if(!list) return NULL;
 
 list->head = NULL;
 list->tail = NULL;
 list->cur  = NULL;
 list->size = 0;
 
 // 初始化成功后，返回list
 return list;
}

// 将元素添加到链表的末尾，成功返回链表的size，失败返回-1
int AddBack(LinkedList* list, void* data)
{
 // 创建一个新节点，创建不成功的话，返回-1
 Node* node = (Node *)malloc(sizeof(Node));
 if(!node) return -1;
 
 // 为节点的数据域赋值
 node->data = data;
 // 如果为链表的末尾
 if(list->tail)
 {
  list->tail->next = node;         // 把新节点赋给链表末尾的下一个
  node->prev       = list->tail;   // 新节点的前一个等于之前的末节点
  node->next       = NULL;         // 新节点为末节点，把它下一个指向NULL
 }
 else // 如果不为末尾，其实就是空链表
 {
  node->next       = NULL;         // 新节点的下一个为NULL
  node->prev       = NULL;         // 新节点的前一个为NULL
  list->head       = node;         // 链表的头为新节点node
 }
 list->tail = node;                   // 链表的末尾指向node
 
 return ++list->size;                 // 返回链表的size
}

// 将元素添加到链表前端，成功返回非0，否则返回0
int AddFront(LinkedList* list, void* data)
{
 Node *node = (Node*)malloc(sizeof(Node));
 if(!node) return 0;
 
 node->data = data;
 if(list->head)
 {
  list->head->prev = node;
  node->next       = list->head;
  node->prev       = NULL;
 }
 else
 {
  node->next       = NULL;
  node->prev       = NULL;
  list->tail       = node;
 }
 list->head = node;
 
 return ++list->size;
}

// 将元素从末端移除并返回该元素，如果链表为空则返回NULL
void* RemoveBack(LinkedList* list)
{
 Node* temp;
 void* data;
 
 if(!list->size) return NULL;
 
 temp = list->tail;
 data = list->tail->data;
 
 if(list->head == list->tail)
 {
  list->head = NULL;
  list->tail = NULL;
  list->cur  = NULL;
 }
 else
 {
  list->tail = list->tail->prev;
  list->tail->next = NULL;
 }
 --list->size;
 free(temp);
 return data;
}

// 将元素从前端移除并返回该元素，如果链表为空则返回NULL
void* RemoveFront(LinkedList* list)
{
 Node* temp;
 void* data;
 
 if(!list->size) return NULL;
 
 temp = list->head;
 data = list->head->data;
 
 if(list->head == list->tail)
 {
  list->head = NULL;
  list->tail = NULL;
  list->cur  = NULL;
 }
 else
 {
  list->head = list->head->next;
  list->head->prev = NULL;
 }
 --list->size;
 free(temp);
 return data;
}

/* 如果当前链表为空则返回非0，否则返回0 */
int IsEmpty(LinkedList* list)
{
    return list->size == 0;
}

/* 获得链表的大小（元素总个数） */
int Size(LinkedList* list)
{
    return list->size;
}

/* 将当前位置移动到链表的开始 */
void Begin(LinkedList* list)
{
    list->cur = list->head;
}

/* 将当前位置移动到链表的最后 */
void End(LinkedList* list)
{
    list->cur = list->tail;
}
/* 将当前位置向后移动一个位置 */
void MoveNext(LinkedList* list)
{
    list->cur = list->cur->next;
}

/* 将当前位置向后移动一个位置 */
void MovePrev(LinkedList* list)
{
    list->cur = list->cur->prev;
}

/* 清空链表中所有元素 */
void Clear(LinkedList* list)
{
 while(RemoveBack(list));
}

/* 销毁一个链表 */
void Destroy(LinkedList* list)
{
 Clear(list);
 free(list);
}

/* 如果当前位置之后还有元素则返回非0，否则返回0 */
int HasNext(LinkedList* list)
{
    if (!list->cur) return 0;
    if (list->cur == list->tail) return 1;
    return list->cur->next != NULL;
}

/* 如果当前位置之前还有元素则返回非0，否则返回0 */
int HasPrev(LinkedList* list)
{
    if (!list->cur) return 0;
    if (list->cur == list->head) return 1;
    return list->cur->prev != NULL;
}

/* 返回当前位置的元素 */
void* Current(LinkedList* list)
{
    return list->cur->data;
}

 

// 正向打印链表
void Traverse(LinkedList* list)
{
 for( Begin(list); HasNext(list); MoveNext(list) )
  printf("%d ", *(int*)Current(list));
 putchar('\n');
}

// 反向打印链表
void RTraverse(LinkedList* list)
{
    for (End(list); HasPrev(list); MovePrev(list))
        printf("%d ", *(int*)Current(list));
    putchar('\n');
}


int main()
{
 int i;
 LinkedList* list = Create();
 
 int array1[10];
 int array2[10];
 
 for(i=0; i<10; i++)
 {
  array1[i] = i+1;
  array2[i] = i+100+1;
  AddBack(list, &array1[i]); 
 }
 
 printf("链表大小(SIZE): %d\n", Size(list));
 
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 printf("添加array2[0]数\n");
 AddBack(list, &array2[0]);
 
 printf("链表大小(SIZE): %d\n", Size(list));
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 printf("调用AddFront函数，添加array2[0]数\n");
 AddFront(list, &array2[1]);
 
 printf("链表大小(SIZE): %d\n", Size(list));
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 printf("从末尾移除的元素是: %d\n", *(int *)RemoveBack(list));
 printf("链表大小(SIZE): %d\n", Size(list));
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 printf("从开头移除的元素是: %d\n", *(int *)RemoveFront(list));
 printf("链表大小(SIZE): %d\n", Size(list));
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 printf("清空链表，Clear(list)后\n");
 Clear(list);
 printf("链表大小(SIZE): %d\n", Size(list));
 
 for(i=0; i<10; i++)
 {
  AddFront(list, &array2[i]);
 }
 printf("正向打印链表:\n");
 Traverse(list);
 printf("反向打印链表:\n");
 RTraverse(list);
 
 Destroy(list);
 printf("销毁链表Destroy(list)\n");
 
 return 0;
}

大神代码的链接

自己的一点想法

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

typedef int ElemType;

typedef struct Node
{
    Node *prev;
    Node *next;
    ElemType *data;
} Node, *NodePointer;
// 创建结构体的时候创建结构体指针，使用typedef创建结构体较为简便
typedef struct LinkList
{
    Node *head;
    Node *tail;
    Node *cur;
    int size;
} LinkList, *LinkListPointer;

// 创建双链表
LinkListPointer CreatLinkList()
{
    // 分配空间
    LinkListPointer L = (LinkListPointer)malloc(sizeof(LinkList));
    if (!L)
    {
        return NULL;
    }
    // 初始化
    L->head = NULL;
    L->cur = NULL;
    L->tail = NULL;
    L->size = 0;
    return L;
}

// 在尾部添加节点
// 错误返回0，正确返回当前的长度
int AddBackLinkList(LinkListPointer L, ElemType *data)
{
    NodePointer node = (NodePointer)malloc(sizeof(Node));
    if (!node)
    {
        return 0;
    }
    node->data = data;
    if (L->tail)
    {
        L->tail->next = node;
        node->prev = L->tail;
        node->next = NULL;
    }
    else
    {
        L->head = node;
        node->prev = NULL;
        node->next = NULL;
    }
    L->tail = node;

    return ++L->size;
}

// 双链表的大小
int SizeLinkList(LinkListPointer L)
{
    return L->size;
}
// 将当前位置移到链表的开始
void Begin(LinkListPointer L)
{
    L->cur = L->head;
}
// 将当前位置移到链表的最后
void End(LinkListPointer L)
{
    L->cur = L->tail;
}
// 将当前的位置向后移到一个位置
void MoveNext(LinkListPointer L)
{
    L->cur = L->cur->next;
}
// 如果当前位置之后还有元素返回1，否则返回0
int HasNext(LinkListPointer L)
{
    if (!L->cur)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
// 返回当前位置的元素
ElemType *Current(LinkListPointer L)
{
    return L->cur->data;
}
// 正向打印链表
void Traverse(LinkListPointer L)
{
    for (Begin(L); HasNext(L); MoveNext(L))
    {
        printf("%-5d", *Current(L));
    }
    cout << endl;
}

int main(int argc, char const *argv[])
{
    LinkListPointer L = CreatLinkList();
    ElemType temp[10];
    for (int i = 0; i < sizeof(temp) / sizeof(temp[0]); i++)
    {
        temp[i] = i;
        AddBackLinkList(L, &temp[i]);
    }

    Traverse(L);
    return 0;
}
张某某！
关注
专栏目录
线性表--双向链表
小程的博客
02-03 1397
双向链表:相比于单链表，双向链表有两个指针域，既可以保存右边的节点地址(后继)，也可以保存左边的节点地址(前驱)。如果指针域指向一个不存在的节点，则将其指针置为NULL。 。
C语言双向链表的实现
m0_63666616的博客
05-03 4843
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
双向循环列表(C 语言实现)
止步听风的博客
04-16 566
// node.h #ifndef NODE_H #define NODE_H typedef struct Node { int data; struct Node *pre; struct Node *next; }ND; // insert a node from tail ND *createListTail(); // insert a node from...
c实现双向循环列表
dabing113的博客
03-30 249
// // LinkList2.c // LinkList // // 双向循环链表 #include <stdio.h> #include <stdlib.h> #define MaxSize 100 #define ElemType int ElemType A[MaxSize]; int n; typedef struct nod...
C语言双向循环列表功能vc2022版
W_YCai的博客
03-26 1233
main函数的 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include "DoubleList.h" int main(int argc, char *argv[]) { DList* L = (DNode*)malloc(sizeof(DNode)); ElemType op; do{ printf("-------双向循环链...
双向列表（JS）
zhouruitao的专栏
11-20 274
  JS实现双向列表 1，add(index, obj)  在指定索引处插入元素obj   2，get(index)  根据索引获取元素 3，getFirst() 获取第一个元素 4，getLast() 获取最后一个元素   5，set(index, obj) 重新设置元素的值   6，size() 返回元素的个数   7，clear() 清空所有元素   8，remo...
双向链表实现贪吃蛇游戏（C语言版）
最新发布
12-26
双向链表是一种数据结构，它允许我们在列表中的任何位置轻松地插入和删除元素，这使得它成为实现动态游戏世界，如贪吃蛇，的理想选择。 1. **双向链表基础** 双向链表与单链表不同，每个节点不仅包含数据，还包含...
C语言双向链表
08-13
在计算机科学中，双向链表是一种数据结构，它允许数据元素在列表中向前和向后移动。相较于单链表，双向链表提供了更多的灵活性，因为每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针。下面我们将...
双向链表反转【C语言】
在人间已是颠
11-25 1548
双向链表反转【C语言】 题目: 实现双向链表的反转 时间复杂度为O(n) 空间复杂度为O(1) 代码: /*9*/ #include <stdio.h> #include <stdlib.h> #define elemtype int int num=0; typedef struct dNode { elemtype da...
数据结构各章节算法实现（C语言版）.docx
10-12
本资料《数据结构各章节算法实现（C语言版）》提供了详细的数据结构算法实现，采用C语言编写，适合计算机专业的学生、ACM竞赛参与者、考研复习者以及准备面试笔试的人群使用。以下是对各个章节主要算法的详细说明： ...
双向链表List_数据结构_C语言实现
钟米苏的博客
07-15 308
前言单向链表 单链表节点中只有一个指向其后继的指针，这使得单链表只能从头节点依次顺序地向后遍历。若要访问某个节点得前驱节点(插入、删除操作时)，只能从头开始遍历。 为了克服单向链表的缺点，引入了双向链表，双向链表节点中有两个next和prev，分别指向下一个节点地址和上一个节点地址。 如图理解： 按位置前插入元素： 删除元素： 线性表链式存储结构，双向链表的实现 定义声明函数： /*...
c 代码实现双向列表
weixin_35756892的博客
02-15 73
下面是用 C 代码实现双向链表的基本框架： #include <stdio.h> #include <stdlib.h> // 双向链表结点定义 struct Node { int data; struct Node *prev; struct Node *next; }; // 在双向链表末尾插入结点 void append(struct No...
C语言双向链表(完整工程。创建，增删查)
tiramisu_L的博客
07-26 566
之前写了一篇基于C语言的单向链表，顺便也把双向链表写了。双向链表跟单向链表的区别就是多了一个向前的指针域。老实说，到目前为止我还没有真正体会到双向链表带给我的好处和优势。。。。 typedef struct _list { struct _list *prev; struct _list *next; int data; }list; ...
创建一个双向列表
三桂gg的博客
06-23 282
初始化一个双向列表，分别赋值’A-Z’ 输入一个数字 ：可正可负。 例如输入1：输出BCDE…ZA 输入-1：输出ZABCD…Y 双向列表删除插入等操作与单列表类似。 #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef char ElemType; typedef int S...
数据结构-双向列表
weixin_43509371的博客
03-07 121
数据结构学习
数据结构-双向链表（C语言）
usiehheu的博客
05-03 1858
文章目录1、双向链表的定义2、双向链表的初始化3、双向链表的打印4、双向链表的插入5、双向链表的删除6、双向链表的元素定位7、链表清空8、测试二、完整代码 1、双向链表的定义 双向链表是链表的一种，与单链表不同的shi，它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。 typedef struct DoubleLinkNode { char data; struct DoubleLink
双向链表(double linked list)
一个搬运知识的笨小孩
07-26 9401
双向链表 单链表寻找某结点的前驱结点时，必须遍历一遍链表，最坏的时间复杂度 O(n)O(n)O(n) 而双向链表可以直接寻找某结点的前驱结点 1.双向链表的某结点 用指向某结点的指针p代表该结点 结点p的后继的前驱等于结点p本身 结点p的前驱的后继等于结点p本身 p = p->prior->next p = p->next->prior 2.非空的带头结点的双向链表 3.双向链表中元素的插入操作 插入操作图解分步： 第一步： s->prior = p; //将p（
c语言实现双向链表
wu1217的博客
09-05 4474
/** 双链表操作 开发环境codeblocks12.11 xxwu */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode{     ElemType data;     struct DNode ...
双向列表实现
u011057161的专栏
02-04 513
http://www.cnblogs.com/matrix1024/archive/2011/12/31/2308380.html
用C语言写一个双向列表
03-06
双向链表是一种常见的数据结构，可以用C语言来实现。以下是一个简单的双向链表的实现示例： ``` #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *prev; struct node *next; } Node; Node *create_node(int data) { Node *new_node = (Node *)malloc(sizeof(Node)); new_node->data = data; new_node->prev = NULL; new_node->next = NULL; return new_node; } void insert_node(Node **head, int data) { Node *new_node = create_node(data); if (*head == NULL) { *head = new_node; return; } Node *current = *head; while (current->next != NULL) { current = current->next; } current->next = new_node; new_node->prev = current; } void delete_node(Node **head, int data) { if (*head == NULL) { return; } Node *current = *head; while (current != NULL && current->data != data) { current = current->next; } if (current == NULL) { return; } if (current->prev != NULL) { current->prev->next = current->next; } else { *head = current->next; } if (current->next != NULL) { current->next->prev = current->prev; } free(current); } void print_list(Node *head) { Node *current = head; while (current != NULL) { printf("%d ", current->data); current = current->next; } printf("\n"); } int main() { Node *head = NULL; insert_node(&head, 1); insert_node(&head, 2); insert_node(&head, 3); print_list(head); delete_node(&head, 2); print_list(head); return ; } ``` 以上是一个简单的双向链表的实现示例，可以用来存储任意类型的数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值