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

    2020-08-04 19:20:58
    双向链表的插入 参考来源:数据结构与算法基础(青岛大学-王卓)p38 算法实现: void ListInset_DuL(DuLinkList &L,int i,ElemType e){ if(!(p=GetElemp_DuL(L,i)))return error; s=new DuLnode; s->data = ...

    双向链表的插入

    参考来源:数据结构与算法基础(青岛大学-王卓)p38
    在这里插入图片描述

    算法实现:

    void ListInset_DuL(DuLinkList &L,int i,ElemType e){
    if(!(p=GetElemp_DuL(L,i)))return error;
    s=new DuLnode; s->data = e;
    s->prior = p->prior; //1
    p->prior->next = s; //2
    s->next = p; //3
    p->prior = s; //4

    return Ok;
    }

    在这里插入图片描述
    注:GetElemp_DuL(L,i) 返回插入位置i的地址值,并赋予给p

    展开全文
  • 双链表的插入

    2015-07-07 21:38:00
    双链表与单链表不同之处是 前者有两个根指针, 一个指向首结点, 一个指向尾结点. 后者只有一个, 指向首结点。 预编译 #include <stdlib.h> #include <stdio.h> #define status int #define TRUE...

    双链表与单链表的不同之处是 前者有两个根指针, 一个指向首结点, 一个指向尾结点.   后者只有一个,  指向首结点。

    预编译

    #include <stdlib.h>
    #include <stdio.h>
    #define status int
    #define TRUE 1
    #define FALSE 0

     

    typedef struct NODE{
        int value;            /* 存放结点值 */
        struct NODE *prev;  /* 指向前一个结点 */
        struct NODE *next;  /* 指向下一个结点 */
    }Node;
    数据结构
     1 /*
     2 功能描述:
     3     插入新结点( 从小到大 )
     4 
     5 参数:
     6     rootp -- 指向根结点的双指针
     7     new_value -- 要插入链表的新值
     8 
     9 返回值:
    10     如果插入成功,返回TRUE;
    11     否则,返回FALSE
    12 */
    13 status
    14 Insert( Node **rootp, int new_value )
    15 {
    16     Node *current = *rootp;    
    17     Node *_new = NULL;
    18 
    19     /* 寻找插入位置 */
    20     while ( current != NULL ){
    21         if ( current->value > new_value )
    22             break;
    23 
    24         if ( current->value == new_value ){
    25             printf( "值%d已存在\n", new_value );
    26             return FALSE;
    27         }
    28         current = current->next;
    29     }
    30 
    31     /* 创建新结点 */
    32     _new = (Node *)malloc( sizeof( Node ) );
    33     if ( _new == NULL ){
    34         printf( "内存不够\n" );
    35         return FALSE;
    36     }
    37     _new->value = new_value;
    38 
    39     /* 插入新结点 */
    40     if ( current == NULL ){
    41         if ( current == *rootp ){    /* 插入到空链表 */
    42             *rootp = _new;
    43             _new->prev = _new;
    44             _new->next = NULL;
    45         
    46         }else{                        /* 插入到尾部 */
    47             _new->next = NULL;
    48             _new->prev = (*rootp)->prev;
    49             (*rootp)->prev->next = _new;
    50             (*rootp)->prev = _new;
    51         }
    52     }else{
    53         if ( current == *rootp ){    /* 插入到根结点前 */
    54             _new->prev = (*rootp)->prev;
    55             _new->next = current;
    56             current->prev = _new;
    57             *rootp = _new;
    58 
    59         }else{                        /* 插入到中间某个结点前 */
    60             _new->prev = current->prev;
    61             current->prev->next = _new;
    62             _new->next = current;
    63             current->prev = _new;
    64         }
    65     }
    66 
    67     return TRUE;
    68 }
    插入代码

     

     1 /*
     2 功能描述:
     3     插入新结点( 从小到大 )
     4 
     5 参数:
     6     rootp -- 指向根结点的双指针
     7     new_value -- 要插入链表的新值
     8 
     9 返回值:
    10     如果插入成功,返回TRUE;
    11     否则,返回FALSE
    12 */
    13 status
    14 Insert( Node **rootp, int new_value )
    15 {
    16     Node *current = *rootp;    
    17     Node *_new = NULL;
    18 
    19     /* 寻找插入位置 */
    20     while ( current != NULL ){
    21         if ( current->value > new_value )
    22             break;
    23 
    24         if ( current->value == new_value ){
    25             printf( "值%d已存在\n", new_value );
    26             return FALSE;
    27         }
    28         current = current->next;
    29     }
    30 
    31     /* 创建新结点 */
    32     _new = (Node *)malloc( sizeof( Node ) );
    33     if ( _new == NULL ){
    34         printf( "内存不够\n" );
    35         return FALSE;
    36     }
    37     _new->value = new_value;
    38 
    39     /* 插入新结点 */
    40     if ( current == NULL ){            /* 插入根结点或尾结点 */
    41         if ( current != *rootp ){
    42             (*rootp)->prev->next = _new;        
    43         }
    44         _new->prev = (current == *rootp) ? _new : (*rootp)->prev;
    45         _new->next = NULL;
    46         ((current == *rootp) ? *rootp : (*rootp)->prev ) = _new; 
    47         
    48     }else{                            /* 插入到根结点或中间结点之前 */
    49         _new->prev = current->prev;
    50         ((current == *rootp) ? current->prev : current->prev->next ) = _new;
    51         _new->next = current;
    52         ((current == *rootp) ? *rootp : current->prev ) = _new;
    53     }
    54 
    55     return TRUE;
    56 }
    优化后的插入代码

     

    转载于:https://www.cnblogs.com/the-one/p/4628335.html

    展开全文
  • 双链表的插入和删除

    2020-10-25 19:47:40
    双链表的插入和删除 完成双循环链表的插入和删除函数 函数接口定义: bool insertDuList(List &L, Position p, ElementType d); bool delDuList( List &L, Position p ); 指针p指向待删除结点 指针p指向...

    双链表的插入和删除
    完成双循环链表的插入和删除函数
    函数接口定义:

    
    bool insertDuList(List &L, Position p, ElementType d);
    bool delDuList( List &L, Position p );
    
    

    指针p指向待删除结点
    指针p指向结点后插入新结点
    裁判测试程序样例:
    测试

    #include <stdio.h>
    #include <stdlib.h>
    #include <iostream>
    #define ERROR NULL
    using namespace std;
    typedef int ElementType;
    typedef struct LNode *PtrToLNode;
    struct LNode {
        ElementType data;
        PtrToLNode next;
        PtrToLNode prior;
    };
    typedef PtrToLNode List;
    typedef PtrToLNode Position;
    Position findPosition( List L, ElementType x );
    bool initDuList( List& L, ElementType X[], int n );
    bool insertDuList(List &L, Position p, ElementType d);
    bool delDuList( List &L, Position p );
    void printSeq(List L);
    bool initDuList( List& L, ElementType x[], int n ){
        List r =L;
        for( int i=0;i<n; i++){
            LNode* newNode = new LNode;
            newNode->data=x[i];
            newNode->next = L;
            newNode->prior = r;
            r->next = newNode;
            r=r->next;
            L->prior=r;
        }
        return true;
    }
    void printSeq(List L){
        List P=L;
        L=L->next;
        while(L!=P){
           cout<<L->data<<" ";
           L=L->next;
        }
        cout<<endl;
    }
    void printRevese(List L){
        List P=L;
        P=P->prior;
        while(P!=L){
           cout<<P->data<<" ";
           P=P->prior;
        }
        cout<<endl;
    }
    Position findPosition( List L, int i ){
        int j=0;
        while(L!=NULL && j<i){
            j++;
            L=L->next;
        }
        return L;
    }
    int main()
    {
        List L;
        ElementType x[10];
        int n;
        L = new LNode; L->next=L; L->prior = L;
        scanf("%d", &n);
        for(int i=0;i<n;i++){
            scanf("%d",&x[i]);
        }
        initDuList(L,x,n);
        //printf("****origin********\n");
        printSeq(L);
        printRevese(L);
        //输入插入位置
        int poi;
        scanf("%d",&poi);
        Position p = findPosition(L,poi);
        int newdata;
        scanf("%d",&newdata);
        insertDuList(L,p,newdata);
        //printf("\n****after insert ********\n");
        printSeq(L);
        printRevese(L);
        int delPoi;
        //输入删除位置
        scanf("%d",&delPoi);
        p = findPosition(L,delPoi);
        delDuList(L,p);
        //printf("\n****after delete ********\n");
        printSeq(L);
        printRevese(L);
        return 0;
    }
    
    
    
    /* 请在这里填写答案 */
    

    输入样例:
    在这里给出一组输入。例如:
    3
    1 2 3
    0
    55
    2

    输出样例:
    在这里给出相应的输出。例如:
    1 2 3
    3 2 1
    55 1 2 3
    3 2 1 55
    55 2 3
    3 2 55

    bool insertDuList(List &L, Position p, ElementType d){
     LNode* temp = new LNode;
     temp->data = d;
     temp->prior = p;
     temp->next = p->next;
     if(p->next!=NULL)
      p->next->prior = temp;
     p->next = temp;
     return true;
    } 
    bool delDuList( List &L, Position p ){
     if(p->prior==NULL)
      L = L->next;
     else if(p->next==NULL)
      free(p);
     else{
      p->prior->next = p->next;
      p->next->prior = p->prior;
      free(p);
     }
     return true;
    }
    展开全文
  • 双向链表的插入和删除

    万次阅读 多人点赞 2018-09-21 17:23:50
    双向链表的插入 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前 第二步:将节点 s 的前驱指向节点 p 的前驱,即 s-&gt;prior = p-&gt;prior; 第三步:将节点 p 的前驱的后继指向节点 s 即 p-&...

    双向链表的插入

    第一步:首先找到插入位置,节点 s 将插入到节点 p 之前

    第二步:将节点 s 的前驱指向节点 p 的前驱,即 s->prior = p->prior;

    第三步:将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s;

    第四步:将节点 s 的后继指向节点 p 即 s->next = p;

    第五步:将节点 p 的前驱指向节点 s 即 p->prior = s;

     

    双向链表的删除

    第一步:找到即将被删除的节点 p

    第二步:将 p 的前驱的后继指向 p 的后继,即 p->prior->next = p->next;

    第三步:将 p 的后继的前驱指向 p 的前驱,即 p->next->prior = p->prior;

    第四步:删除节点 p 即 delete p;

    展开全文
  • 双向链表的插入操作

    2019-10-08 16:22:26
    今天自己动手code了一下双向链表的插入操作,坑点不少,坑点都附在了注释后面了,接下来就不过多赘述了 LinkList(DuLinkList *L,int i,ElemType e) //DualNode *L 要换成DuLinkList *L { int j=0; DualNode *p=L....
  • 后面面试官又在我的其中一种方案上让我手写代码实现排序双线链表的插入,根据score值插入,并且链表长度限制在100。 需要考虑的点:1)插入在链表表头的;2)插入到链表表尾;3)插入到链表中间;4)需要在遍历...
  • 双链表的插入的实现

    2017-03-14 21:09:20
    还是一如既往先把这次例子的终极版展现出来://----------------------【双链表的插入(终极版)】--------------- //描述:通过创建双链表来进行新节点的插入 //-----------------------------------------------------...
  • 双向链表的插入 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前 (//箭头指向谁,是谁被存) 第二步:将节点 s 的前驱指向节点 p 的前驱,即 s->prior = p->prior; //p的前驱里面存放的是第...
  • 双向链表的插入及删除图解

    千次阅读 多人点赞 2018-01-31 14:20:43
    双向链表的插入 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前  第二步:将节点 s 的前驱指向节点 p 的前驱,即 s->prior = p->prior;  第三步:将节点 p 的前驱的后继指向节点 s 即 p->prior->...
  • 双向链表的插入 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前 第二步:将节点 s 的前驱指向节点 p 的前驱,即 s->prior = p->prior; 第三步:将节点 p 的前驱的后继指向节点 s 即 p->prior->next =...
  • 双向链表的插入,删除,mergesort等。#include&lt;iostream&gt; using namespace std; struct BiListNode { int val; BiListNode *pre; BiListNode *next; BiListNode(int x) :val(x), pre(NULL), next...
  • 如何实现双向链表的插入、删除操作  循环单链表的出现,虽然能够实现从任一结点出发沿着链能找到其前驱结点,但是时间复杂度为O(N)。如果希望能从链表中快速确定某一个结点的前驱,另一个解决方法就是在单链表的每...
  • 严蔚敏数据结构 P36页——双向链表的插入 /* 严蔚敏数据结构 P36页——双向链表的插入 */ //头文件 #include<stdio.h> #include<stdlib.h> //结构 typedef struct st { int data; //...
  • 双向链表的插入删除和查询

    千次阅读 2013-03-17 23:57:30
    实现双向链表的插入删除和查询,并写出测试用例。 #include #include using namespace std; /*** *实现双向链表的插入、查找、删除 *xx笔试算法题 ***/ typedef struct Node { int data; struct ...
  • 有序双链表的插入问题

    千次阅读 2012-10-30 01:45:13
    这里只讨论双链表(Doubly Linked List),更具体的说是有序双链表的插入问题。 所谓双链表,就是链表中每个节点含两个节点类型的指针,一个指向下一个节点,另外一个指向上一个节点。 链表节点数据结构定义如下: ...
  • 双向链表的插入与删除(c++实现)

    千次阅读 2020-04-30 16:28:13
    (https://blog.csdn.net/qq_36472818/article/details/96306824)进一步实现单向链表的插入、删除。 双向链表插入节点 在双向链表中插入新节点与单向链表相似,而根据新节点插入位置的不同,分为三种不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,578
精华内容 3,031
关键字:

双链表的插入