问题形貌

输入一个链表，按链表值从尾到头的递次返回一个ArrayList。

剖析

要了解链表的数据结构：

val属性存储当前的值，next属性存储下一个节点的援用。

要遍历链表就是不停找到当前节点的next节点，当next节点是null时，申明是末了一个节点，住手遍历。

末了别忘了，从尾到头遍历链表，不要忘了将你的效果举行翻转。

代码

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function printListFromTailToHead(head)
{
    const result = [];
    let temp = head;
    while(temp){
        result.push(temp.val);
        temp = temp.next;
    }
    return result.reverse();
}

拓展

链表定义：用一组恣意存储的单位来存储线性表的数据元素。

一个对象存储着自身的值和下一个元素的地点。

须要遍历才查询到元素，查询慢。

插进去元素只需断开衔接从新赋值，插进去快。

        function LinkList(){
            function node(element){
                this.value = element;
                this.next = null;
            }
            let length = 0;
            let head = null;
        }
        LinkList.prototype = {
            // 追加
            append:function(element){
                var node = new node(element);
                var temp = this.head;
                if(this.head){
                    //遍历找到链表的尽头
                    while(temp.next){
                        temp = temp.next;
                    }
                    temp.next = node;
                }else{
                    this.head = node;
                }
                this.length++;
            },
            // 插进去
            insert:function(element,index){
                if(index <= this.length && index>0){
                    var node = new node(element);
                    var currentIndex = 0;
                    var currentNode = this.head;
                    var preNode = null;
                    if (currentIndex === 0) {
                        node.next = currentNode;
                        this.head = node;
                        return;
                    }
                    while(currentIndex<index){
                        preNode = currentNode;
                        currentNode = currentNode.next;
                        currentIndex++;
                    }
                    preNode.next = node;
                    node.next = currentNode;
                    this.length++;
                }
            }
        }

链表翻转

把初始链表头当作基准点

挪动下一个元素到头部

直到下一个元素为空

    /**
     * Definition for singly-linked list.
     * function ListNode(val) {
     *     this.val = val;
     *     this.next = null;
     * }
     */
    /**
     * @param {ListNode} head
     * @return {ListNode}
     */
    var reverseList = function (head) {
      let currentNode = null;
      let headNode = head;
      while (head && head.next) {
        // 将当前节点从链表中掏出
        currentNode = head.next;
        head.next = currentNode.next;
        // 将掏出的节点挪动到头部
        currentNode.next = headNode;
        headNode = currentNode;
      }
      return headNode;
    };