数据结构和算法二

剑指 Offer 06. 从尾到头打印链表

题目：输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000

/*方法一：栈【本质：先进后出】
	栈的特点是后进先出，即最后压入栈的元素最先弹出。考虑到栈的这一特点，使用栈将链表元素顺序倒置。从链表的头节点开始，依次将每个节点	压入栈内，然后依次弹出栈内的元素并存储到数组中。
思路：
	1、创建一个栈，用于存储链表的节点
	2、创建一个指针，初始时指向链表的头节点
	3、当指针指向的元素非空时，重复下列操作：
		将指针指向的节点压入栈内
		将指针移到当前节点的下一个节点
	4、获得栈的大小 size，创建一个数组 print，其大小为 size
	5、创建下标并初始化 index = 0
	6、重复 size 次下列操作：
		从栈内弹出一个节点，将该节点的值存到 print[index]
		将 index 的值加 1
	7、返回 print  
复杂性分析：
	时间复杂度：O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
	空间复杂度：O(n)。额外使用一个栈存储链表中的每个节点。
*/
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Method1{
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

/*方法二：递归法
思路：
	1、递推阶段：每次传入 head.next ，以 head == null（即走过链表尾部节点）为递归终止条件，此时直接返回。
	2、回溯阶段：层层回溯时，将当前节点值加入列表，即tmp.add(head.val)。
	3、最终，将列表tmp转化为数组res，并返回即可。
复杂度分析：
	时间复杂度O(N)：遍历链表，递归N次。
	空间复杂度O(N)：系统递归需要使用O(N)的栈空间。
*/
class Method2{
    ArrayList<Integer> tmp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        recur(head);
        int[] res = new int[tmp.size()];
        for(int i = 0; i < res.length; i++)
            res[i] = tmp.get(i);
        return res;
    }
    void recur(ListNode head) {
        if(head == null) return;
        recur(head.next);
        tmp.add(head.val);
    }
}

剑指 Offer 09. 用两个栈实现队列

题目：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数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]
提示：
        1 <= values <= 10000
        最多会对 appendTail、deleteHead 进行 10000 次调用

/*方法一：双栈
思路一:
	1、维护两个栈，第一个栈支持插入操作，第二个栈支持删除操作。
	2、根据栈先进后出的特性，我们每次往第一个栈里插入元素后，第一个栈的底部元素是最后插入的元素，第一个栈的顶部元素是下一个待删除的元	 素。为了维护队列先进先出的特性，我们引入第二个栈，用第二个栈维护待删除的元素，在执行删除操作的时候我们首先看下第二个栈是否为空。	 如果为空，我们将第一个栈里的元素一个个弹出插入到第二个栈里，这样第二个栈里元素的顺序就是待删除的元素的顺序，要执行删除操作的时候	 我们直接弹出第二个栈的元素返回即可。
	成员变量：
		维护两个栈stack1和stack2，其中stack1支持插入操作，stack2支持删除操作
	构造方法：
		初始化stack1和stack2为空
	插入元素：
		插入元素对应方法appendTail
		stack1直接插入元素
	删除元素：
		删除元素对应方法deleteHead
复杂度分析：
	时间复杂度：对于插入和删除操作，时间复杂度均为O(1)。插入不多说，对于删除操作，虽然看起来是O(n)的时间复杂度，但是仔细考虑下每个				  元素只会[至多被插入和弹出 stack2 一次]，因此均摊下来每个元素被删除的时间复杂度仍为 O(1)。
	空间复杂度：O(n)。需要使用两个栈存储已有的元素。
*/
class CQueue1{
    Deque<Integer> stack1;
    Deque<Integer> stack2;
    public CQueue() {
        stack1 = new LinkedList<Integer>();
        stack2 = new LinkedList<Integer>();
    }
    public void appendTail(int value) {
        stack1.push(value);
    }
    public int deleteHead() {
        // 如果第二个栈为空
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        } 
        if (stack2.isEmpty()) {
            return -1;
        } else {
            int deleteItem = stack2.pop();
            return deleteItem;
        }
    }
}

/*思路二：
	1、栈无法实现队列功能： 栈底元素（对应队首元素）无法直接删除，需要将上方所有元素出栈。
	2、双栈可实现列表倒序： 设有含三个元素的栈A=[1,2,3]和空栈B=[]。
						若循环执行A元素出栈并添加入栈B，直到栈A为空。
						A=[],B=[3,2,1]即栈B元素实现栈A元素倒序 。
	3、利用栈B删除队首元素：倒序后，B执行出栈则相当于删除了A的栈底元素，即对应队首元素。
函数设计：
	题目只要求实现加入队尾appendTail()和删除队首deleteHead()两个函数的正常工作；
	因此我们可以设计栈 A 用于加入队尾操作，栈B用于将元素倒序，从而实现删除队首元素。
	1、队尾appendTail()函数：将数字val加入栈A即可。
	2、队首deleteHead()函数：有以下三种情况。
		(1)B不为空：B中仍有已完成倒序的元素，因此直接返回B的栈顶元素。
		(2)A为空：即两个栈都为空，无元素，因此返回-1。
		(3)栈A元素全部转移至栈B中，实现元素倒序，并返回栈B的栈顶元素。
复杂度分析：
	由于问题特殊，以下分析仅满足添加N个元素并删除N个元素，即栈初始和结束状态下都为空的情况。
	时间复杂度：appendTail()函数为O(1)；deleteHead()函数在N次队首元素删除操作中总共需完成N个元素的倒序。
	空间复杂度O(N)：最差情况下，栈A和B共保存N个元素。
*/
class CQueue2{
    LinkedList<Integer> A, B;
    public CQueue() {
        A = new LinkedList<Integer>();
        B = new LinkedList<Integer>();
    }
    public void appendTail(int value) {
        A.addLast(value);
    }
    public int deleteHead() {
        if(!B.isEmpty()) return B.removeLast();
        if(A.isEmpty()) return -1;
        while(!A.isEmpty())
            B.addLast(A.removeLast());
        return B.removeLast();
    }
}

总结：

希望每天都能有所进步和收获！不要躺在舒适圈中，要适当的打破周围的舒适圈！只有这样我们才能进步哦！各位小伙伴！加油！