leetcode

/ Annabelle
目录
反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {

}
用两个栈实现队列

CQueue 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ， 分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]

示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]


type CQueue struct {
    Stack1 *list.List
    Stack2 *list.List
}

func Constructor1() CQueue {
    return CQueue{
        Stack1: list.New(),
        Stack2: list.New(),
    }
}

func (q *CQueue) AppendTail(value int) {
    q.Stack1.PushBack(value)
}

func (q *CQueue) DeleteHead() int {
    if q.Stack2.Len() > 0 {
        e := q.Stack2.Back()
        q.Stack2.Remove(e)
        return e.Value.(int)

    } else {
        for q.Stack1.Len() > 0 {
            q.Stack2.PushBack(q.Stack1.Remove(q.Stack1.Back()))
        }

        if q.Stack2.Len() == 0 {
            return -1
        } else {
            e := q.Stack2.Back()
            q.Stack2.Remove(e)

            return e.Value.(int)
        }
    }
}
包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

输入
["MinStack","push","push","push","min","pop","top","min"]
[[],[-2],[0],[-3],[],[],[],[]]
输出
[null,null,null,null,-3,null,0,-2]
输入：
["MinStack","push","push","push","min","top","pop","min"]
[[],[-2],[0],[-1],[],[],[],[]]
输出：
[null,null,null,null,-2,-1,null,-2]
type MinStack struct {
    AllStack *list.List
    MinStack *list.List
}

// Constructor /** initialize your data structure here. */
func Constructor() MinStack {
    return MinStack{
        new(list.List),
        new(list.List),
    }
}

// Push 当辅助栈为空，或者入栈元素小于辅助栈的栈顶元素时入栈
func (s *MinStack) Push(x int) {
    if s.MinStack.Len() <= 0 || x <= s.MinStack.Back().Value.(int)  {
        s.MinStack.PushBack(x)
    }
    s.AllStack.PushBack(x)
}

func (s *MinStack) Pop() {
    if s.AllStack.Back().Value.(int) == s.MinStack.Back().Value.(int) {
        s.MinStack.Remove(s.MinStack.Back())
    }

    s.AllStack.Remove(s.AllStack.Back())

}

func (s *MinStack) Top() int {
    return s.AllStack.Back().Value.(int)
}

func (s *MinStack) Min() int {
    return s.MinStack.Back().Value.(int)
}
从尾到头打印链表

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reversePrint(head *ListNode) []int {
    var Stack list.List
    var Res []int
    temp := head

    //使用栈将链表元素顺序倒置
    for temp != nil {
        Stack.PushBack(temp.Val)
        temp = temp.Next
    } 

    for Stack.Len() > 0 {
        e := Stack.Back()
        Res = append(Res, e.Value.(int))
        Stack.Remove(e)
    }

    return Res   
}