双向链表

最新推荐文章于 2020-08-20 11:33:34 发布
最新推荐文章于 2020-08-20 11:33:34 发布
阅读量533 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/So_discrepancy/article/details/52964981
版权

解释，我们在单链表中，有了next指针，查找下一元素为O（1），而查找上一节点的话，则是O（n）。
所以为了克服单向性这一缺点，我们在单链表的每个节点中，在设置一个指向其前区节点的指针域。

#include "string.h"
#include "ctype.h"

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 1000 /* 存储空间初始分配量 */
typedef int ElemType ;
typedef int status  ;

typedef struct DulNode{
    ElemType data;
    struct DulNode * next;
    struct DulNode * prior;
}DulNode,*DuLinkList;

//typedef struct DulNode* DuLinkList; 和上述表示方法一样
status InitList(DuLinkList * L){
 (*L) =(DuLinkList) malloc(sizeof(DulNode));
    if(*L == NULL){
        return ERROR;
    }else{
        (*L)->next = NULL;
        (*L)->prior = NULL;
        return OK;
    }
}

status EemptyList(DuLinkList L){
    if(L->next == NULL){
        return ERROR;
    }else{
        return OK;
    }

}

status Inserthead(DuLinkList **L,ElemType e){
    DuLinkList first;
    first = (DuLinkList)malloc(sizeof(DulNode));
    first->data = e;
    //printf("%p\n",(*(*L)));

    (*(*L))->next = first;
    first->prior = (*(*L));
    first->next = NULL;
    return -1;
}

status InsertTail(DuLinkList *L,ElemType e){//从表尾插 //
    DuLinkList rear;
    rear = (DuLinkList)malloc(sizeof(DulNode));
    rear->data = e;
    (*L)->next = rear;
    rear->prior = (*L);
    rear->next = NULL;

return 1;
}

status ListInsert(DuLinkList *L , int i, ElemType e){//考虑没有节点和插入到第一个位置
    if(!EemptyList(*L))
       return Inserthead(&L,e);
    DuLinkList p = (*L);
    int j=1;
    while(p && j<i ){
        p = p->next;
        j++;
    }
    if(!p||j>i){//用于判断i大于公共的节点数越界的情况和i=0的情况
        return ERROR;
    }

    if(p->next == NULL){//最后一个位置的后一个位置
       InsertTail(&p,e); //传p不用重新遍历
       return -1;
    }

    DuLinkList q = (DuLinkList)malloc(sizeof(DulNode));
    q->data = e;
    q->next = p->next;
    q->prior=p;
    p->next->prior = q;
    p->next = q;

}

status GetElem(DuLinkList L ,int i , ElemType *e){  //L指向头结点 L叫头指针

    int j=1;
    DuLinkList p = L->next;//指向第一个节点
    while(p&&j<i){
      j++;
      p = p->next;
    }
    if(!p||j>i){
      return ERROR;
    }

    *e = p->data;
    return OK;

}

status DeleteList(DuLinkList * L , int i ,ElemType *e){//由于是双向链表没有必要再去找到i-1个位置
    if(!EemptyList(*L))
    return ERROR;
    int j=1;
    DuLinkList p = (*L)->next; //从第一个位置开始
    while(p&&j<i){
        j++;
        p=p->next;
    }
    if(!p||j<i){
        printf("dasdasd\n");
        return ERROR;
    }

    *e = p->data;
    if(p->next==NULL){ //删除最后一个元素
        p->prior->next = NULL;
        free(p);
        return OK;
    }


    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;

}

int ListLength(DuLinkList L){
    if(!EemptyList(L))
    return 0;

    int j=0;
    DuLinkList p = L->next;
    while(p){
        j++;
        p = p->next;
    }

return j;
}

status FromHeadInsert(DuLinkList *L ,int n){

    (*L) =(DuLinkList) malloc(sizeof(DulNode));
    (*L)->next  = NULL;
    (*L)->prior = NULL;
    int i;
    srand(time(0));
    DuLinkList q=NULL;//用于记录原第一个节点的位置
    for(i=0;i<n;i++){
        DuLinkList s;
        s = (DuLinkList) malloc(sizeof(DulNode));
        s->data = rand()%100+1;
        s->prior = (*L);
        s->next = q;
        if(i!=0)
        (*L)->next->prior = s;//除了第一次插入的节点外，以后每次插
                             //入都需要设置原来的节点的前一个指向新的节点
        //q->prior = s 也可以

        (*L)->next = s;
        q=s;
    }


return OK;
}

status FromTailInsert(DuLinkList *L ,int n){
    (*L) =(DuLinkList) malloc(sizeof(DulNode));
    (*L)->next  = NULL;
    (*L)->prior = NULL;
    int i;
    srand(time(0));
    DuLinkList q=(*L);//用于记录原节点的位置
     for(i=0;i<n;i++){
        DuLinkList s;
        s = (DuLinkList) malloc(sizeof(DulNode));
        s->data = rand()%100+1;
        s->prior = q;
        s->next = NULL;
        q->next = s;
        q=s;
    }
}

status ClearList(DuLinkList *L){
    if(!EemptyList(*L))
    return ERROR;
    DuLinkList p=(*L)->next,q;
    while(p){
      q=p->next;
      free(p);
      p=q;
    }
    (*L)->next  = NULL;
    (*L)->prior = NULL;
    return OK;
}

int LocateElem(DuLinkList L,ElemType e){
    if(!EemptyList(L))
    return ERROR;
    DuLinkList p=L->next;
    int i=1;
    while(p){
        if(p->data == e)
        {
          return i;
        }
        p=p->next;
        i++;

    }
    return ERROR;
}
int main(){
    DuLinkList node;
    InitList(&node);
    //判读是否为空
    printf("%d\n",EemptyList(node));
    ListInsert(&node,1,2);//从头插
    printf("%p\n",node);
   // printf("%d\n",node->next->data);
    ListInsert(&node,1,5);
    ListInsert(&node,2,7);
    ListInsert(&node,2,9);
    ListInsert(&node,5,19);//插入到最后一个位置的下一个
    DuLinkList first,first1;
    first = node->next;
     while(first){
        printf("%d\n",first->data);
        first1 = first;
        first= first->next;
    }
     printf("\n");
     while(first1!=node){
        printf("%d\n",first1->data);
        first1= first1->prior;
    }
    printf("\n");
//得到元素
int value;
GetElem(node,5,&value);
printf("%d\n",value);

//删除元素
printf("\n");
printf("%d\n",DeleteList(&node,1,&value));
//printf("%d\n",value);
first = node->next;
     while(first){
        printf("%d\n",first->data);
        first1 = first;
        first= first->next;
    }
    printf("\n");
     while(first1!=node){
        printf("%d\n",first1->data);
        first1= first1->prior;
    }
printf("\n");
//计算长度
int chang = ListLength(node);
printf("%d\n",chang);
//头插法
printf("\n");
DuLinkList HeadInsert,test,test1;
FromHeadInsert(&HeadInsert,10);
test = HeadInsert->next;
     while(test){
        printf("%d\n",test->data);
        test1 = test;
        test= test->next;
    }
   printf("\n");
    while(test1!=HeadInsert){
        printf("%d\n",test1->data);
        test1= test1->prior;
    }
printf("\n");
//尾插法
DuLinkList TailInsert;
FromTailInsert(&TailInsert,3);
test = TailInsert->next;
     while(test){
        printf("%d\n",test->data);
        test1 = test;
        test= test->next;
    }
   printf("\n");
    while(test1!=TailInsert){
        printf("%d\n",test1->data);
        test1= test1->prior;
    }
      printf("\n");
//清空链表
printf("%p\n",TailInsert);
ClearList(&TailInsert);
printf("%p\n",TailInsert);

//查找相等元素的位置

int result = LocateElem(node,19);
printf("%d\n",result);
return 0;
}
So_discrepancy
关注
专栏目录
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
数据结构：双向链表
最新发布
2401_86551514的博客
08-03 726
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
操作系统课设-线程安全的双向链表
04-25
操作系统课程设计中实现线程安全的双向链表是一项重要的实践任务，这涉及到多线程编程、数据结构以及并发控制等核心知识点。在这个项目中，我们主要关注如何在多线程环境下构建一个能够正确操作（如插入、删除）而不...
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
stm32f103 双向链表
08-16
在这个项目中，我们讨论的是如何在STM32F103上实现一个双向链表的数据结构。双向链表是一种特殊的数据结构，它允许我们在列表中的节点之间进行前向和后向的移动，这在处理动态数据集合时非常有用。 首先，我们要...
数据结构笔记（四）顺序表和链表的基本操作
weixin_45541911的博客
08-20 505
线性表 线性表又分为顺序储存和链式储存，分别称为顺序表和链表。 顺序表 在计算机中申请一块连续的空间，将元素按存入,是一种随机存取的方式，这种方式可以随时读取，其时间复杂度为O(1)，但需要做增删操作时，需要移动大量元素，时间复杂度是O（n）。因为是连续的空间，因此会造成空间浪费或溢出的现象。 删除顺序表的第 i 个元素时，需要移动 n - i 个元素； 插入到第 i 个位置时，需要移动 n - i + 1个元素。 顺序表有静态分配与动态分配，这里记录最常用的动态分配 #include<stdlib
双向链表数据管理
"多重双向链表的实现及操作" 多重双向链表是一种复杂的数据结构，它不仅包含元素节点，还包含多个指向不同属性的链接。在这个实现中，链表用于存储具有姓名、性别、信仰和职务等信息的员工数据。链表的每个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值