转载：详解P=Q-＞NEXT和P-＞NEXT=Q的区别，链表操作，附代码

详解P=Q-＞NEXT和P-＞NEXT=Q的区别，附代码

单链表简单操作

（1）P=Q

将q的value和next都赋值给p意味着p和q的value值相同同时都指向q的下一个对象

(2)P.NEXT = Q

将q赋值给p.next。也就是说p的next中保存的会是q。那么p的下一个节点为q同时p与t的连接断开了

(3)P=Q.NEXT

理解为q.next（t）赋值给p,也就是将t赋值给p。即t和p的value和next值相同。p和t同时指向t的下一个元素

###下面给出代码说明，为便于理解和证明为Node添加name属性

NODE类

public class Node {
    public String name;
    public int value;
    public Node next;
    public Node(){
    }
    public Node(int data){
        this.value = data;
    }
    public Node(String name){
        this.name = name;
    }
    public Node(String name,int data){
        this.name = name;
        this.value = data;
    }
    
}

输出类PRINT

public class Print {
    public static void printLinkedList(Node node) {
        System.out.print("Linked List: ");
        while (node != null) {
            System.out.print(node.name + ":"+ node.value + "->");
            node = node.next;
        }
        System.out.println();
    }

}

测试类

public class Test {
    public static void main(String[] args) {
        Print print = new Print();
        Node node1 = new Node("node1",1);
        Node node2 = new Node("node2",2);
        Node node3 = new Node("node3",3);
        Node node4 = new Node("node4",4);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = null;

        //(1)未作修改
        //print.printLinkedList(node1);

        //(2)测试 p = q    node = node2
        //Node node = new Node("node");
        //node = node2;
        //print.printLinkedList(node1);
        //print.printLinkedList(node);

        //(3)测试p.next = q  node2.next = node
        //Node node = new Node("node",22);
        //node2.next = node;
        //print.printLinkedList(node1);

        //(4)测试p=q.next  node = node2.next
        Node node = new Node("node",22);
        node = node2.next;
        print.printLinkedList(node1);
        print.printLinkedList(node);

    }
}

运行结果
（1）

Linked List: node1:1->node2:2->node3:3->node4:4->

（2）node = node2;

Linked List: node1:1->node2:2->node3:3->node4:4->
Linked List: node2:2->node3:3->node4:4->

第二个是以node2开头，证实了是将node2赋值给node所以

name,value,next都相同

（3）node2.next = node;

Linked List: node1:1->node2:2->node:22->

这里node2和node3的连接被断开了

（4）node = node2.next;

Linked List: node1:1->node2:2->node3:3->node4:4->
Linked List: node3:3->node4:4->

这里证实了将node2的下一个节点赋值给node所以node和node3的

name,value,next都相同。

延伸
1.理解NODE2.NEXT = NODE; NODE.NEXT = NODE3是在弄得NODE2和NODE3之间插入NODE节点

2.理解NODE.NEXT = NODE3；NODE2.NEXT = NODE; 是在弄得NODE2和NODE3之间插入NODE节点

3.P.NEXT=Q.NEXT是删除Q节点

//插入节点1
Node node = new Node(22);
node2.next = node;
node.next = node3;
print.printLinkedList(node1);


//插入节点2
Node node = new Node(22);
node.next = node3;
node2.next = node;
print.printLinkedList(node1);

//删除节点
node2.next = node3.next;
print.printLinkedList(node1);

赋值构造函数

iint main(int argc, char * argv[])
{
CExample A;
A.Init(40);

 CExample C;  
 C.Init(60);  

 //现在需要一个对象赋值操作,被赋值对象的原内容被清除，并用右边对象的内容填充。  
 C = A;  
return 0;  

}
用到了"="号，但与上面的例子中语句“ CExample B=A; ” 不同“ CExample B=A; ”语句中的 “=” 在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。 例CExample B(A);

而本例子中，"=" 表示赋值操作。将对象 A 的内容复制到对象C;，这其中涉及到对象C 原有内容的丢弃，新内容的复制。 但"=“的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。 由于对象内包含指针，将造成不良后果:指针的值被丢弃了，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。 因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载”="赋值操作符号。

注意：拷贝构造函数是在对象被创建时调用的，而赋值构造函数只能被已经存在了的对象调用

转载于：
版权声明：本文为weixin_42988712原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42988712/article/details/107447667