双向链表doubleLinklist

最新推荐文章于 2024-05-30 21:35:46 发布
最新推荐文章于 2024-05-30 21:35:46 发布
阅读量120 收藏
点赞数
分类专栏： 数据结构 C语言 文章标签： 链表 数据结构 c语言 linux 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74937538/article/details/132868539
版权

特性

逻辑结构：线性结构

存储结构：链式存储结构

操作：增删改查

双向链表的结构体：

typedef int datatype;
typedef struct node
{
    datatype data;      //数据域
    struct node *next;  //指向下一个节点的指针
    struct node *prior; //指向前一个节点得指针
} link_node_t, *link_list_t;

//将双向链表的头指针和尾指针封装到一个节点体里 
//思想上有点像学的链式队列
typedef struct doublelinklist
{
    link_list_t head; //指向双向链表的头指针
    link_list_t tail; //指向双向链表得尾指针
} double_t, *double_list_t;

双向链表的相关操作

插入：

需要注意的是，与单链表不同，双链表创建过程中，每创建一个新节点都要与其前驱节点建立两次联系，分别是：

  1. 将新节点的 prior 指针指向直接前驱节点。
  2. 将直接前驱节点的 next 指针指向新节点。

结构体

#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node
{
    datatype data;//数据域
    struct node *next;//指向下一个节点的指针
    struct node *prior;//指向前一个节点的指针
}link_node_t,*link_list_t;
typedef struct doublelinklist
{
    link_list_t head;//指向双向链表的头指针
    link_list_t tail;//指向双向链表的尾指针
    int len;//记录链表长度
}double_t,*double_list_t;

1）创建一个空的双向链表

//创建一个空的双向链表
double_list_t createEmptyDoubleLinkList()
{
    //1.申请一块空间放头尾指针
    double_list_t p = (double_list_t)malloc(sizeof(double_t));
    if (NULL == p)
    {
        perror("createEmptyDoubleLinkList p malloc err");
        return NULL;
    }
    //2.初始化，将头尾指针指向开辟得头节点
    p->len = 0;
    p->head = p->tail = (link_list_t)malloc(sizeof(link_node_t));
    if (NULL == p->head)
    {
        perror("createEmptyDoubleLinkList p->head malloc err");
        return NULL;
    }
    //3.头节点初始化
    p->head->next = NULL;
    p->head->prior = NULL;
    return p;
}

2）插入数据

//插入数据
int InsertLinklist(double_list_t p,int post,datatype data)
{
    if(post<0||post>p->len)//容错
    {
        printf("post error\n");
        return -1;
    }
    link_list_t pt=NULL;
    link_node_t *pnew=(link_node_t *)malloc(sizeof(link_node_t));
    if(NULL==pnew)
    {
        perror("开辟失败\n");
    }
    pnew->data=data;
    pnew->next=NULL;
    pnew->prior=NULL;
    if(post==p->len)//尾插
    {
        pnew->prior=p->tail;
        p->tail->next=pnew;
        p->tail=pnew;

    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pt=p->head;
            for(int i=0;i<=post;i++)
            {
                pt=pt->next;
            }
        }
        else//后半段
        {
            pt=p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {
                pt=pt->prior;
            }
        }
            pnew->prior=pt->prior;
            pt->prior->next=pnew;
            pt->prior=pnew;
            pnew->next=pt;
            // pnew->prior=pt->prior;
            // pnew->next=pt;
            // pt->prior->next=pnew;
            // pt->prior=pnew;

    }
        p->len++;
    return 0;
}

3）遍历双向链表

void Show(double_list_t p)
{
#if 1//正向遍历
    link_node_t *pt=p->head;
    while(pt->next!=NULL)
    {
        pt=pt->next;     
        printf("%d ",pt->data);
    }   
#else//反向遍历
    link_list_t ph=p->tail;
    // while(ph->prior!=NULL)
    while(ph!=p->head)
    {
        printf("%d ",ph->data);
        ph=ph->prior;
    }
#endif
    puts(" ");
}

4）删除确定位置数据

//删除确定位置数据
int DelLinklist(double_list_t p,int post)
{
    if(post<0||post>=p->len||IsVoidLinklist(p))
    {
        printf("err\n");
        return -1;
    }
    link_list_t pt=NULL;
    if(post==p->len-1)
    {
        p->tail=p->tail->prior;
        free(p->tail->next);
        p->tail->next=NULL;
        return p->tail->data;
        p->len--;
    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pt = p->head;
            for(int i=0;i<=post;i++)
            {
                pt=pt->next;
            }
        }
        else//后半段
        {
            pt = p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {   
                pt=pt->prior;
            }
        }
        link_list_t pdel=pt;
        int data=pdel->data;
        pt->prior->next=pt->next;
        pt->next->prior=pt->prior;
        free(pdel);
        printf("删除%d\n",data);
    }
    p->len--;
    return 0;
}

5）查询数据位置

//查询数据位置
int SearchLinklist(double_list_t p,datatype data)
{
    if(IsVoidLinklist(p))
        {
            printf("链表为空\n");
            return -1;
        }
    link_list_t ptemp=p->head;
    int num=0;
    while(ptemp->next!=NULL)
    {
        ptemp=ptemp->next;
        if(ptemp->data==data)
        {
            printf("该数据位于%d处\n",num);
            return num;
        }
        num++;
    }
    printf("未找到该数据\n");
    return -1;
}

6）更改数据

//更改数据
int ChangeLinklist(double_list_t p,int post,datatype data)
{
    if(post<0||post>=p->len||IsVoidLinklist(p))
    {
        printf("err\n");
        return -1;
    }
    link_list_t pc=NULL;//定义一个新指针用于便利
    if(post==p->len-1)
    {
        p->tail->data=data;
        return 0;
    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pc = p->head;
            for(int i=0;i<=post;i++)
            {
                pc=pc->next;
            }
        }
        else//后半段
        {
            pc = p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {
                pc=pc->prior;
            }
        }
    }
    pc->data=data;
    return 0;
}

7）按数据删除内容

//按数据删除内容
int DelatedataLinklist(double_list_t p,datatype data)
{
    if(IsVoidLinklist(p))
        {
            printf("链表为空\n");
            return -1;
        }
    link_list_t pdel=NULL;
    link_list_t ph=p->head->next;
    while(ph!=NULL)
    {   
        if(ph->data==data)
        {
            if(ph==p->tail)
            {
                pdel=p->tail;
                p->tail=p->tail->prior;
                p->tail->next=NULL;
                printf("删除:%d\n",pdel->data);
                free(pdel);
                pdel=NULL;
                return 0;
            }
            else
            {
                pdel=ph;
                ph->prior->next=ph->next;
                ph->next->prior=ph->prior;
                printf("删除%d\n",pdel->data);
                free(pdel);
                pdel=NULL;
            }
                p->len--;
        }
        ph=ph->next;
    }
}


#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node
{
    datatype data;//数据域
    struct node *next;//指向下一个节点的指针
    struct node *prior;//指向前一个节点的指针
}link_node_t,*link_list_t;
typedef struct doublelinklist
{
    link_list_t head;//指向双向链表的头指针
    link_list_t tail;//指向双向链表的尾指针
    int len;//记录链表长度
}double_t,*double_list_t;
//创建一个头节点
double_list_t CreatLinklist()
{
    double_list_t p=(double_list_t)malloc(sizeof(double_t));
    if(NULL==p)
    {
        printf("开辟失败\n");
        return NULL;
    }
    p->head=p->tail=(link_list_t)malloc(sizeof(link_node_t));
    if(NULL==p->tail)
    {
        printf("开辟失败\n");
        return NULL;
    }
    p->tail->next=NULL;
    p->tail->prior=NULL;
    p->len=0;
    return p;
}

//插入数据
int InsertLinklist(double_list_t p,int post,datatype data)
{
    
    if(post<0||post>p->len)//容错
    {
        printf("post error\n");
        return -1;
    }
    
    link_list_t pt=NULL;
    link_node_t *pnew=(link_node_t *)malloc(sizeof(link_node_t));
    if(NULL==pnew)
    {
        perror("开辟失败\n");
    }
    pnew->data=data;
    pnew->next=NULL;
    pnew->prior=NULL;
    if(post==p->len)//尾插
    {
        pnew->prior=p->tail;
        p->tail->next=pnew;
        p->tail=pnew;

    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pt=p->head;
            for(int i=0;i<=post;i++)
            {
                pt=pt->next;
            }
        }
        else//后半段
        {
            pt=p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {
                pt=pt->prior;
            }
        }
            pnew->prior=pt->prior;
            pt->prior->next=pnew;
            pt->prior=pnew;
            pnew->next=pt;
            // pnew->prior=pt->prior;
            // pnew->next=pt;
            // pt->prior->next=pnew;
            // pt->prior=pnew;

    }
        p->len++;
    return 0;
}
void Show(double_list_t p)
{
#if 1
    link_node_t *pt=p->head;
    while(pt->next!=NULL)
    {
        pt=pt->next;     
        printf("%d ",pt->data);
    }   
#else
    link_list_t ph=p->tail;
    // while(ph->prior!=NULL)
    while(ph!=p->head)
    {
        printf("%d ",ph->data);
        ph=ph->prior;
    }
#endif
    puts(" ");
}
int IsVoidLinklist(double_list_t p)
{
    return p->len==0;
}
//删除确定位置数据
int DelLinklist(double_list_t p,int post)
{
    if(post<0||post>=p->len||IsVoidLinklist(p))
    {
        printf("err\n");
        return -1;
    }
    link_list_t pt=NULL;
    if(post==p->len-1)
    {
        p->tail=p->tail->prior;
        free(p->tail->next);
        p->tail->next=NULL;
        return p->tail->data;
        p->len--;
    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pt = p->head;
            for(int i=0;i<=post;i++)
            {
                pt=pt->next;
            }
        }
        else//后半段
        {
            pt = p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {   
                pt=pt->prior;
            }
        }
        link_list_t pdel=pt;
        int data=pdel->data;
        pt->prior->next=pt->next;
        pt->next->prior=pt->prior;
        free(pdel);
        printf("删除%d\n",data);
    }
    p->len--;
    return 0;
}
//链表长度
int LengthLinklist(double_list_t p)
{
    printf("长度为：%d\n",p->len);
    return p->len;
}
//查询数据位置
int SearchLinklist(double_list_t p,datatype data)
{
    if(IsVoidLinklist(p))
        {
            printf("链表为空\n");
            return -1;
        }
    link_list_t ptemp=p->head;
    int num=0;
    while(ptemp->next!=NULL)
    {
        ptemp=ptemp->next;
        if(ptemp->data==data)
        {
            printf("该数据位于%d处\n",num);
            return num;
        }
        num++;
    }
    printf("未找到该数据\n");
    return -1;
}
//更改数据
int ChangeLinklist(double_list_t p,int post,datatype data)
{
    if(post<0||post>=p->len||IsVoidLinklist(p))
    {
        printf("err\n");
        return -1;
    }
    link_list_t pc=NULL;//定义一个新指针用于便利
    if(post==p->len-1)
    {
        p->tail->data=data;
        return 0;
    }
    else
    {
        if(post<p->len/2)//前半段
        {
            pc = p->head;
            for(int i=0;i<=post;i++)
            {
                pc=pc->next;
            }
        }
        else//后半段
        {
            pc = p->tail;
            // for(int i=0;i<=p->len-post-2;i++)
            for(int i=p->len-1;i>post;i--)
            {
                pc=pc->prior;
            }
        }
    }
    pc->data=data;
    return 0;
}
//按数据删除内容
int DelatedataLinklist(double_list_t p,datatype data)
{
    if(IsVoidLinklist(p))
        {
            printf("链表为空\n");
            return -1;
        }
    link_list_t pdel=NULL;
    link_list_t ph=p->head->next;
    while(ph!=NULL)
    {   
        if(ph->data==data)
        {
            if(ph==p->tail)
            {
                pdel=p->tail;
                p->tail=p->tail->prior;
                p->tail->next=NULL;
                printf("删除:%d\n",pdel->data);
                free(pdel);
                pdel=NULL;
                return 0;
            }
            else
            {
                pdel=ph;
                ph->prior->next=ph->next;
                ph->next->prior=ph->prior;
                printf("删除%d\n",pdel->data);
                free(pdel);
                pdel=NULL;
            }
                p->len--;
        }
        ph=ph->next;
    }
}
int main(int argc, char const *argv[])
{
    double_list_t p=CreatLinklist();
    InsertLinklist(p,0,1);
    InsertLinklist(p,3,4);
    InsertLinklist(p,1,2);
    InsertLinklist(p,2,3);
    InsertLinklist(p,3,4);
    InsertLinklist(p,3,4);
    InsertLinklist(p,4,5);
    InsertLinklist(p,4,5);
    InsertLinklist(p,3,4);
    InsertLinklist(p,5,6);
    Show(p);
    DelLinklist(p,3);
    Show(p);
    SearchLinklist(p,6);
    ChangeLinklist(p,4,999);
    DelatedataLinklist(p,4);
    Show(p);
    return 0;
}

杀猴子

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

typedef int datatype;
typedef struct node_t
{
	datatype data;
	struct node_t * prior;
	struct node_t * next;
}link_node_t,*link_list_t;

typedef struct doublelinklist
{
	link_list_t head;
	link_list_t tail;
}double_node_t,*double_list_t;


int main(int argc, const char *argv[])
{
	int i;
	int all_num = 8;//猴子总数
	int start_num = 3;//从3号猴子开始数
	int kill_num = 3;//数到几杀死猴子 
	link_list_t h = NULL;
	link_list_t pdel = NULL;//用来指向被杀死猴子的节点
	printf("请您输入猴子的总数，开始号码，出局号码:\n");
	scanf("%d%d%d",&all_num,&start_num,&kill_num);
	//1.创建一个双向的循环链表
	double_list_t p = (double_list_t)malloc(sizeof(double_node_t));//申请头指针和尾指针
	if(NULL == p)
	{
		perror("malloc failed");
		return -1;
	}
	p->head = p->tail = (link_list_t)malloc(sizeof(link_node_t));
	if(NULL == p->tail)
	{
		perror("p->tail malloc failed");
		return -1;
	}
	p->head->data = 1;
	p->head->prior = NULL;
	p->head->next = NULL;
	//将创建n个新的节点，链接到链表的尾
	for(i = 2; i <= all_num; i++)
	{
		link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
		if(NULL == pnew)
		{
			perror("pnew malloc failed");
			return -1;
		}
		pnew->data = i;
		pnew->prior = NULL;
		pnew->next = NULL;
		//(1)将新的节点链接到链表的尾
		p->tail->next = pnew;
		pnew->prior = p->tail;
		//(2)尾指针向后移动，指向当前链表的尾
		p->tail = pnew;
	}
	//(3)形成双向循环链表 
	p->tail->next = p->head;
	p->head->prior = p->tail;
	//调试程序 
#if 0
	while(1)
	{
		printf("%d\n",p->head->data);
		p->head = p->head->next;
		sleep(1);
	}
#endif
	//2.循环进行杀死猴子
	h = p->head;
	//(1)先将h移动到start_num处，也就是开始数数的猴子号码处
	for(i = 1; i < start_num; i++)
		h = h->next;
        printf("start is:%d\n",h->data);
	while(h->next != h)//当h->next == h 就剩一个节点了，循环结束
	{
		//(2)将h移动到即将杀死猴子号码的位置
		for(i = 1; i < kill_num; i++)
			h = h->next;
		//(3)进行杀死猴子，经过上面的循环后，此时的h指向即将杀死的猴子
		h->prior->next = h->next;
		h->next->prior = h->prior;
		pdel = h;//pdel指向被杀死猴子的位置
		printf("kill is -------%d\n",pdel->data);
		h = h->next;//需要移动，从杀死猴子后的下一个位置开始数
		free(pdel);
	}
	printf("猴王是%d\n",h->data);
	return 0;
}

满山的猴子我的腚最红
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
双向链表
u011164680的博客
01-14 361
双向链表 单向链表相对数组来说已经有很多优点了，但是，它还有一个最大的弊端，每次查找元素时都要一路遍历，没办法倒回来，这种特性在进行数据操作时，会大大浪费时间，鉴于此，出现了双向链表的概念。 双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点...
C语言实现双向链表
09-03
本文给大家分享的是一段使用C语言实现双向链表的代码，完全是根据自己的理解和认识来编写的，希望大家能够喜欢，文章的最后附上了一个网友写的对于双向链表删除节点、插入节点、双向输出等操作的代码，也非常不错，...
数据结构（二）：双向链表DoubleLinkList，带头结点和不带头结点的实现方法
qq_41623154的博客
04-20 509
双向链表DoubleLinkList 双向链表就是单链表的改进，添加了一个“pre”域，但是这个新的域指向的是上一个结点。 对单链表遗忘的，可以和我的上一篇文章单链表结合起来看。 双向链表的删除和插入需要考虑的情况会多点。因为多了个pre域，很容易在头部或者尾部进行插入和删除的时候，报空指针异常。 java：实现带头结点的双向链表。 package com.study; public clas...
双向链表（DoubleLinkList）
Cdreamfly的博客
07-06 767
双向链表 有关链表的知识可以点击我上篇文章这里就不再赘述LinkedList 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向循环链表的可以点击我这篇文章这里就不再赘述DoubleLoopLinkList 添加 头添加 void addFirst(const T &e) { //新建一个节点让它前驱指向头，后继指向头的后
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
数据结构——双向链表
qq_56668869的博客
08-23 673
数据结构、双向链表、双向链表的优缺点、程序代码封装双向链表、双向链表的操作及方法
Python双向链表的操作
分享一点有用的知识
04-21 1116
Python双向链表的操作
JavaScript实现双向链表
qq_42710593的博客
03-12 1144
JavaScript实现双向链表
Java实现双向链表
m0_57099067的博客
05-04 817
package 链表; public class DoubleLinkedListDemo { public static void main(String[] args) { DoubleLinkList doubleLinkList = new DoubleLinkList(); doubleLinkList.add(1); doubleLinkList.add(4); doubleLinkList.add(2); .
Python实现双向链表
wangTongGen
05-13 1250
双向链表：比单链表复杂一点的就是双向链表，也是由一个个节点组成。每个节点有两个链接，一个指向前一个节点，当此节点为第一个节点时，指向None；另一个指向后一个节点，当此节点为最后一个节点时，指向None。 节点实现： class Node(object): """节点""" def __init__(self, val=None): self.val = ...
创建双向链表_双向链表_
09-30
通过建立双向链表，来实现双向查找，增加和删除的功能
C++实现双向链表
12-17
本文实例为大家分享了C++实现动态顺序表的具体代码，供大家参考，具体内容如下 List.h #pragma once #include #include #include using namespace std; typedef int DataType; struct ListNode ... :_data
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
树--搜索二叉树
Beau Wang
05-29 786
线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。
Redis 中 Set 数据结构详解
llt2997632602的博客
05-29 646
Redis 中 Set 的常用命令，编码，场景整理。
数据结构——图论详细笔记
2301_79376014的博客
05-27 524
一 图论基本概念二 图的存储。
数据结构——二叉树（C语言版）
最新发布
2302_80657849的博客
05-30 597
二叉树是一种非线性的数据结构。二叉搜索树、堆、红黑树等高阶数据结构都是依托于二叉树的基础实现的，所以我们有必要好好研究一下“二叉树”这种数据结构。本文只介绍二叉树的基础及中等用法，笔者能力有限，欠妥当之处欢迎批评指正。
ConcurrentHashMap 双向链表
03-22
ConcurrentHashMap是Java中的一个线程安全的哈希表实现，它是HashMap的线程安全版本。它通过使用锁分段技术来实现高效的并发访问。 ConcurrentHashMap的内部结构是由一个固定数量的Segment（段）组成的，每个Segment都是一个类似于HashMap的结构，它包含了一个哈希表和一个链表。每个Segment维护了一个独立的锁，不同的线程可以同时访问不同的Segment，从而实现了并发访问。 双向链表（Doubly Linked List）是一种链表数据结构，它的每个节点都包含了指向前一个节点和后一个节点的指针。相比于单向链表，双向链表可以支持双向遍历，即可以从头到尾或者从尾到头遍历链表。 在Java中，并没有直接提供双向链表的实现，但可以通过自定义类来实现双向链表的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

满山的猴子我的腚最红

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值