C 实现双链表

最新推荐文章于 2024-04-11 10:14:59 发布
最新推荐文章于 2024-04-11 10:14:59 发布
阅读量240 收藏
点赞数
分类专栏： Data Structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuemocheng/article/details/82622582
版权

DoublyLinkedList.h

#pragma once

// 新建双向链表。成功，返回0；否则，返回-1。
extern int DLink_Create();

// 链表大小
extern int DLink_Size();

// 获取第index位置的节点的值。
extern void* DLink_GetValue(int index);

// 表头插入数据
extern int DLink_InsertFirst(void *pval);

// 表尾插入数据
extern int DLink_InsertLast(void *pval);

// 在第index位置插入数据
extern int DLink_Insert(int index, void *pval);

// 删除双链表的第一个节点
extern int DLink_DeleteFirst();

// 删除双链表的最后一个节点
extern int DLink_DeleteLast();

// 删除双链表的第index个节点
extern int DLink_Delete(int index);

// 销毁双向链表。成功，返回0；否则，返回-1。
extern int DLink_Destory();

DoublyLinkedList.c

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

// 双向链表节点
typedef struct node
{
    struct node *prev;
    struct node *next;
    void *p;
}node;

// 头结点，头结点不保存数据
static node *phead = NULL;

// 节点个数
static int count = 0; 

// 新建节点。成功，返回节点指针；否则，返回NULL。
static node* CreateNode(void *pval)
{
    node *pnode = NULL;
    pnode = (node*)malloc(sizeof(node));
    if (pnode == NULL)
    {
        printf("Create Node Failed!\n");
        return NULL;
    }
    // 初始化新建节点前置节点和后置节点都是自己
    pnode->prev = pnode->next = pnode;
    // 节点的值可为任何类型
    pnode->p = pval;

    return pnode;
}

// 新建双向链表。成功，返回0；否则，返回-1。
int DLink_Create()
{
    // 创建表头
    phead = CreateNode(NULL);
    if (phead == NULL)
        return -1;

    count = 0;

    return 0;
}

// 链表大小
int DLink_Size()
{
    return count;
}

// 获取第index位置的节点。 0 <= index < count
static node* GetNode(int index)
{
    if (index < 0 || index >= count)
    {
        printf("%s failed! Index is out of range!\n", __func__);
        return NULL;
    }

    /// count = 6
    ///   ↓—————————————————————————————————————————————————↑
    ///  □□□  <-> □□□ <-> □□□ <-> □□□ <-> □□□ <-> □□□ <-> □□□ 
    ///  ↓—————————————————————————————————————————————————↑
    ///  head      0       1       2       3       4       5

    // 正向查找
    if(index < (count/2))
    {
        int i = 0;
        node *pnode = phead->next;
        while ((i++) < index)
            pnode = pnode->next;

        return pnode;
    }

    // 反向查找
    int i = count - 1;
    node *pnode = phead->prev;
    while ((i--) > index)
        pnode = pnode->prev;

    return pnode;
}

// 获取第index位置的节点的值。
void* DLink_GetValue(int index)
{
    node *pnode = GetNode(index);
    if (pnode == NULL)
    {
        printf("%s failed!\n", __func__);
        return NULL;
    }
    return pnode->p;
}

// 表头插入数据
int DLink_InsertFirst(void *pval)
{
    node *pnode = CreateNode(pval);
    if (pnode == NULL)
        return -1;

    pnode->next = phead->next;
    pnode->prev = phead;
    phead->next->prev = pnode;
    phead->next = pnode;

    count++;
    return 0;
}

// 表尾插入数据
int DLink_InsertLast(void *pval)
{
    node *pnode = CreateNode(pval);
    if (pnode == NULL)
        return -1;

    pnode->next = phead;
    pnode->prev = phead->prev;
    phead->prev->next = pnode;
    phead->prev = pnode;

    count++;
    return 0;
}

// 在第index位置插入数据
int DLink_Insert(int index, void *pval)
{
    if (index == 0)
        return DLink_InsertFirst(pval);

    node *pIndex = GetNode(index);
    if (pIndex == NULL)
        return -1;

    node *pnode = CreateNode(pval);
    if (pnode == NULL)
        return -1;

    pnode->next = pIndex->next;
    pnode->prev = pIndex;
    pIndex->next->prev = pnode;
    pIndex->next = pnode;

    count++;
    return 0;
}

// 删除双链表的第一个节点
int DLink_DeleteFirst()
{
    return DLink_Delete(0);
}

// 删除双链表的最后一个节点
int DLink_DeleteLast()
{
    return DLink_Delete(count - 1);
}

// 删除双链表的第index个节点
int DLink_Delete(int index)
{
    node *pindex = GetNode(index);
    if (pindex == NULL)
    {
        printf("%s failed!", __func__);
        return -1;
    }

    pindex->next->prev = pindex->prev;
    pindex->prev->next = pindex->next;
    free(pindex);
    count--;
    return 0;
}

// 销毁双向链表。成功，返回0；否则，返回-1。
int DLink_Destory()
{
    if (phead == NULL)
    {
        printf("%s failed!\n", __func__);
        return -1;  
    }

    node *pnode = phead->next;
    node *ptmp = NULL;
    while (pnode != phead)
    {
        ptmp = pnode;
        pnode = pnode->next;
        free(ptmp);
    }
    free(phead);
    phead = NULL;
    count = 0;
    return 0;
}

DoublyLinkedList_Test.c

#include <stdio.h>
#include <DoublyLinkedList.h>

void int_test()
{
    int iarr[4] = { 10, 20, 30, 40 };
    printf("\n----%s----\n", __func__);
    DLink_Create();             // 创建双链表

    DLink_Insert(0, &iarr[0]);  // 在表头插入数据
    DLink_Insert(0, &iarr[1]);  // 在表头插入数据
    DLink_Insert(0, &iarr[2]);  // 在表头插入数据
    DLink_Insert(0, &iarr[3]);  // 在表头插入数据

    printf("This list`s size is %d\n", DLink_Size());

    // 打印全部数据
    int *p;
    int size = DLink_Size();
    for (int i = 0; i < size; i++)
    {
        p = (int*)DLink_GetValue(i);
        printf("第%d个元素为：%d\n", i, *p);
    }
    DLink_Destory();
}

void string_test()
{
    char* sarr[4] = { "ten","tweny","thiry", "forty" };
    printf("\n----%s----\n", __func__);
    DLink_Create();

    DLink_Insert(0, sarr[0]);
    DLink_Insert(0, sarr[1]);
    DLink_Insert(0, sarr[2]);
    DLink_Insert(0, sarr[3]);

    printf("This list`s size is %d\n", DLink_Size());

    char *p;
    int size = DLink_Size();
    for (int i = 0; i < size; i++)
    {
        p = (char*)DLink_GetValue(i);
        printf("第%d个元素为：%s\n", i, p);
    }
    DLink_Destory();
}

typedef struct stu
{
    int id;
    char name[20];
}stu;

static stu arr_stu[] =
{
    {10,"andy"},
    {20,"baby"},
    {30,"city"},
    {40,"dog"},
};

#define ARR_STU_SIZE ((sizeof(arrstu))/(sizeof(arrstu[0])))

void object_test()
{
    printf("\n----%s----\n", __func__);
    DLink_Create();

    DLink_Insert(0, &arr_stu[0]);
    DLink_Insert(0, &arr_stu[1]);
    DLink_Insert(0, &arr_stu[2]);
    DLink_Insert(0, &arr_stu[3]);

    printf("This list`s size is %d\n", DLink_Size());

    stu *p;
    int size = DLink_Size();
    for (int i=0;i<size;i++)
    {
        p = (stu*)DLink_GetValue(i);
        printf("第%d个元素是[%d,%s]\n", i, p->id, p->name);
    }
    DLink_Destory();
}

int main()
{
    int_test();
    string_test();
    object_test();
    printf("\n");
    system("pause");
    return 0;
}

测试结果

这里写图片描述

参考：http://wangkuiwu.github.io/2013/01/01/dlink/

Spades_J
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C实现双链表
finewind的专栏
11-22 3966
链表带以下功能：1. 初始化链表：创建一个哨兵节点，链表头指向哨兵节点;2. 添加元素：添加的元素加到链表尾部;3. 搜索元素：遍历链表，寻找第一个匹配的节点，若找到，返回该节点的指针，若找不到，返回0;5. 删除元素： 删除匹配的第一个节点。头文件：#ifndef D_LIST_H_ #define D_LIST_H_ typedef unsigned int word; typedef unsigned char byte; typedef int Item; struct node {
双向链表（C实现）
zenglinshan的博客
11-22 388
list.h #ifndef _LIST_H #define _LIST_H typedef struct _node { void *data; struct _node *piror; struct _node *next; }NODE; typedef struct { NODE *head; NODE *last; int length; }LIST; LIST *In
c语言双链表
qq_40738945的博客
03-05 132
typedef int elemtype; typedef struct Dlink { elemtype data; Dlink *prev; Dlink *next; }Dlink; typedef struct{ int cursize; Dlink *head; }Dlinklist; 下面是 #include"Double_link.h"//循环链表一定要有头节点，并且循环链...
C语言的双链表
qq_32659129的博客
10-28 153
C语言的双链表的增、删和打印 #include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node *prior,*next; // prior前驱指针，next后继指针 }Node,*LinkList; struct Node* InitLinkList(LinkList L){ // 初始化链表 L = ((Node *)malloc(sizeof(Node))); L->
C语言实现双链表
qq_59183443的博客
07-28 442
代码】C语言实现双链表。
C语言实现双向链表
09-03
在C语言中，双向链表是一种非常重要的数据结构，它具有前向和后向两个指针，可以方便地进行节点的插入、删除和查找等操作。以下是对标题和描述中涉及的知识点的详细说明： 首先，我们需要定义一个双向链表的节点...
C语言实现双向链表DuLiST.c
03-24
本文将深入探讨C语言实现的双向链表，即标题中的"DuLiST.c"项目。 双向链表（Doubly Linked List）与单链表不同，每个节点不仅包含数据，还包含两个指针，一个指向下一个节点，另一个指向前一个节点。这种设计使得...
C语言实现的双链表功能完整示例
08-27
C语言实现的双链表功能完整示例 本文主要介绍了C语言实现的双链表功能，结合完整实例形式分析了基于C语言实现的双链表定义、添加、删除、排序等相关操作实现技巧。 一、双链表的定义 在C语言中，双链表的定义主要...
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点...
【C 数据结构】双向链表
最新发布
普罗米修斯的博客
04-11 719
双链表删除结点时，只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可。每个节点存在前后两个指针，分别指向前驱节点和后继节点。
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
【C语言】C语言实现双链表
熠熠L的博客
04-18 776
头文件 #pragma once #ifndef _L_LIST_H #define _L_LIST_H /* 需要用到的C库文件 */ #include <stdlib.h> #include <stdio.h> /* 双向链表节点结构体声明 */ typedef struct node { struct node* nextNode, * prevNode; //指向上一个节点和下一个节点的地址 void* nodeData; //指向节点的数据地址 }no
数据结构（双向链表）（C语言）
x18261294286的博客
08-10 1250
利用C语言实现双向链表的基本功能： 头文件： //LinkList.c #ifndef _LINKLIST_H #define _LINKLIST_H #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef s...
C语言双向链表实现
lichangshun3的博客
09-10 1758
C语言双向链表实现 链表是计算机编程中常用的一种数据结构，在大部分面向对象的编程语言中都会有封装好的类供用户直接使用，只有在数据结构课程中，老师才会要求学生用代码实现一个链表，而如果用C语言实现链表，除了要了解链表的特性之外，对于指针的操作也是一个重头戏。 开发环境：VS2013 开发系统：window7 头文件（TwoWayList.h）代码如下： #ifndef TWOWAY_...
C语言 实现一个双链表
pecuyu
12-12 3401
1 头文件编写如下doublelinklist.h头文件#pragma once typedef int _TYPE; // 数据类型typedef struct DoubleLinkListNode { struct DoubleLinkListNode* pPre; // 前一个节点指针 struct DoubleLinkListNode* pNext; // 后一个节点指针
C语言 先进先出链表
kaikai45的博客
06-24 817
C语言 链表 PS: 也是从网上各个帖子中学习的Python，因此代码的格式以及内容有粘贴网上其他大神的代码，如有侵权请告知删除 参照文章： https://blog.csdn.net/u010299133/article/details/103882723 因工作需要用到C语言的先进先出链表，但从上学开始，链表就只会答答选择题，无法熟练运用，多亏上方链接中的学习汇总，作者的总结对我十分有用，感谢！本篇意在对参考文章进行学习理解。 //声明链表节点 typedef struct _node{ time_t
C语言实现双链表及其基本操作
海马有力量的博客
11-04 266
双链表比普通的链表多了指向前方数据的指针，方便对链表的查找。不过在实现方面却复杂了不少，增加或者删除数据的时候要考虑到前后数据指针，其中的操作顺序一定不能错。 #include<stdio.h> #include<stdlib.h> #define N 100 typedef int ElemType; typedef struct Dnode{ ElemType data; struct Dnode *prior,*next; }Dnode,*DLinkList; DLink
数据结构（C实现）------- 双向链表
jesson20121020的专栏
09-19 1316
双向链表的结点描述及各种操作（C实现）
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 7422
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
C语言实现双向链表与线性表特性详解
在实现上，双向链表的存储结构使用了C语言的结构体定义，如`typedef struct DuLNode`，它包含数据元素、指向前一个节点的指针和指向后一个节点的指针。链表的初始化、插入、删除等操作都需要通过这些指针进行。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值