精华内容
下载资源
问答
  • 双向链表节点交换

    千次阅读 2019-09-19 17:25:28
    天关于双向链表节点交换,用了很长的时间去学习,理解,敲了好多次,总是达不到效果,就是能想明白,但是在写的时候不是出现这样就是那样的问题,最后参照另外一位CSDN博主的帖子,才写出一个完整的函数, ...

    这两天关于双向链表的节点的交换,用了很长的时间去学习,理解,敲了好多次,总是达不到效果,就是能想明白,但是在写的时候不是出现这样就是那样的问题,最后参照另外一位CSDN博主的帖子,才写出一个完整的函数,

    贴上代码,以便自己以后随时查看,没有图.

    void swap(USERINFO *head,USERINFO *left,USERINFO *right)
    {
    	USERINFO *temp;
    	if (right->next == NULL) //t结点是否为尾结点
    	{
    		if (left->next == right) //p,t结点是否相邻
    		{
    			//与尾结点相邻的交换代 
    			right->next = left;
    			right->pre = left->pre;
    			left->next = NULL;
    			left->pre->next = right;
    			left->pre = right;
    		}
    		else
    		{
    			//与尾结点不相邻的交换代 
    			right->next = left->next;
    			right->pre->next = left;
    			temp = right->pre;
    			right->pre = left->pre;
    			left->next->pre = right;
    			left->next = NULL;
    			left->pre->next = right;
    			left->pre = temp;
    		}
    	}
    	else
    	{
    		if (left->next == right) //p,t结点是否相邻
    		{
    			//相邻的交换代 
    			right->next->pre = left;
    			temp = right->next;
    			right->next = left;
    			right->pre = left->pre;
    			left->next = temp;
    			left->pre->next = right;
    			left->pre = right;
    		}
    		else
    		{
    			//不相邻的交换代 
    			right->next->pre = left;
    			temp = right->next;
    			right->next = left->next;
    			left->next->pre = right;
    			left->next = temp;
    			right->pre->next = left;
    			temp = right->pre;
    			right->pre = left->pre;
    			left->pre->next = right;
    			left->pre = temp;
    		}
    	}
    }
    

     

    展开全文
  • 双向链表两个结点互换位置(链表–数据结构) 双向链表两个结点互换位置 /*struct Node { int value; Node *next; Node *prev; };*/ /*交换 buffer 和 i 个结点(buffer在i右端)i---->buffer */ Node *temp; ...

    双向链表两个结点互换位置(链表–数据结构)

    双向链表两个结点互换位置

    /*struct Node
    {
     int value;
     Node *next;
     Node *prev;
    };*/
    
    /*交换 buffer 和 i 两个结点(buffer在i右端)i---->buffer  */
    
        Node *before; //before 在i前面的结点
        Node *after; //after 在buffer后面的结点
        if (buffer->next == NULL)//若buffer是链表结尾
        {
         before = i->prev;
         buffer->next = i;
         buffer->prev = before;
         i->next = NULL;
         i->prev = buffer;
         before->next = buffer;
        }
        else
        {
         before = i->prev;
         after = buffer->next;
         after->prev = i;     
         buffer->next = i;
         buffer->prev = before;
         i->next = after;
         i->prev = buffer;
         before->next = buffer;
         }
    展开全文
  • 双向循环链表两节点交换的原则

    千次阅读 2015-10-31 15:55:36
    假设q是p的前驱结点;  总共分三阶段  1.p与新前驱建立联系  q->llink->rlink=p; p->link=q->llink; 2.q与新后驱建立联系  ...:总结一下其实在交换过程中要注意的就是不能丢掉前后端结点的
    假设q是p的前驱结点; 
    
    总共分三阶段 
    1.p与新前驱建立联系 
    q->llink->rlink=p;
    p->link=q->llink;

    2.q与新后驱建立联系 
    p->rlink->llink=q;
    q-rlink=p->rlink;

    3.p与q互连
    p->rlink=q;
    q->llink=p;

    :总结一下其实在交换过程中要注意的就是不能丢掉前后两端结点的地址, 
    也就是说在任何时间都应该可以得到两端的结点
    展开全文
  • 双向链表交换节点

    2019-09-20 22:53:48
    交换index // 更改prev next if (attrFromNode.prev) { attrFromNode.prev.next = targetNode; } if (attrTargetNode.next) { attrTargetNode.next.prev = fromNode; } targetNode.prev =...
            switchChainNode(fromNode, targetNode) {
                let attrFromNode = {
                    index: fromNode.index,
                    prev: fromNode.prev,
                    next: fromNode.next
                };
                let attrTargetNode = {
                    index: targetNode.index,
                    prev: targetNode.prev,
                    next: targetNode.next
                };
    
                let isSibling = attrTargetNode.prev === fromNode;
                // 交换index 
                // 更改prev next
    
                if (attrFromNode.prev) {
                    attrFromNode.prev.next = targetNode;
                }
    
                if (attrTargetNode.next) {
                    attrTargetNode.next.prev = fromNode;
                }
    
                targetNode.prev = attrFromNode.prev;
                fromNode.next = attrTargetNode.next;
    
                if (isSibling) {
                    targetNode.next = fromNode;
                    fromNode.prev = targetNode;
                } else {
                    targetNode.next = attrFromNode.next;
                    fromNode.prev = attrTargetNode.prev;
    
                    if (attrTargetNode.prev) {
                        attrTargetNode.prev.next = fromNode;
                    }
                    if (attrFromNode.next) {
                        attrFromNode.next.prev = targetNode;
                    }
                }
    
                fromNode.index = attrTargetNode.index;
                targetNode.index = attrFromNode.index;
            }

     

    转载于:https://www.cnblogs.com/vaal-water/p/10245611.html

    展开全文
  • 双向链表中的交换节点

    千次阅读 2016-03-13 11:26:25
    双向链表交换两节点的值 struct node* temp; //定义一个中间结构体存储q->last和p->next temp->last=q->last; temp->next=p->next; p->next=q->next; q->last->next=p; p->last->next=q; q->next=...
  • 将给定的链表中每个相邻的节点交换一次,返回链表的头指针例如,给出1->2->3->4,你应该返回链表2->1->4->3。你给出的算法只能使用常量级的空间。你不能修改列表中的值,只能修改节点本身。 /* ...
  • 无空头链表通过下标交换节点void swapbypoint(int index1, int index2) { if (pHead == NULL || pHead->pNext == NULL || index1 < 0 || index2 < 0 || index1 == index2 || index1 >= count || index2...
  • 数据链表:双向循环链表交换结点

    千次阅读 2019-03-21 17:21:09
    要求:已知p指向双向循环链表中的一个结点,其结点结构为data、prior、next三个域,写出算法change§,交换p所指向的结点和它的前缀结点的顺序。 [题目分析] 知道双向循环链表中的一个结点,与前驱交换涉及到四个结点...
  • 双向链表——有序双向链表中插入节点
  • 链表的操作总结 链表反转这是一个简单的链表操作问题,在leetcode上面有52.7%的通过率,难度是简单。但是还是想在这里基于python做一下总结,顺便总结一下链表的各种操作。首先先看一下leetcode上面的题目:反转一个...
  • 利用双向循环链表表示一个整数序列,指定一个结点位置用p指向该结点,交换p所指向的结点及其前驱结点的顺序。 输入 多组数据,每组数据有三行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)...
  • 链表交换相邻结点

    2015-11-13 18:07:00
    Swap(LinkNode low,LinkNode high)//交换两个结点 { low->prior->next=high;high->prior=low->prior; high->next->prior=low; low->next=high->next; high->next=low; ...
  • 交换链表节点

    2017-06-13 21:51:12
    给你一个链表以及两个权值v1和v2,交换链表中权值...你需要交换两节点而不是改变节点的权值 样例 给出链表 1->2->3->4->null ,以及 v1 = 2 , v2 = 4 返回结果 1->4->3->2->null。 import java.util.Scan
  • 利用双向循环链表表示一个整数序列,指定一个结点位置用p指向该结点,交换p所指向的结点及其前驱结点的顺序。 输入 多组数据,每组数据有三行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)...
  • 利用双向循环链表表示一个整数序列,指定一个结点位置用p指向该结点,交换p所指向的结点及其前驱结点的顺序。 输入 多组数据,每组数据有三行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)...
  • 我们先来讲讲相邻节点是如何调换的 一、先创建一条链表 直接上代码(不知道如何创建链表的同学可以看看我上一篇文章) //需要的个头文件 #include<stdio.h> #include<stdlib.h> //定义结构体(包含...
  • 24. 两两交换链表中的节点 给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。 你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。 示例: 给定 1->2->3->4, 你应该返回 2->...
  • 前言前端工程师对于算法和数据结构这块的知识的掌握程度,是进阶高级工程师的非常重要的标志之一,为了总结一下数据结构和算法方面的知识,笔者今天继续把链表这一块的知识补上,也作为自己知识体系的一个梳理,笔者...
  • 每一次先检查pre前是否有2个节点,有才可以进行交换,先用l1和l2代表需要交换的2个节点,然后将pre节点指向L2,目的是保证前驱节点的下一个指向是正确的(举个例子【1–>2–>3–>4】:现添加的节点node,他...
  • Java实现 双链表互换任意节点

    千次阅读 2017-05-11 16:29:21
    1、确定节点的先后顺序 2、next、prev互相交换顺序以及将换向前方的节点与之前的节点对接。(1.prev.next = 2) 3、判断是否相邻 链表类:public class SLink { public SNode head; public SLink() { this...
  • 交换链表相邻的个元素 题目:给定一个链表交换每个相邻的元素,最后返回新的链表节点。 ListNode *swapNodes(ListNode *head) { if(head == NULL || head->next == NULL) return head; ListNode *...
  • C语言实现双向链表

    2020-01-16 22:04:34
    目前我们所学到的链表,无论是动态链表还是静态链表,表中各节点中都只包含一个指针(游标),且都统一指向直接后继节点,通常称这类链表为单向链表(或单链表)。 虽然使用单链表能 100% 解决逻辑关系为 “一对一...
  • 常规的链表处理,需要另外的一个指针next记录下节点之后的第三个节点,保证节点不会丢失找不到。(leetcode24)class Solution { public ListNode swapPairs(ListNode head) { if(head == null){ return null; ...
  • 种方式实现双向链表的反转

    千次阅读 2019-08-26 18:42:28
    双向链表的反转,种方式实现,1、利用指针遍历的方式实现;2、不采用指针,直接用数据交换的方式进行反转。 public class shuangxianglianbaiofanzhuan { public static void main(String[] args){ ...
  • 题目 题目:假设有一个双向链表,链表中每个节点定义如下: public class Node { ...// 交换节点位置(注意:我们不知道a节点和b节点的位置以及先后顺序) void changeNode(Node a, Node b) { Node aBe
  • 链表中插入节点(C语言实现)

    千次阅读 2020-07-15 17:45:09
    相关背景介绍1.1 双链表概念1.2 双链表的优势与劣势1.3 双链表插入节点位置2. 不同位置插入数据2.1 在DLL的前端添加节点2.2 在给定节点之前添加节点2.3 在DLL的末尾添加节点2.4 在给定节点之后添加节点3. 综合...
  • 合并个无序的双向链表双向链表进行按位置反转 比如A->B->C->D->E->F 以 C 点 为转换 转换之后就是C->D->E->F->A->B #include "3.h" Linklist createlist() //创建一个带头节点...
  • 链表由一连串的节点组成,双向链表节点中包含个特殊的成员,一个用来指向前一个节点,一个用来指向后一个节点,如图所示(为了便于操作我们可以使用 head 和 tail 节点来做首尾): 添加节点时,把该位置前后...
  • 双向链表这里不做赘述,其特性已经普及遍了。可以参考之前博客的单向链表进行回顾学习。 在这里记录一个问题点,就是双向链表的有序插入时,赋值顺序是什么? 首先什么是有序插入,插入分为头部插入和尾部插入和按...
  • 高分悬赏:Java语言怎么交换两双向链表,首先请给出链表的设计类,然后再交换!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,836
精华内容 5,934
关键字:

双向链表交换两节点位置