链表指针 |这是什么意思：next 是引用，可以被视为链接或指针？

Question

我的问题是关于链表和指针 我知道链表及其工作原理，但我的问题是：

我有这个例子奇偶链表：

// This is class node for create nodes
class Node {
    constructor(val, next) {
        this.val = val === undefined ? 0 : val;
        this.next = next === undefined ? null : next;
    }
}

// this is our function to return odd nodes followed bt even nodes 
// * return the index of node not the value so if node index is 1 and value is 2 
// thats mean odd node not even cuz we don't care about value
// consider that index start from 1 not from 0

const oddEvenLinkedList = function (head) {
    if (!head) return head;
    var odd = head
    var even = head.next 
    var evenHead = even 
    while (odd.next) {
        odd.next = even.next 
        odd = odd.next 
        even.next = odd.next 
        even = even.next 
    }
    odd.next = evenHead
    return head;  
};
// create our linked list
// Node takes two params Node(value, next_node)
const head = new Node(1, 
             new Node(2, 
             new Node(3, 
             new Node(4, 
             new Node(5, 
             new Node(6, 
             new Node(7)))))))

console.log(oddEvenLinkedList(head));

结果将是：

head = [1,3,5,2,4,6,7] // odd numbers followed by even nubmers

所以我的问题是： 当我们添加时这里发生了什么：

    var odd = head
    var even = head.next 
    var evenHead = even 

我知道odd var 现在将是：[1,2,3,4,5,6] 同时even 将是：[2,3,4,5,6,7]

问题是：odd 和 even 循环后将等于：

   odd = [7] 
   even = null

在最后一行添加：odd.next = evenHead 这意味着odd 将等于odd=[7,1,2,3,4,5,6,7] 但是当我返回odd 时会是这样的：odd=[1,3,5,2,4,6,7]

同时当我返回head 将等于odd 相同的结果： head=[1,3,5,2,4,6,7]

为什么odd var 会影响head 和even var 会影响evenHead？

希望你明白我的意思：

上面的解释不懂就简单总结一下

let head = [1,2,3,4,5] // linked list 1->2->3...etc
let x = main
let z = main

//for example when change x or z :
x.next = null
//or 
z.next = null // or whatever value

// any changes we do in z or x will affect the head, why?

class Node {
    constructor(val, next) {
        this.val = val === undefined ? 0 : val;
        this.next = next === undefined ? null : next;
    }
}

var oddEvenLinkedList = function (head) {
    if (!head) return head;
    var odd = head 
    var even = head.next 
    var evenHead = even 
    while (odd.next) {
        odd.next = even.next 
        odd = odd.next 
        even.next = odd.next 
        even = even.next 
    }
    odd.next = evenHead
    return head;  
};
const head = new Node(1, new Node(2, new Node(3, new Node(4, new Node(5, new Node(6, new Node(7)))))))

console.log(oddEvenLinkedList(head));

Answer 1

odd.next = evenHead 这意味着 odd 将等于 odd=[7,1,2,3,4,5,6,7] 但是当我返回 odd 时是这样的：odd=[1,3,5,2,4,6,7]

原因是循环重新连接了列表。在循环执行之前，从head开始的列表是：

 odd
head         
  ↓
  1→2→3→4→5→6→7
    ↑
 evenHead
   even 

但是循环重定向了所有那些“箭头”，所以在循环之后，链接如下：

head         odd
  ↓           ↓
  1→→→3→→→5→→→7
    2→→→4→→→6
    ↑       ↑
 evenHead  even

当最后一次赋值执行完毕后，我们得到最终结果：

head         odd
  ↓           ↓
  1→→→3→→→5→→→7→→→2→→→4→→→6
                  ↑       ↑
               evenHead  even

因此，如果您查看odd，您会发现以下列表序列：[7, 2, 4, 6]。如果目的是首先得到所有奇数值，然后得到所有偶数值，那么循环之后的语句应该改变如下：

odd.next = evenHead
return head;  

到这里：

even.next = head
return evenHead;  

它们会在状态如下时被执行（我重复一遍）：

head         odd
  ↓           ↓
  1→→→3→→→5→→→7
    2→→→4→→→6
    ↑       ↑
 evenHead  even

但是通过这些最终陈述，我们得到：

              head         odd
                ↓           ↓
    2→→→4→→→6→→→1→→→3→→→5→→→7
    ↑       ↑
 evenHead  even
  

...然后evenHead 将被返回，因此序列将是 [2, 4, 6, 1, 3, 5, 7]。