双向链表_

已于 2024-02-19 17:13:49 修改
阅读量263 收藏
点赞数
文章标签： 数据结构
于 2017-05-31 18:17:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ericios/article/details/72822620
版权

http://lvguohaolcj.blog.163.com/blog/static/31646731201073121340250/

一、循环链表

       循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表

       的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而

       构成一个环形的链；

  循环链表和单链表的运算不同点：

  1、在建立一个循环链表时，必须使其最好一个结点的指针指向表头结点，而

  不是象单链表那样置为NULL，此中情况还使用于在最后一个结点后插入一个

  新的结点；

  2、在判断是否到表尾时，是判断该结点链域的值是否是表头结点，当链域值

  等于表头指针时，说明已经表尾，而非象单链表那样判断链域值是否为NULL。

  二、双向链表

              当我们对单链表进行操作时，有时你要对某个结点的直接前驱进行操作时，

  又必须从表表头开始查找。这是由单链表结点的结构所限制的，因为单链表每个

  结点只有一个存储直接后继结点地址的链域，那么能不能定义一个既有存储直接

  后继结点地址的链域，又有存储直接前驱结点地址的链域的这样一个双链域结点

  结构呢？这就是双向链表。

              在双向链表中，结点除含有数据域外，还有两个链域，一个存储直接后继

  结点地址，一般称之为右链域；一个存储直接前驱结点地址，一般称之为左链域。

*/

//双向链表

typedef struct node

{

       char name[20];

       struct node *llink,*rlink;

}stud;

stud* creat(int n)

{

       stud *p,*h,*s;

       

       int size = sizeof(stud);

       if ((h= (stud*) malloc(size)) == NULL)

       {

              printf("malloc failt");

              exit(0);

       }

       //创建一个空的结构指针空间;

       h->name[0] = '\0';

       h->llink = NULL;

       h->rlink =NULL;

       p = h;

       for (int i=0;i<n;i++)

       {

              if ((s = (stud*) malloc(size)) == NULL)

              {

                     printf("malloc failt");

                     exit(0);

              }

              p->rlink = s;

              printf("请输入第%d个人的姓名",n+1);

              scanf("%s",s->name);

              s->llink = p;

              s->rlink = NULL;

              s= p;

       }

       h->llink =s;

       p->rlink = h;

       return (h);

}

/*

假若我们要在一个表头的双向循环链表中查找数据域为一特定值的某个结点时，

我们同样从表头结点往后一次比较各结点数据域的值，若正是该特定值，则返

回指向结点的指针，否则继续往后查，直到表尾。

*/

stud* seach(stud *h,char* x)

{

       stud *p;

       char *y;

       p = h->rlink;

       while(p != h)

       {

              y = p->name;

              if (strcmp(y,x) == 0)

              {

                     return (p);

              }

              else

              {

                     p= p->rlink;

              }

       }

       

       printf("没有查找到该数据");

}

void print(stud *h)

{

       stud *p;   

       p = h->rlink;

       

       printf("数据信息为：\n");

       while(p != h)

       {

              printf("%s ",&*(p->name));

              p=p->rlink;

       }

       printf("\n");

}

/*

对于双向链表，我们可以随意在某个结点前或后插入一个新的结点；

假诺s，p，q是连续三个结点的指针，若我们要p前插入一个新结点r，

则只需把s的右链域指针指向r，r的左链域指针指向s，r的右链域指针指向

p，p的左链域指针指向r即可。

*/

void insert(stud* p)

{

       char stuname[20];

       stud *s;

       if ((s= (stud*)malloc(sizeof(stud))) ==NULL)

       {

              printf("malloc Fail");

              exit(0);

       }

       printf("请插入人的姓名：");

       scanf("%s",stuname);

       strcpy(s->name,stuname);

       s->rlink = p->rlink;

       p->rlink = s;

       s->llink = p;

       (s->rlink)->llink =s;

}

/*

 删除某个结点，其实就是插入某个结点的逆操作，还是对于双向循环，要在连续三个结点

 s，p，q中删除p点，只需把s的右链域指针指向q，q的左链域指针指向s，并回收p结点。

*/

void del(stud *p)

{

       (p->rlink)->llink = p->llink;

       (p->llink)->rlink = p->rlink;

       free(p);

}

C语言实现双向链表

2009年03月23日 星期一 下午 03:34

/************双向链表*******/
#include <stdio.h>
#include <conio.h>

typedef struct LIST
{
int element;
        struct LIST *prior;
struct LIST *next;
}LIST;

LIST *Init_List            (void);           /** 建表 **/
int       Insert_List       (LIST *List, int i, int element); /** 插入元素 **/
int      Delect_List      (LIST *List, int i);      /** 删除元素 **/
LIST *Get_piout        (LIST *List, int i);
void   List_List          (LIST *List);           /** 打印表 **/
char   menu               (void);

int main (void)
{
       int i;
         int element;
       LIST *List;
        char choice;

       List = Init_List ();

        do
        {
                choice = menu ();
           
                switch (choice)
                {
                     case 'i':
                       case 'I':
                               printf ("i , element==>> ");
                                scanf ("%d%d", &i, &element); 
                               Insert_List (List, i, element);
                               break;
           
                       case 'd':
                        case 'D':
                                printf ("i==>> ");
                                scanf ("%d", &i);
                               Delect_List (List, i);  
                               break;
    
                       case 'l':
                       case 'L':
                                 List_List (List);
                                 break;
    
                        default :
                                 break;
                 }
       }while (choice != 'q' && choice != 'Q');

      return 0;
}
  
/**建表**/
LIST *Init_List (void)
{
      int i ;
      LIST *temp, *This, *List;

      List = (LIST *) malloc (sizeof(LIST));
      List->prior = List;     
      List->next = NULL;

      This = List;
      /* 表头插入法建有五个元素的表 */
      for (i = 1; i <= 5; ++i)
      {
              temp = (LIST *) malloc (sizeof(LIST));
   
              printf ("enter %d Node's date>>",i);
             scanf ("%d", &(temp->element));
          
               temp->prior = This;   
               temp->next = NULL;
              This->next = temp;
             This = temp;
      }

      return (List);
}

/** 插入表 **/
int Insert_List (LIST *List, int i, int element)
{
        LIST *This, *temp;

       This = Get_piout (List, i);

        temp = (LIST*) malloc (sizeof (LIST));

         temp->element = element;
        temp->prior = This;
       temp->next = This->next;
        This->next = temp;

         return 0;
}

/*** 删除元素 ***/
int Delect_List (LIST *List, int i)
{
       LIST *This, *p;

        This = Get_piout (List, i);

         p = This->next;
        p->next->prior = This ;
      This->next = p->next;
        free (p);

        return 0;
}

/**** 找位置函数 ***/
LIST *Get_piout(LIST *List, int i)
{
        LIST *This;
         int j = 0;

         This = List;

        while ((This != NULL)&& (j < i - 1))
         {
               This = This->next;
                ++j;
          }

         if ((This == NULL) || (j > i - 1))
         {
                 return 1;
          }

         return (List);
}

/****打印表***/
void List_List (LIST *List)
{
        LIST *q;

         q = List->next;

         if(q == NULL)
          {
                printf ("empty\n");
                getch();
                 return 1;
         }

         while (q->next != NULL)
         {
               printf ("%d,", q->element);
               q = q->next;
         }
        printf ("%d", q->element);
        getch();
}


char menu (void)
{
       char choice;

        system ("cls");
        printf ("----------------------------------\n");
         printf ("        i insert\n");
        printf ("        d delete\n");
       printf ("        l   list\n");
        printf ("\n\n");
        printf ("        q qiut\n");
        printf ("----------------------------------\n");
         printf ("------Your choice>>");
        scanf ("%c", &choice);

        fflush (stdin);
        return (choice);
}

投篮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-双向链表
qq_43714814的博客
12-12 1925
数据结构-双向链表
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6364
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
2.11线性表总结与提高
WithoutEndFree的博客
05-23 504
2.11线性表总结与提高 【主要知识点】 线性表的特征：线性表中每个数据元素有且仅有一个直接前驱和一个直接后继，第一个 结点无前驱，最后一个结点无后继。 线性表存储方式：实现线性表在计算机中的存放有顺序存储与链式存储两种方式。 线性表顺序存储（顺序表）：采用静态分配方式，借助于 C 语言的数组类型，申请一组连续的地址空间，依次存放表中元素，其逻辑次序隐含在存储顺序之中。因为线性表中元素类型相同（即占用空间相等），如果给定起始地址（即数组名）和元素下标，那么就可以方便地实现表中元素的存取。但当表长度变化时需
单向链表
CodePanda@GPF的博客
08-07 125
package singlelinkist; /** * Created by guipengfei on 2020/8/5 22:34 */ public class Node { int num; String name; Node next; public Node() { } public Node(int num,String name) { this.num=num; this.name=na
双向链表详解
子曰小玖的博客
04-26 2149
https://blog.csdn.net/cainv89/article/details/51301631 https://www.2cto.com/kf/201608/540936.html 1. 双向链表的概念 1.1 双向链表的定义 双向链表又称为双链表，是链表的一种。 1.2 双向链表的结点结构 双向链表的结点包括三个部分：前驱指针域、数据域和后继指针域。 (1)前驱指针域(...
04_双向链表_链表_declaredzfw_双向链表_
10-01
本文将深入探讨双向链表的概念及其在实际编程中的应用，以标题"04_双向链表_链表_declaredzfw_双向链表_"所提及的源码为例，结合"链表 declaredzfw 双向链表"的标签进行详细讲解。 双向链表（Doubly Linked List）...
doublelink.zip_C 双向链表_双向链表
09-22
在编程领域，双向链表是一种数据结构，它在链表的基础上增加了向前和向后移动的能力。与单链表相比，双向链表允许我们更高效地进行某些操作，比如插入和删除，因为它可以从两个方向遍历元素。下面我们将深入探讨...
sss.rar_sss_双向链表_链表_链表 插入
09-14
**双向链表详解** 双向链表是一种数据结构，与单链表类似，但它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表在某些操作上比单链表更加灵活，如正向和反向遍历。以下...
LinkLink_curd_Python双向链表_游标排序_
09-29
在IT领域，特别是编程中，双向链表是一种重要的数据结构，它在Python中被广泛用于实现各种算法和数据管理。本文将深入探讨Python双向链表的实现、操作以及如何使用游标排序。 双向链表与单链表的主要区别在于每个...
双向链表(简单介绍)
weixin_61898526的博客
04-18 3943
就是在单链表的的每个结点中，再设置一个指针域，也就是每个结点都有两个指针域，一个指向它的前驱结点，一个指向它的后继结点。 typedef struct DuLNode { type data ; struct DuLNode *prior ; // 前驱指针 struct DuLNode *next ;// 后继指针 }DuLNode , *DuLinkList; 双向链表也可以有循环链表。 那么对于双向循环链表来说，每个结点p都有两种表示自己的方...
数据结构复习（二）线性表（2）单链表
gs_upupup的博客
05-24 195
单链表定义 实现 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,* LinkList; 优缺点 优点：不需要大片的、连续的内存空间来存储。且改变容量很容易 缺点：无法随机存取，且需要额外的空间来存储节点的指针 初始化 不带头结点 //带头结点 bool InitList(LinkList &L){ ...
双链表详解
weixin_63246064的博客
02-15 6124
目录 一.双链表的定义 二.要实现的功能 三.功能实现 0、创建结点 1、初始化 2、打印 3、尾插 4、尾删 5、头插 6、头删 7、任意插入 8、任意删除 9、查找 四.全部代码的实现 1、text.c 2、List.c 3、List.h 一.双链表的定义 由图这就是一个双链表，可以看出它是一个由尾和头双向指向的环，且每个结点之间都是双向指向的。 二.要实现的功能 双链表是一种数据结构，所谓数据结构就是用来储存数据的工具，功能大致就和基本储存数据的
特殊的链表——双向链表
kxbdys的博客
04-05 4129
一、双向链表的概述 1、双向链表的定义：在单链表的每个结点里再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。 2、优点：双向链表可以克服单链表查找链表中某结点不方便的缺点。 3、双向循环链表：和单链的循环表类似，双向链表也可以有循环表。让头结点的前驱指针指向链表的最后一个结点，让最后一个结点的后继指针指向头结点。 二、双向链表的特点与算法操作 1、双向链表结构的对称性：设指针P指向某一结点，侧有： p->next->prior=p=p
双向链表(double linked list)
一个搬运知识的笨小孩
07-26 9325
双向链表 单链表寻找某结点的前驱结点时，必须遍历一遍链表，最坏的时间复杂度 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（
浅谈双向链表
wcqqq的博客
07-02 321
介绍双向链表的基础知识
C语言单链表
codeHaoHao的博客
10-31 2448
因为这一段时间在学数据结构与算法，而且这些东西也挺重要的，所以我也会多写一些这类的东西来加深一下自己的记忆
java创建双向链表_Java双向链表创建/输出---基础<Base>：
最新发布
05-18
双向链表是一种常见的数据结构，与单向链表相比，它可以在节点之间进行双向遍历。在Java中，我们可以使用类来实现双向链表。 下面是一个简单的Java程序，演示如何创建和输出双向链表： ```java // 双向链表节点类 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值