【go】剑指offer06_从头到尾打印链表

题目描述

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

限制：

0 <= 链表长度 <= 10000

我的解题思路：遍历链表，将其值全部放到数组内，再反转数组

func reversePrint(head *ListNode) []int {
    var array []int
	for head != nil{
		array = append(array,head.Val)
        head = head.Next
	}
	var lenInt = len(array)-1
	for i:=0;i<len(array)/2;i++{
		var temp = array[i]
		array[i] = array[lenInt-i]
		array[lenInt-i] = temp
	}
	return array
}

官方思路：用栈暂存链表值，再遍历栈放入数组，利用栈先入后出的特性

func reversePrint(head *ListNode) []int {
    if head == nil {
        return nil
    }
    res := list.New()
    for head != nil {
        res.PushFront(head.Val)
        head = head.Next
    }
    ret := []int{}
    for e := res.Front(); e != nil; e = e.Next() {
        ret = append(ret, e.Value.(int))
    }
    return ret
}

其他思路一：遍历链表记录链表长度，再次遍历链表从数组尾部开始添加值

func reversePrint(head *ListNode) []int {
    if head == nil {
        return nil
    }
    count := 0
    newHead := head
    for head != nil {
        count++
        head = head.Next
    }
    res := make([]int, count)
    i := 0
    for newHead != nil {
        res[count-i-1] = newHead.Val
        i++
        newHead = newHead.Next 
    }
    return res
}

其他思路二：反转链表，再遍历链表放入数组

func reversePrint(head *ListNode) []int {
    if head == nil {
        return nil
    }

    var newHead *ListNode
    res := []int{}
    for head != nil {
        node := head.Next
        head.Next = newHead
        newHead = head
        head = node
    }

    for newHead != nil {
        res = append(res, newHead.Val)
        newHead = newHead.Next
    }

    return res
}

 复杂性分析

时间复杂度：O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
空间复杂度：O(n)。额外使用一个栈存储链表中的每个节点。

作者：william-jian
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/go-yu-yan-shi-xian-san-chong-jie-fa-di-gui-fan-zhu/