精华内容
下载资源
问答
  • [数据结构]双链表删除结点P的操作

    千次阅读 2014-08-14 15:07:05
    算法的思想就是:把P的前驱

    算法的思想就是:把P的前驱结点接上P的后继节点。然后P的后继节点的前驱节点指向P的前驱节点。这个时候P就被架空了。此时释放P.


    代码:

    void DDeleteNode(DListNode *p){
    		//假设*P非最后的尾结点
    		p->prior->next = p->next;//P的前置节点的后继节点指向P的后继节点
    		p->next->prior = p->prior;//P的后置节点的前驱节点指向P的前驱节点
    		free(p);//释放P
    	}


    展开全文
  • 双向链表实现结点

    2018-04-11 08:47:19
    定义、实现并测试一个双向链表结点类DNode。...编写主程序:输入不少于3组x、y整数,分别利用左侧和右侧插入结点函数组织数据为双向链表,测试输出链表中每个结点的左侧和右侧相邻节点内容,测试对左右侧结点删除
  • 循环双链表删除结点,删除值为num的所有结点 关于遍历循环双向链表删除特定结点的问题,我一直没在网上看到能成功的在我的编辑器上运行的代码,于是自己写了一个,逻辑比较啰嗦,但能成功运行,我把几个边界点单独拿...

    循环双链表删除结点,删除值为num的所有结点

    关于遍历循环双向链表删除特定结点的问题,我一直没在网上看到能成功的在我的编辑器上运行的代码,于是自己写了一个,逻辑比较啰嗦,但能成功运行,我把几个边界点单独拿出来讨论的。

    下面是代码

    #include <iostream>
    using namespace std;
    class linknode {
    public:
        int data;
        linknode* next, * prev;
        linknode(int info = 0, linknode* nextpr = NULL, linknode* prevpr = NULL)
        {
            data = info;
            next = nextpr;
            prev = prevpr;
        }
    };
    class linklist {
    public:
        linknode* head, * tail;
        linklist()
        {
            head = tail = NULL;
        }
        void push(int num)
        {
            if (head == NULL) {
                head = tail = new linknode(num);
                head->next = NULL;
                tail->next = head;
            }
            else {
                linknode* p = new linknode(num);
                tail->next = p;
                p->prev = tail;
                tail = p;
                tail->next = head;
            }
        }
        void deletelinknode(int num)
        {
            linknode* p = this->head;
            linknode* q = p->next;
            for (; p->next != head; p = q)
            {
                q = q->next;
                if (p->data == num)
                {
                    if (p == head)
                    {
                        head = p->next;
                        p->next->prev = tail;
                        tail->next = p->next;
                        delete p;
                    }
                    else
                    {
                        p->prev->next = p->next;
                        p->next->prev = p->prev;
                        delete p;
                    }
                }
            }
            if (p == tail)
            {
                if (p->data == num)
                {
                    tail = p->prev;
                    p->prev->next = p->next;
                    p->next->prev = p->prev;
                    delete p;
                }
            }
        }
        void display()
        {
            if (head == tail) {
                return; //说明没有元素,直接返回即可
            }
            for (linknode* p = head;; p = p->next) {
                if (p == tail) {
                    cout << tail->data << endl;
                    break;
                }
                cout << p->data << " ";
            }
        }
    };
    
    int main()
    {
        linklist ll;
        int count, value;
        cin >> count;
        for (int i = 0; i < count; i++) {
            cin >> value;
            ll.push(value);
        }
        cout << "初始值为:";
        ll.display();
        cin >> value;
        ll.deletelinknode(value);
        cout << "删除值为" << value << "的结点后为:";
        ll.display();
        return 0;
    }
    

    欢迎交流和指正

    展开全文
  • 内存中一片连续空间(不妨假设地址从1到m),提供给两个栈S1和S2使用,怎样分配这部分存储空间,使得对任一个栈,仅当这部分空间全满时才发生上溢。
  • 这里是节选的我看完课程后自己再写一次的双链表里面的删除结点的一段代码 int delete_node(dlnode *pHeader,int data) { dlnode *p = pHeader; if(NULL == p) { return -1; } while(NULL != p->pNext)...

    这里是节选的我看完课程后自己再写一次的双链表里面的删除结点的一段代码

    int delete_node(dlnode *pHeader,int data)
    {
    	
    	dlnode *p = pHeader;
    	if(NULL == p)
    	{
    		return -1;
    	}
    	
    	while(NULL != p->pNext)
    	{
    		p = p->pNext;
    		if(p->data == data)
    		{
    			if (NULL == p->pNext)
    			{
    				// 尾节点
    				// p表示当前节点地址,p->pNext表示后一个节点地址,p->pPrev表示前一个节点的地址
    				p->pPrev->pNext = NULL;
    				//p->pPrev = NULL;			可以省略,因为后面整个都被销毁了
    				// 销毁p节点
    				//free(p);
    			}
    			else
    			{
    				p->pPrev->pNext = p->pNext ;//把被删除的结点的前结点的pNext与后结点连起来
    				p->pNext->pPrev = p->pPrev;	//把被删除的结点的后结点的pPrev与前结点连起来
    			//p->pPrev = NULL;
    			//p->pNext = NULL;
    			
    			}
    			free(p);
    			
    			return 0;	
    		}
    	}
    	
    	printf("未找到该结点\n");
    	return -1;
    }
    

    目前这段代码运行是正常的,已经找过课程代码对比修改过了
    说说问题所在吧
    1.我之前想的时候没有注意把这个函数写成一个有返回值的函数,写成了void类型,当然,那时候我也没有写return。但是想起课程里面说如果传进来的头结点是一个NULL的话那就会报错了,因为NULL的pNext是没有分配到的。所以在前面加上一个if来判断是否是NULL。
    这里if判断之后可以不加return的,但是如果要判定正确0错误-1这样的话最好就加上return 0 return -1,网上查过0代表正确-1代表有误(大概这样吧)如果有返回值的话函数的返回值类型就得写成相应的类型,不能是void了,这里的话就是int类型。

    2.可能是没有连贯着写这段代码的原因吧,我没注意到我最后main函数里面的是前插,比如说前插顺序是33 2 1,向后遍历出来的就是1 2 33了,所以当我删除的33的时候我还以为是删除的第一个结点,运行的时候出现了段错误,其实并不是这样,我删除的33是最后一个结点,即尾结点,这时候我的while循环里面是没有判断是否为尾结点这一个判断条件的,因为不加上的话,尾结点的pNext就是NULL了,不存在后面的->pPrev了,所以编译虽然没错,但是运行起来就会出现段错误。后面我从课程代码里面吧这个if判断尾结点的拉过来了,然后就没出现段错误了。

    总结一下:
    大体的思路还算是清晰的,起码删掉结点之后要怎么连接前后结点这些还是没问题的,但是前面的判断头结点是否为NULL,或者尾结点的判断,这些尽管在看课程的时候是懂的,但是过后自己再写一次的时候就没有注意到,可能当时的印象不深刻吧。通过这次自己再写一次之后印象深刻了很多,对很多的基础知识也得到了运用。

    继续加油!

    展开全文
  • 双向链表结点的插入和删除算法

    万次阅读 多人点赞 2018-10-03 23:47:46
    双向链表的插入与删除 双向链表结点定义 #define ElemType int //双向链表的存储结构 typedef struct DuLNode ...双向链表结点删除 ...画图表示,并在上述双向链表中一个已知结点p之后插入一个结...

    双向链表的插入与删除

    双向链表的结点定义

    #define  ElemType int
    //双向链表的存储结构
    typedef struct DuLNode
    {
        ElemType data;
        DuLNode *prior;
        DuLNode *next;
    }DuLNode, *DuLinkList;
    

    双向链表的结点插入

    画图表示,并在上述双向链表中一个已知结点p之后插入一个结点s的四条语句,请标明先后顺序。

    在p之后插入结点s

    对应的代码片段为:

    //在第i个结点p之后插入s,数据域是e的结点
    void ListInsert_DuL(DuLinkList &L, int i,ElemType e)
    {    
        DuLNode *p;
        p = GetElem_DuL(L,i);//在L中确定第i个元素的位置指针p
        //新建一个结点
        DuLNode *s;
        s = new DuLNode;
        s->data = e;
        //插入
        s->prior = p;
        p->next->prior = s;
        s->next = p->next;
        p->next = s;
     }
    

    双向链表插入算法的注意事项:插入新结点的核心步骤为修改四个指针,要保证在插入的过程中不能断开链表原来的链,否则链表就断链了。

    双向链表的结点删除

    画图表示,并在上述双向链表中删除一个已知结点p的两条语句,请标明先后顺序。
    删除结点p
    对应的代码片段为:

    //在双向链表中删除第 i个结点
    void ListDelete_DuL(DuLinkList &L, int i)
    {
        DuLNode *p;
        p = GetELem_DuL(L,i);在L中确定第i个元素的位置指针p
        //重建链
        p->prior->next = p->next;
        p->next->prior = p->prior;
        //删除p结点
        delete p;
    }
    

    双向链表删除算法的注意事项:插入新结点的核心步骤为修改只需要修改两个指针,方法简单,注意释放结点p的空间即可。

    作者practical_sharp
    第一次写博客,有很多做的不周到地方,不喜勿喷。

    展开全文
  • 双链表删除节点

    千次阅读 2021-02-22 15:22:20
    编写一个程序,从双链表中移除一个节点,函数的原型如下 int dll_remove(struct NODE *rootp, struct NODE *node); 你可以假设节点数据结构在头文件double_linked_list_node.h文件中定义,函数第一个参数是一个...
  • 带头结点双向链表的内存分布情况 头文件 #pragma once //双向链表 typedef struct DNode { int data; DNode* next; DNode* prio; }DNode , *DList ; //初始化 void InitList(DList plist); //头插法 bool ...
  • 文章目录总结归纳代码实现 总结归纳 在 InsertPriorNode 函数(前插操作)中,如果想在表尾处插入结点,则无法进行,需要特殊处理,比较简单,这里没有写出;...循环双链表(带头结点) */ #include <ios
  • 数据结构:双链表的创建,在P结点前后插入结点,删除P前后的结点以及P结点 提到链表的首元结点,我们首先想到的是head标志的结点,但其实head结点只是人为规定的,首元结点既可以定义为head也可以定义为end,尾元...
  • 双链表删除节点操作)

    千次阅读 2020-12-10 20:54:32
    双链表删除第i个节点算法如下: 首先要会: ...假设删除双链表L中*p 节点 , 的 后继节点 (我们将用q表示 — q = p->next;) 1.首先我们还是先查找 i-1 个节点 2.然后判断该位置是否为空,是,则返回
  • 本题要求实现两个函数,分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表链表结点定义如下: struct ListNode { int data; ListNode *next; }; 函数接口定义: struct ListNode *...
  • 在双向链表存储结构中,删除p所指的结点时须修改指针()【MOOC选择题】
  • 双向链表主要注意: 1、插入节点要考虑到是在第1个节点和最后一个节点上,或者是中间,因情况不同处理的方法也不同 2、移除链表上的一个节点要考虑是1个节点还是最后一个节点上,或者是中间,因情况不同处理的方法也...
  • 本小程序是对于循环双向链表删除指定元素 考虑几种边界情况!
  • 基本操作4.1 初始化双链表4.2 判空4.3 查找操作4.3.1 按位查找4.3.2 按值查找4.4 插入操作4.4.1指定结点插入4.4.1.1后插4.4.1.1.1 给结点4.4.1.1.2 给元素值4.4.1.2 前插4.4.2 按位插入4.5 删除操作4.6 创建双链表...
  • 在双向链表存储结构中,删除p所指的结点时需修改指针的操作为 p-&gt;next-&gt;prior=p-&gt;prior; p-&gt;prior-&gt;next=p-&gt;next; p-&gt;next=p-&gt;next-&gt;next;p-&...
  • 删除循环链表的x结点的前驱结点

    千次阅读 2019-07-19 20:13:27
    void Del_x_prior(LNode *x){ LNode *p=x; //工作指针 LNode *r=p; //用于保存p的前驱结点 while(p->next!=x){ r=p; p=p->next; } r->next=x; free(p); } ...
  • 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前 第二步:将节点 s 的前驱指向节点 p 的前驱,即 s->prior = p->prior; 第三步:将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s; 第四步...
  • 双向链表插入、删除节点(详细图解+代码)

    千次阅读 多人点赞 2020-02-01 20:36:36
    双向链表 在单链表的基础上增加了前缀结点,一定程度上提升了查找元素的速度 在查找元素时,可以反向查找前缀结点 插入结点过程(分为4步) ...这四个步骤的顺序可调整,但是必须要保证...删除结点(分两步) ...
  • 编写C函数,实现双向链表删除一个节点P。 //删除操作 Status ListDelete_Dul(DuLinkList &amp;L,int i,ElemType &amp;e) { if(!(p=GetElemP_DuL(L,i))) return Error; e=p-&gt;data; p-&gt;...
  • 循环双链表删除第一个值为x的结点

    千次阅读 2017-09-26 21:40:51
    #include using namespace std; int const NONE = 0; int const DONE = 1; /* run this program using the console pauser or add your own getch, system("pause") or input loop */ ...//结点 class N
  • 删除双向链表的头

    2016-04-12 22:47:37
    双向链表
  • 删除给定索引的数据元素。 给定索引index ,数据元素x,将x插入到index的位置。 C++:设计一个结构体struct chainNode,再设计一个具体类 class doubleChain 作为抽象类 class linearList的派生类实现类linearList中...
  • 文章目录双链表与循环链表双链表单链表 VS 双链表双链表的初始化(带头结点)双链表的插入双链表删除双链表的遍历循环链表循环单链表循环双链表 双链表与循环链表 双链表 单链表 VS 双链表 单链表:无法逆向检索,...
  • 知识点:循环链表构造,删除结点 题目描述 N 个人围成一圈顺序编号,从1 号开始按1、2、3 顺序报数,报3 者退出圈外,其余的人再从1、2、3 开始报数,报3 的人再退出圈外,依次类推。请按退出顺序输出每个退出人的...
  • 双向链表——插入、删除指定位置和相同节点
  • 什么是双向循环链表 1、拥有两个指针域prior以及next,一个数据域data 2、尾部的next指针 指向头结点 存储结构 typedef struct DuLNode { ElemType data;...带头结点双链循环表创建 1、创建头结点 2、在循环...
  • 带有头结点的双向链表

    千次阅读 2017-03-14 10:11:24
    //带有头结点的双向链表 typedef int ElemType; typedef struct DuLNode {  ElemType data;  DuLNode *prior,*next; }DuLNode,*DuLinkList;   //创建带有头结点的线性双向链表 void InitList...
  • 删除链表中的结点

    2021-01-25 21:08:51
    给你一个链表删除链表的倒数第 n 个结点,并且返回链表的头结点。 进阶:你能尝试使用一趟扫描实现吗? 示例 1: 输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5] 示例 2: 输入:head = [1], n = 1 输出:[] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,845
精华内容 10,338
关键字:

双链表删除p结点