双向链表的操作（C语言）

已于 2024-02-21 19:39:51 修改
阅读量612 收藏 6
点赞数 8
文章标签： 链表 c语言 数据结构
于 2024-02-21 19:38:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Volimteczh/article/details/136219180
版权

main函数部分：

#include <stdio.h>
#include "./23_doubleLinkList.h"
int main(int argc, const char *argv[])
{   
    doubleLinkList* head = create_doubleLinkList();
    insertHead_doubleLinkList(head,12);
    insertHead_doubleLinkList(head,21);
    insertHead_doubleLinkList(head,14);
    insertHead_doubleLinkList(head,16);
    
    insertTail_doubleLinkList(head,13);
    show_doubleLinkList(head);
    insertBypos_doubleLinkList(head,33,6);
    show_doubleLinkList(head);
    deleteHead_doubleLinkList(head);
    show_doubleLinkList(head);
    deleteTail_doubleLinkList(head);
    show_doubleLinkList(head);
    deleteBypos_doubleLinkList(head,2);
    show_doubleLinkList(head);                                 
    return 0;
}

功能函数：

#include<stdio.h>                                                                                                                                                                                                                            
#include <stdlib.h>                                                                                                                                                                                                                          
#include "./23_doubleLinkList.h"                                                                                                                                                                                                             
doubleLinkList* create_doubleLinkList()                                                                                                                                                                                                      
{                                                                                                                                                                                                                                            
    doubleLinkList* head = (doubleLinkList*)malloc(sizeof(doubleLinkList));                                                                                                                                                                  
    if(NULL==head)                                                                                                                                                                                                                           
    {                                                                                                                                                                                                                                        
        printf("头结点创建失败！\n");                                                                                                                                                                                                        
        return NULL;                                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                        
    head->text.len=0;                                                                                                                                                                                                                        
    head->next=head->prev=NULL;                                                                                                                                                                                                              
    return head;                                                                                                                                                                                                                             
}                                                                                                                                                                                                                                            
//判断链表是否为空                                                                                                                                                                                                                           
int isEmpty(doubleLinkList* head)                                                                                                                                                                                                            
{                                                                                                                                                                                                                                            
    return head->next==NULL?1:0;                                                                                                                                                                                                             
}                                                                                                                                                                                                                                            
//头插                                                                                                                                                                                                                                       
void insertHead_doubleLinkList(doubleLinkList* head,datatype num)                                                                                                                                                                            
{                                                                                                                                                                                                                                            
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                                                                                                                                    
    if(NULL == temp)                                                                                                                                                                                                                         
    {                                                                                                                                                                                                                                        
        printf("头结点创建失败！\n");                                                                                                                                                                                                        
        return;                                                                                                                                                                                                                              
                                                                                                                                                                                                                                             
    }                                                                                                                                                                                                                                        
    temp->text.data=num;                                                                                                                                                                                                                     
    temp->next=temp->prev=NULL;                                                                                                                                                                                                              
    //插入操作                                                                                                                                                                                                                               
    //需分情况考虑该链表是否有元素，以免出现段错误                                                                                                                                                                                           
        if(head->next!=NULL)                                                                                                                                                                                                                 
    {                                                                                                                                                                                                                                        
        temp->next = head->next;                                                                                                                                                                                                             
        head->next=temp;                                                                                                                                                                                                                     
        temp->prev=head;                                                                                                                                                                                                                     
        temp->next->prev=temp;                                                                                                                                                                                                               
    }else                                                                                                                                                                                                                                    
    {                                                                                                                                                                                                                                        
        temp->next = head->next;                                                                                                                                                                                                             
        head->next=temp;                                                                                                                                                                                                                     
        temp->prev=head;                                                                                                                                                                                                                     
    }                                                                                                                                                                                                                                        
    head->text.len++;                                                                                                                                                                                                                        
    return;                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                             
}                                                                                                                                                                                                                                            
//尾插                                                                                                                                                                                                                                       
void insertTail_doubleLinkList(doubleLinkList* head,datatype num)                                                                                                                                                                            
{                                                                                                                                                                                                                                            
    //定义一个新的结点                                                                                                                                                                                                                       
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                                                                                                                                    
    if(NULL == temp)                                                                                                                                                                                                                         
    {                                                                                                                                                                                                                                        
        printf("头结点创建失败！\n");                                                                                                                                                                                                        
        return;                                                                                                                                                                                                                              
                                                                                                                                                                                                                                             
    }                                                                                                                                                                                                                                        
    temp->text.data=num;                                                                                                                                                                                                                     
    temp->next=temp->prev=NULL;                                                                                                                                                                                                              
    //找到尾部的结点，p就是原双向链表的尾部结点                                                                                                                                                                                              
    doubleLinkList* p=head;                                                                                                                                                                                                                  
    while(p->next!=NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        p=p->next;                                                                                                                                                                                                                           
    }                                                                                                                                                                                                                                        
    p->next=temp;                                                                                                                                                                                                                            
    temp->next=NULL;                                                                                                                                                                                                                         
    temp->prev=p;                                                                                                                                                                                                                            
    head->text.len++;                                                                                                                                                                                                                        
    return;                                                                                                                                                                                                                                  
}                                                                                                                                                                                                                                            
//按位置插入                                                                                                                                                                                                                                 
void insertBypos_doubleLinkList(doubleLinkList* head,datatype num,int pos)                                                                                                                                                                   
{                                                                                                                                                                                                                                            
    if(pos<1 || pos>head->text.len+1)                                                                                                                                                                                                        
    {                                                                                                                                                                                                                                        
        printf("输入的位置%d不合法！\n",pos);                                                                                                                                                                                                
    }                                                                                                                                                                                                                                        
    //定义一个新的结点                                                                                                                                                                                                                       
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                                                                                                                                    
    if(NULL == temp)                                                                                                                                                                                                                         
    {                                                                                                                                                                                                                                        
        printf("头结点创建失败！\n");                                                                                                                                                                                                        
        return;                                                                                                                                                                                                                              
                                                                                                                                                                                                                                             
    }                                                                                                                                                                                                                                        
    temp->text.data=num;                                                                                                                                                                                                                     
    temp->next=temp->prev=NULL;                                                                                                                                                                                                              
    //找到要插入位置的前一个`结点                                                                                                                                                                                                            
    doubleLinkList* p=head;                                                                                                                                                                                                                  
    int i;                                                                                                                                                                                                                                   
    for(i=0;i<pos-1;i++)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        p=p->next;                                                                                                                                                                                                                           
    }                                                                                                                                                                                                                                        
    temp->next=p->next;                                                                                                                                                                                                                      
    p->next=temp;                                                                                                                                                                                                                            
    temp->prev=p;                                                                                                                                                                                                                            
    if(temp->next!=NULL)                                                                                                                                                                                                                     
    temp->next->prev=temp;                                                                                                                                                                                                                   
    head->text.len++;                                                                                                                                                                                                                        
    return;                                                                                                                                                                                                                                  
}                                                                                                                                                                                                                                            
//头删                                                                                                                                                                                                                                       
void deleteHead_doubleLinkList(doubleLinkList* head)                                                                                                                                                                                         
{                                                                                                                                                                                                                                            
    if(head->next==NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        printf("链表为空！\n");                                                                                                                                                                                                              
        return;                                                                                                                                                                                                                              
    }                                                                                                                                                                                                                                        
    //定义一个指针指向要删除的结点方便后续释放                                                                                                                                                                                               
    doubleLinkList* temp;                                                                                                                                                                                                                    
    temp=head->next;                                                                                                                                                                                                                         
                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                             
    head->next=temp->next;                                                                                                                                                                                                                   
    //需分情况考虑该结点是否为链表最后一个结点，以免出现段错误                                                                                                                                                                               
    if(temp->next!=NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        temp->next->prev=head;                                                                                                                                                                                                               
    }                                                                                                                                                                                                                                        
    free(temp);                                                                                                                                                                                                                              
    head->text.len--;                                                                                                                                                                                                                        
    return;                                                                                                                                                                                                                                  
}                                                                                                                                                                                                                                            
//尾删                                                                                                                                                                                                                                       
void deleteTail_doubleLinkList(doubleLinkList* head)                                                                                                                                                                                         
{                                                                                                                                                                                                                                            
    if(head->next==NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        printf("链表为空！\n");                                                                                                                                                                                                              
        return;                                                                                                                                                                                                                              
    }                                                                                                                                                                                                                                        
    //定义一个指针指向要删除的结点方便后续释放                                                                                                                                                                                               
    doubleLinkList* p=head;                                                                                                                                                                                                                  
    while(p->next!=NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        p=p->next;                                                                                                                                                                                                                           
    }                                                                                                                                                                                                                                        
    p->prev->next=NULL;                                                                                                                                                                                                                      
    free(p);                                                                                                                                                                                                                                 
    head->text.len--;                                                                                                                                                                                                                        
    return;                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                             
}                                                                                                                                                                                                                                            
//按位置删除                                                                                                                                                                                                                                 
void deleteBypos_doubleLinkList(doubleLinkList* head,int pos)                                                                                                                                                                                
{                                                                                                                                                                                                                                            
    if(head->next==NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
        printf("链表为空！\n");                                                                                                                                                                                                              
        return;                                                                                                                                                                                                                              
    }                                                                                                                                                                                                                                        
    //判断位置是否合法                                                                                                                                                                                                                       
    if(pos<1 || pos>head->text.len)                                                                                                                                                                                                          
    {                                                                                                                                                                                                                                        
        printf("输入的位置%d不合法！\n",pos);                                                                                                                                                                                                
    }                                                                                                                                                                                                                                        
    //定义一个指针指向要删除的结点方便后续释放                                                                                                                                                                                               
    doubleLinkList* p=head;                                                                                                                                                                                                                  
    int i;                                                                                                                                                                                                                                   
    for(i=0;i<pos;i++)                                                                                                                                                                                                                       
    {                                                                                                                                                                                                                                        
        p=p->next;                                                                                                                                                                                                                           
    }                                                                                                                                                                                                                                        
    //p就是要删除的结点                                                                                                                                                                                                                      
    p->prev->next=p->next;                                                                                                                                                                                                                   
    //当结点不为最后一个节点时，需要将该结点的后一位的前驱指针指向上一个结点                                                                                                                                                                 
    //当结点为最后一个节点则不需要，若不分情况考虑则会出现段错误；                                                                                                                                                                           
    if(p->next!=NULL)                                                                                                                                                                                                                        
    {                                                                                                                                                                                                                                        
    p->next->prev=p->prev;                                                                                                                                                                                                                   
    }                                                                                                                                                                                                                                        
    free(p);                                                                                                                                                                                                                                 
    head->text.len--;                                                                                                                                                                                                                        
}                                                                                                                                                                                                                                            
//遍历                                                                                                                                                                                                                                       
void show_doubleLinkList(doubleLinkList* head)                                                                                                                                                                                               
{                                                                                                                                                                                                                                            
    doubleLinkList* p=head;                                                                                                                                                                                                                  
    if(isEmpty(head))                                                                                                                                                                                                                        
    {                                                                                                                                                                                                                                        
        printf("链表为空！\n");                                                                                                                                                                                                              
    }                                                                                                                                                                                                                                        
    while(p->next!=NULL)                                                                                                                                                                                                                     
    {                                                                                                                                                                                                                                        
            p=p->next;                                                                                                                                                                                                                       
                                                                                                                                                                                                                                             
        printf("%d ",p->text.data);                                                                                                                                                                                                          
    }                                                                                                                                                                                                                                        
    printf("\n");                                                                                                                                                                                                                            
    return;                                                                                                                                                                                                                                  
}

头文件：

                                                                                 
#ifndef __doubleLinkList_H__
#define __doubleLinkList_H__
typedef int datatype;
union msg{    //若数据的类型也为int，则不需要这个联合体
datatype data;
int len;       //放头结点，记录链表长度
};
typedef struct node{
    union msg text;
    struct node* next; //指针，由于指针指向这一整个节点，所以类型为struct node*
    struct node* prev; 
}doubleLinkList; 

doubleLinkList* create_doubleLinkList();

void insertHead_doubleLinkList(doubleLinkList* head,datatype num);

void insertTail_doubleLinkList(doubleLinkList* head,datatype num);

void deleteBypos_doubleLinkList(doubleLinkList* head,int pos);
void deleteTail_doubleLinkList(doubleLinkList* head);
void deleteHead_doubleLinkList(doubleLinkList* head);
void insertBypos_doubleLinkList(doubleLinkList* head,datatype num,int pos);
void show_doubleLinkList(doubleLinkList* head); 
#endif

Volimtey
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向链表基本操作(C语言)
weixin_46503238的博客
04-29 3158
#include <stdio.h> #include <stdlib.h> #include<stdbool.h> //双向链表 typedef int Elemtype; typedef struct DNode { Elemtype data; struct DNode *prior,*next; } DNode,*DLinkList; //尾插法创建链表 DLinkList CreateList() { int x; DLin
C语言双向链表的实现
m0_63666616的博客
05-03 4733
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
双向链表操作c语言 函数,C语言实现数据结构和双向链表操作
weixin_42397516的博客
05-20 206
数据结构 双向链表的实现双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。双向链表结点的类型描述：//双向链表的类型描述typedef int ElemType;typedef struct node{ElemType data;struct node *prior,*next;}DuLNode,*DuLinkList;其中，pr...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构初阶 --- 双向链表的C语言实现
m0_71722065的博客
09-12 2509
带头双向循环链表
双向链表逆置 c语言,双向链表操作（逆置三种实现以及 冒泡排序 ）
weixin_42662171的博客
05-22 567
#pragmaonce#includeusingnamespacestd;typedefintDataType;classSListNode{public:SListNode(DataTypex):_x(x),_next(NULL),_pre(NULL){}friendclassSList;private:DataType_x;SListNode*_next;SList...
数据结构-双向链表（C语言）
usiehheu的博客
05-03 1712
文章目录1、双向链表的定义2、双向链表的初始化3、双向链表的打印4、双向链表的插入5、双向链表的删除6、双向链表的元素定位7、链表清空8、测试二、完整代码 1、双向链表的定义 双向链表是链表的一种，与单链表不同的shi，它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。 typedef struct DoubleLinkNode { char data; struct DoubleLink
双向链表（C语言）
17的博客
10-07 800
双向链表
双向链表逆置 c语言,双向链表的逆置（两种）
weixin_31998661的博客
05-22 749
#include#includeusingnamespacestd;templatestructLinkNode{LinkNode(constT&x):_data(x),_prev(NULL),_next(NULL){}T_data;LinkNode*_prev;LinkNode*_next;};templateclassList{public:List():_hea...
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 4985
本文详细介绍带头双向循环链表，内容较为丰富
C语言实现双向链表
09-03
在C语言中，双向链表是一种非常重要的数据结构，它具有前向和后向两个指针，可以方便地进行节点的插入、删除和查找等操作。以下是对标题和描述中涉及的知识点的详细说明： 首先，我们需要定义一个双向链表的节点...
C语言 双向链表操作，普通双向和循环双向
09-23
C语言双向链表操作 C语言双向链表操作是指在C语言中使用结构体来实现双向链表的操作，包括创建、销毁、查找、删除和插入操作。双向链表是一种数据结构，其中每个节点都可以向前和向后进行遍历。在C语言中，可以...
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的操作。双向循环链表是一种特殊的数据结构，每个节点不仅包含数据，还包含指向左邻节点和右邻节点的指针，形成一个首尾相连的环状结构。 首先，定义了一个名为`...
循环双向链表（C语言）
09-17
循环双向链表，实现了插入、查找特定的节点、删除等功能，是自己花了半天的时间写完的。
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点...
高并发服务器-使用多进程（Multi-Process）实现【C语言】
qq_42037383的博客
07-17 309
初始化服务器创建监听套接字（socket绑定套接字到指定地址和端口（bind开始监听连接请求（listen等待连接进入一个无限循环，等待并接受客户端连接（accept创建子进程每当接受到一个新的客户端连接，创建一个子进程（fork子进程负责与客户端通信，处理请求并发送响应。父进程继续监听父进程关闭与客户端通信的套接字，继续监听新的连接请求。处理子进程结束信号（可选）注册信号处理函数，处理子进程结束信号，避免僵尸进程。
三、初识C语言（3）
m0_56351488的博客
07-16 1631
例：#define MAX 100例：#define MAX (x,y) (x>y?x:y)（无参数类型）宏模块之间不能有空格调用：定义了一个MAX(x,y)的宏//#define定义宏x:y)int main()int a = 0;int b = 0;int c = 0;printf("最大值是：%d\n",c);return 0;
C语言之2048小游戏理解分析
m0_65146517的博客
07-20 582
按键W --------------- 向上按键A --------------- 向左按键S --------------- 向下按键D --------------- 向右按键P --------------- 开始游戏按键L --------------- 结束游戏按键其他 ---------- 提示有错。
E16.【C语言】练习：输入一个正的整数，逆序打印这个整数的每一位
最新发布
2401_85828611的博客
07-20 186
分析：123%10=3-->123/10=12(3被去除了)-->12%10=2-->12/10=1(2被去除了)-->1%10=1(取出最后一位)->1/10=0-->停止循环。输入一个正的整数，逆序打印这个整数的每一位。步骤：1.取出整数的每一位 2.倒序打印。
双向链表反转c语言
06-01
以下是双向链表反转的 C 语言代码： ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; struct Node* prev; }; void printList(struct Node* node) { while (node != NULL) { printf("%d ", node->data); node = node->next; } printf("\n"); } void reverseList(struct Node** head) { struct Node* temp = NULL; struct Node* current = *head; while (current != NULL) { temp = current->prev; current->prev = current->next; current->next = temp; current = current->prev; } if (temp != NULL) { *head = temp->prev; } } int main() { struct Node* head = NULL; struct Node* first = (struct Node*)malloc(sizeof(struct Node)); struct Node* second = (struct Node*)malloc(sizeof(struct Node)); struct Node* third = (struct Node*)malloc(sizeof(struct Node)); first->data = 1; first->prev = NULL; first->next = second; second->data = 2; second->prev = first; second->next = third; third->data = 3; third->prev = second; third->next = NULL; head = first; printf("Original List: "); printList(head); reverseList(&head); printf("Reversed List: "); printList(head); return 0; } ``` 在这个代码中，我们定义了一个 `Node` 结构体，包含了数据、前驱指针和后继指针。`printList` 函数用于打印链表中的每个元素。`reverseList` 函数用于反转链表，该函数的参数是一个指向指针的指针，因为我们需要在函数内部改变链表头指针的值。 在 `reverseList` 函数中，我们使用 `temp` 变量来保存当前结点的前驱指针，因为我们需要在交换当前结点的前驱和后继指针后，把它赋给下一个结点的前驱指针。最后，我们需要更新链表头指针的值，否则我们会得到一个不完整的链表。 在 `main` 函数中，我们创建了一个简单的双向链表，并将其传递给 `reverseList` 函数来反转它。最后，我们使用 `printList` 函数来检查链表是否被正确地反转。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值