精华内容
下载资源
问答
  • 双向链表的查找

    千次阅读 2017-05-20 13:21:14
    #include #include typedef struct linknode//定义双向链表 { int data; linknode *prior,*next; } Node,*Linklist;...Linklist Createlist(int n);//建立双向链表 ...//在链表中查找值为x下标 void Sh
    #include <stdio.h>
    #include <malloc.h>
    
    typedef struct linknode//定义双向链表
    {
        int data;
        linknode *prior,*next;
    } Node,*Linklist;
    
    Linklist Createlist(int n);//建立双向链表
    int Find(Linklist L,int x);//在链表中查找值为x的下标
    void Showlist(Linklist L);//输出双向链表
    
    int main(void)
    {
        int n;
        scanf("%d",&n);
        Linklist L1=Createlist(n);
        Showlist(L1);
        printf("%d\n",Find(L1,5));
        return 0;
    }
    
    Linklist Createlist(int n)//建立双向链表
    {
        Linklist head=(Linklist)malloc(sizeof(Node));//申请头结点
        Node *p,*e;
        int x;
        p=head;//让p指向头结点
        for(int i=0; i<n; i++)
        {
            e=(Linklist)malloc(sizeof(Node));//申请新的节点
            scanf("%d",&x);
            e->data=x;
            p->next=e;//前一个节点的后继指向新的节点
            e->prior=p;//新节点的前驱指向上一个节点
            p=e;//始终让p指向当前节点
        }
        p->next=NULL;//最后一个节点的后继为空
        head=head->next;//头结点为空节点,所以向后移动一个
        head->prior=NULL;//头结点的前驱为空
        return head;//返回头结点
    }
    
    void Showlist(Linklist L)//输出双向链表
    {
        while(L)
        {
            printf("%d ",L->data);
            L=L->next;
        }
        printf("\n");
    }
    
    int Find(Linklist L,int x)
    {
        int i = 1;
        while(L != NULL && L->data != x )//寻找值为x的元素**注意这里循环的条件不能写反。原因,当L == NULL 时候 L->data会出错
        {
            i++;                    
            L= L->next;
        }
        if(L == NULL)               //如果没找到返回-1
            return -1;
        else 
            return i;              //如果找到返回i
    }
    

    展开全文
  • Java语言如何实现双向链表的查找、插入、删除、排序呢 Java语言如何实现双向链表的查找、插入、删除、排序呢
  • 双向链表的查找工作 解析: 使用next指针遍历,直到找到数据为data的节点,如果找到节点,返回节点,否则返回NULL; //查找节点,成功则返回满足条件的节点指针,否则返回NULL; Dbnode *FindNode(Dbnode *head,...

    双向链表的查找工作

    解析:

    使用next指针遍历,直到找到数据为data的节点,如果找到节点,返回节点,否则返回NULL;

    1. //查找节点,成功则返回满足条件的节点指针,否则返回NULL;
    2. Dbnode *FindNode(Dbnode *head,int data)
    3. {

          Dbnode *pnode=head;

          if(head==null)

            return NULL;

          while(pnode->next!=NULL &&pnode->data!=data)

            pnode=pnode->next;

          if(pnode->next==NULL)

            return NULL;

          return pnode;

        }

      在双向链表中节点p之前插入一个节点的操作运算如下(c描述):

        void DINSERT(DLINKLIST *p,Datatye x)

        {

          DLINKLIST *s;//插入节点

          s=(DLINKLIST *)malloc(sizeof(DLINKLIST));

          s->data=x;//存储数据x

          s->next=p;//s的next指针指向p

          p->prior->next=s;//p的前面的节点的next指向s

          s->prior=p->prior;//

          p->prior=s;

        }

     

    在双向链表中删除节点p:

      void DELETE(DLINKLIST *p)

      {

         p->prior->next=p->next;

         p->next-prior=p->prior; 

         free(p);

      }

     

      循环链表的许多操作都是在首尾位置进行的,因此使用指向循环链表末尾节点的指针来标志一个线性表,实现某些操作会更容易。使用rear来标志循环链表的末尾节点;例如:将俩个线性链表L1,L2合并成一个表时,使用设立尾指针的循环链表表示时,设表L1用rear1表示,L2为rear2表示,L2从L1末尾开始接,只需要下面五句话;

    p=rear1->next;q=rear2->next;rear1->next=q->next;rear2->next=p;free(q);

    转载于:https://www.cnblogs.com/hai5111/p/6228518.html

    展开全文
  • 双向链表的查找,排序程序

    千次阅读 2020-03-02 23:08:57
    双向链表在排序和查找时候,如果采用从两边开始查找或者排序需要解决奇偶问题,再考虑这个问题时候建议拿出笔在草稿纸上画图。 附上程序: #include <stdio.h> #include <stdlib.h>...

    双向链表相对于单向链表区别在于双向链表不但保存了下一个节点的地址还保存了上一个的地址,而单向链表只保存了下一个的地址;

    这样的话其实双向链表就是一个圆形,固定的头是我们人为设定的

    双向链表在排序和查找时候,如果采用从两边开始查找或者排序的需要解决奇偶的问题,再考虑这个问题的时候建议拿出笔在草稿纸上画图。

    连接:https://blog.csdn.net/qq_40082488/article/details/104622519

    附上程序: 

    #include <stdio.h>
    #include <stdlib.h>
    #include<string.h>
    typedef struct stu{
    int num;
    char name[20];
    int sorce;
    struct stu*p_front;
    struct stu*p_next;
    }STU;
    
    STU * double_link_inseart(STU*head,STU temp);//双向链表插入
    void double_link_printf(STU*head);//双向链表打印
    STU *double_link_find(STU*head,char *name);//双向链表的查找
    STU *double_link_order(STU *head);//双向链表的排序
    
    int main()
    {
        STU* head=NULL,*find_temp=NULL,student;
        int i;
        char find_name[20]="";
        for(i=0;i<3;i++)//输入学生信息
        {
            printf("学生信息:num,name,sorce\n");
            scanf("%d %s %d",&student.num,student.name,&student.sorce);
            head=double_link_inseart(head,student);
        }
    
        double_link_printf(head);//打印输出
    
        printf("-------排序-------\n");
        head=double_link_order(head);
        double_link_printf(head);
    
        printf("------查找--------\n");
        while(1)
        {
            printf("要查找的学生姓名\n");
            scanf("%s",find_name);
            find_temp=double_link_find(head,find_name);
            printf("%d %s %d\n",find_temp->num,find_temp->name,find_temp->sorce);
        }
        return 0;
    }
    //----------------------------------------------------
    STU* double_link_order(STU *head)
    {
        STU *ph,*pt,temp,temp2;
        ph=head;//先取出头的地址保存
         while(ph->p_front!=head)//标记尾巴,判断头最终位置是否完成一圈
        {
            pt=ph->p_front;//每次进入都拿头的成员分数进行从尾巴开始比对
            while(pt!=head)//从尾巴开始遍历
            {
    
                    if(head->sorce<pt->sorce)//从大到小排序
                {
                    temp=*head;//先取出头里面的成员
                    *head=*pt;//再对头重新赋值,前后指向变化了
                    head->p_front=temp.p_front;//改回原来的指向
                    head->p_next=temp.p_next;
                    temp2=*pt;//同上理
                    *pt=temp;
                    pt->p_front=temp2.p_front;
                    pt->p_next=temp2.p_next;
    
                }
                pt=pt->p_front;//比对,从尾巴开始往上找
            }
            head=head->p_next;//每完成一次内循环,头向下移动一个
    
        }
         return ph;
    }
    STU * double_link_inseart(STU*head,STU temp)
    {
        STU*stu_temp,*p,*pt;
        stu_temp=calloc(1,sizeof(STU));//申请空间
        *stu_temp=temp;//把要存的内容放入申请的空间
        p=head;//把头地址放进P保存
        if(head==NULL)//判断链表头有没有数据
        {
           head=stu_temp;
           head->p_next=head;
           head->p_front=head;
        }else
        {//头部之后加节点
            pt=p->p_next;//先保存头后面的地址
            p->p_next=stu_temp;//再更改头的next
            stu_temp->p_front=p;//更改新元素的上一个是头
            pt->p_front=stu_temp;//原头的下一个的上一个改为新元素
            stu_temp->p_next=pt;//新元素的下一个是上一个头的next
        }
        return head;
    }
    void double_link_printf(STU*head)
    {
        STU *temp;
        temp=head;
        do{
        printf("%d %s %d\n",temp->num,temp->name,temp->sorce);
        temp=temp->p_next;
        }while(head!=temp);
    
    }
    STU *double_link_find(STU*head,char *name)
    {
        STU *pf;
        pf=head->p_front;
        while(strcmp(head->name,name)!=0&&strcmp(pf->name,name)!=0&&head!=pf&&head->p_next!=pf)
        {
        //从两头开始查找,同时判断头尾,并且在奇数情况下不允许相等,在偶数情况下防止死循环
            head=head->p_next;
            pf=pf->p_front;
        }
    //处理奇数和偶数的情况
        if(strcmp(head->name,name)==0)
        {
            return head;
        }
        else if(strcmp(pf->name,name)==0)
        {
            return pf;
        }
        return NULL;
    }
    

     

    展开全文
  • 数据结构-编程实现一个双向链表的查找 1:代码如下: // ConsoleApplication24.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<malloc.h> #include <iostream> #include &...

    数据结构-编程实现一个双向链表的查找

    1:代码如下:

    // ConsoleApplication24.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include<malloc.h>
    #include <iostream>
    #include <assert.h>
    using namespace std;
    
    typedef struct DbNode //双向链表结构体
    {
        int data;//节点数据
        DbNode *left;//前驱节点指针
        DbNode *right;//后继节点指针
    }DbNode;
    
    DbNode *CreateNode(int data)//创建一个节点,返回新创建的节点
    {
        DbNode *pnode = (DbNode*)malloc(sizeof(DbNode));
        pnode->data = data;
        pnode->left = pnode->right = pnode;//初始化的节点的前驱和后继都等于本身的地址
        return pnode;
    }
    
    DbNode *CreateList(int head)//创建一个链表头,参数给出表头节点数据,表头节点不作为存放有意义数据的节点
    {
        DbNode *pnode= (DbNode*)malloc(sizeof(DbNode));
        pnode->data = head;
        pnode->left =  pnode;
        pnode->right = NULL;
        return pnode;
    }
    
    /*插入新节点,总是在表尾插入;返回表头节点*/
    DbNode *AppendNode(DbNode *head, int data)//参数1是链表的表头节点,参数2是要插入的节点,其数据为data
    {
        DbNode *node = CreateNode(data);//创建数据为data的新节点
        DbNode *p = head, *q=NULL;
        while (p != NULL)//循环结束后,最后一个节点是q,p是q的right
        {
            q = p;
            p = p->right;
        }
        /*---在双向链表尾部插入新节点的方法---*/
        q->right = node;
        node->left = q;
        node->right = NULL;
        /*---*/
        return head;
        
    }
    
    void PrintList(DbNode *head)//打印整个链表
    {
        DbNode *pnode = NULL;
        if (head == NULL)//链表为空
        {
            return;
        }
        pnode = head;
        while (pnode != NULL)
        {
            printf("%d", pnode->data);
            pnode = pnode->right;
        }
        printf("\n");
    }
    
    int GetLength(DbNode *head)//双向链表的测长,参数为链表头节点
    {
        int count = 1;
        DbNode *pnode = NULL;
        if (head==NULL)//head为NULL表示链表空
        {
            return 0;
        }
        pnode = head->right;
        while (pnode != NULL)
        {
            pnode = pnode->right;//使用right指针遍历
            count++;
        }
        return count;
    }
    
    /*查找节点,成功返回满足条件的节点指针,否则返回NULL*/
    DbNode *FindNode(DbNode *head, int data)//参数1是链表的头结点,参数2是要查找的节点,其数据为data
    {
        DbNode *pnode = head;
        if (head == NULL)//head为NULL表示链表空
        {
            return NULL;
        }
        /*找到数据或者到达链表末尾,推出while循环*/
        while (pnode->right != NULL && pnode->data != data)
        {
            pnode = pnode->right;//使用right指针遍历
        }
        //没有找到数据为data的节点,返回NULL
        if (pnode->right == NULL)
        {
            return NULL;
        }
        return pnode;
    }
    
    
    int main()
    {
        /*---生成从0-9含有10个节点的循环链表---*/
        DbNode *head = CreateList(0);//生成链表头
        for (int i = 1; i < 10; i++)
        {
            head = AppendNode(head, i);//添加9个节点,数据为从1到9
        }
        PrintList(head);
    
        cout << "找到数据为2的节点,地址为:" << FindNode(head, 2) << endl;
        cout << "数据为:" << FindNode(head, 2)->data << endl;
        return 0;
    }

    View Code

    运行结果:

    posted @ 2017-09-27 17:48 一串字符串 阅读(...) 评论(...) 编辑 收藏

    展开全文
  • 代码实现 st_doubNode* searchDoubListNode(st_doubNode* head, int num){ if(NULL == head){ return NULL; } st_doubNode* p = NULL; st_doubNode* q = NULL; p = head; while(NULL !...data...
  • 查找过程中循环条件变化 插入元素过程中指针运算 在表建好以后,调用GetElemP_DuL()函数查找第i个元素,返回第i个元素地址,否则返回空指针。 如图: 程序: #include<stdio.h>#include<...
  • 双向链表的查找、删除、插入节点

    千次阅读 2018-06-21 00:04:47
    双向链表前插入无需定位到节点前一位,因为其本身有prior指针。从根本上来讲,它和单链表是类似:#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct student { int num; ...
  • 构建循环链表 Head->front= stu; tail ->back= Head; } while (strcmpi(stu->name, " exit " )!= 0 ); // 初始指针p 使他头结点Head // stu=Head->back; // do // { // printf("%s,到校时间:%d...
  • 文章摘自http://www.rzchina.net/forum/34考点:双向链表的操作出现频率:★★★★解析:使用right指针遍历,直至找到数据为data的节点,如果找到节点,返回节点,否则返回NULL。1 //查找节点,成功则返回满足条件...
  • C/C++面试题大全 进入名企的敲门砖(连载)双向链表的查找节点。考点:双向链表的操作出现频率:★★★★解析:使用right指针遍历,直至找到数据为data的节点,如果找到节点,返回节点,否则返回NULL。1 //查找节点...
  • 主要介绍了c++双向链表操作示例,包括创建双向链、删除双向链表双向链表查找数据、插入数据等,需要朋友可以参考下
  • 原因是双向链表的每个节点都有两个指向其他节点的引用。但这也是其缺点,因为在插入、删除的时候需要处理四个链接点的引用, 占用的空间也大了一些。如将头节点和尾节点链接起来,即成为双向循环链表。下面是java...
  • 算法中常常会涉及循环链表和双向链表这些特殊的链表,对于循环链表来说,从表中任意节点出发均可以找到...1.单循环链表的查找操作public Lnode get(char x){Lnode p = h.next;while(p!=null&&p.data!=x)p...
  • * 把二元查找树转变成排序的双向链表 - by Chimomo * * 【思路】按照二叉树中序遍历正好是按从小到大地顺序遍历全部节点。在遍历过程中,更改它逻辑结构。 */ #include &lt;iostream&gt; ...
  • 双向链表:java实现双向链表的增删改 单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找 单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除 1、遍历方和单链表一样,只是可以...
  • 输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新结点,只能调整树中结点指针指向。这个题目有两种方法,一是递归,另外就是利用栈;我们知道排序树中序遍历结果就是排序,本...
  • 出题:把二元查找树转变成排序的双向链表。输入一棵二元查找树,要求将该二元查找树按照中序转换成一个排序的双向链表,要求不能创建任何新节点,只能调整指针指向; 分析: 递归思路,当前节点需要进行...
  • 把二元查找树转变成排序的双向链表题目:输入一棵二元查找树,将该二元查找树转换成一个排序的双向链表。要求不能创建任何新结点,只调整指针指向。10/ \6 14/ \ / \4 8 12 16转换成双向链表4=6=8=10=12=14=16。...
  • 双向链表 引言 页面的前进与回退 已知某指针q的位置,求指针p。 由于单链表节点中只有一个指向其直接后继结点的...双向链表的基本操作 //定义结构体变量 typedef struct node{ int data; //data域存放数据 str
  • 题目:输入一棵二元查找树,将该二元查找树转换成一个排序的双向链表。要求不能创建任何新结点,只调整指针指向。比如将二元查找树转换成双向链表4=6=8=10=12=14=16题目来源:链接中解决方法其实已经说很...
  • 双向链表的创建查找与删除元素

    千次阅读 2016-05-14 23:46:06
    双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
  • 添加(默认添加到双向链表的最后) (1).先找到双向链表的最后这个节点(temp) (2).temp.next = newHeroNode (3).newHeroNode.pre = temp; 修改思路和单链表一样 删除 (1).以为是双向链表,因此,我们可以...
  • 双向链表

    2021-02-24 18:39:52
    双向链表一、双向链表的概述1.1 什么是双向链表1.2 双向链表和单向链表的区别二、双向链表的应用2.1 添加节点2.2 修改节点2.3 删除节点 一、双向链表的概述 1.1 什么是双向链表 双向就是链表由单向的链变成了双向链...
  • 双向链表相比单链表,节点多了一个pre指向前一个节点的地址添加节点思路遍历方和单链表-样,只是可以向前,也可以向后查找添加(默认添加到双向链表的最后)先找到双向链表的最后这个节点temp.next =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,977
精华内容 1,190
关键字:

双向链表的查找