转换数组到链表-从雄辩的Javascript

Question

这是我无法理解的书中的挑战之一，或者我的大脑无法分解它。下面是解函数:

 function arrayToList(array) {
  var list = null;
  for (var i = array.length - 1; i >= 0; i--)
    list = {value: array[i], rest: list};
  return list;
}
console.log(arrayToList([10, 20]));
// → {value: 10, rest: {value: 20, rest: null}}

所以我们在反向循环数组所以第一次列表应该是:

list = {value:20, rest:{value:20, rest:**mind blows here**}}

有谁能帮我完成这个过程吗?

Answer 1

reducer可以用来从数组元素创建链表。

function ListNode(val, next) {
  this.val = (val === undefined ? 0 : val)
  this.next = (next === undefined ? null : next)
}
let input = [1, 2, 3];

let head = input.reverse().reduce((acc, curr) => {
  if (acc == null) {
    acc = new ListNode(curr);
  } else {
    acc = new ListNode(curr, acc);
  }
  return acc;
}, null);
console.log(head);

Answer 2

如下:

function L(val){
    this.val = val;
    this.next = null;
}
//We have to develop
/*
L{
    val:1,
    next:{
        val:2,
        next: {
            val:3,
            next: {
                val:4,
                next:null
            }
        }
    }
}
*/
function createL(a){
    let node, temp;
    for(let i=a.length-1; i >= 0; i--){
        if(!node)
            node = new L(a[i]);
        else {
            temp = new L(a[i]);
            temp.next = node;
            node = temp;
        }
    }
    return node;
}
createL([1,2,3,4]);

Answer 3

逐级执行，跟踪每个名称/变量的值:

最初:

array = [10, 20]
list = null
i = 1

下步骤:

array = [10, 20]
list = {value: 20, rest: null}
i = 1

下步骤:

array = [10, 20]
list = {value: 20, rest: null}
i = 0

下步骤:

array = [10, 20]
list = {value: 10, rest: {value: 20, rest: null}}
i = 0

此时循环和函数结束。

当执行操作时，键为。由于这是命令式编程风格(与(纯)函数式相反)，因此与名称(变量)关联的值可以在代码执行期间更改。因此，当list被读取时，当list被赋值时，这是至关重要的。

Answer 4

一个简单的方法是创建一个虚拟节点。然后，将每个数组元素推入虚拟节点。然后返回虚拟节点的下一个节点。

class ListNode {
    constructor(data) {
        this.data = data
        this.next = null                
    }
}
const arr = [1,2,3];
let dummy = new ListNode(-1);
let dummyHead = dummy;
for(let i = 0; i < arr.length; i++){
  dummyHead.next = new ListNode(arr[i]);
  dummyHead = dummyHead.next;
}

Answer 5

基本上你创建了一个包含两个元素的对象。第一个元素是值，第二个元素是列表的其余部分。在list = {value:20, rest:{value:20, rest:list}}行，我们基本上是从头到尾创建列表，所以你总是添加列表前状态。假设有3个元素[10,20,30]1. 我们从30开始-创建一个名为list的对象，其元素value = 30, list = null。2. 我们在20中-获取看起来像{value:30, rest:null}的列表对象并将其放置在具有20值的新对象中，因此我们有{value: 20, rest:{**old list** --> {value:30, list:null} }}现在我们将list的引用更改为指向新创建的对象。list = {value: 20, rest:{**old list** --> {value:30, list:null} }}3.2.

现在你有一个列表。(希望我讲清楚了)

Answer 6

update hasan。答案是2022年。我喜欢这样，而且可以更短更直接。

function ListNode(val, next) {
  this.val = (val===undefined ? 0 : val)
  this.next = (next===undefined ? null : next)
}
const arrToList = (arr) => arr.reduceRight((last, val)=> last = last === null ? new ListNode(val) : new ListNode(val, last),null)
const arr = [1,2,3]
console.log(arrToList(arr))
// {val: 1, next: {val: 2, next: { val: 3, next:  null}}}

打印稿版本

class ListNode {
  val: number
  next: ListNode | null
  constructor(val?: number, next?: ListNode | null) {
    this.val = val === undefined ? 0 : val
    this.next = next === undefined ? null : next
  }
}
const arrToList = (arr:number[]) => arr.reduceRight<null|ListNode>((last, val)=> last = last === null ? new ListNode(val) : new ListNode(val, last),null)
const arr = [1,2,3]
console.log(arrToList(arr))

Answer 7

使用一些额外的日志

function arrayToList(array) {
  var list = null;
  for (var i = array.length - 1; i >= 0; i--) {
    console.log(i); //2, then 1
    console.log(array[i]); //20, then 10
    list = {
      value: array[i],
      rest: list //null, then {value:20, rest: null}
    };
  }
  return list;
}
console.log(arrayToList([10, 20]));
//{ value: 10, rest: { value: 20, rest: null } }

您可以看到，尽管您正在反向迭代列表，但list对象的value属性将是最后迭代的数组元素。在该迭代中，rest属性将是list的副本。