[Function add]

Seanforfun · Seanforfun · commit a62c4d2a0727 · 2019-06-28T15:23:58.000-04:00
1. Add leetcode solutions with tag amazon.
diff --git a/leetcode/116. Populating Next Right Pointers in Each Node.md b/leetcode/116. Populating Next Right Pointers in Each Node.md
@@ -146,4 +146,18 @@ public class Solution {
 			return root;
 		}
 	}
+	```
+
+* Method 2: Recursion
+	```Java
+	class Solution {
+		public Node connect(Node root) {
+			if(root == null) return root;
+			if(root.left != null) root.left.next = root.right;
+			if(root.right != null) root.right.next = root.next == null ? null: root.next.left;
+			connect(root.left);
+			connect(root.right);
+			return root;
+		}
+	}
 	```
diff --git a/leetcode/25. Reverse Nodes in k-Group.md b/leetcode/25. Reverse Nodes in k-Group.md
@@ -112,4 +112,40 @@ class Solution {
         return head;
     }
 }
-```
+```
+
+### Amazon Session
+* Method 1: Recursion
+	```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public ListNode reverseKGroup(ListNode node, int k){
+			if(node == null) return null;
+			ListNode dummy = new ListNode(0);
+			dummy.next = node;
+			ListNode temp = dummy;
+			for(int i = 0; i < k; i++){
+				if(temp.next == null) return node;
+				temp = temp.next;
+			}
+			int count = 0;
+			ListNode pre = null, cur = node, next = null;
+			while(count++ < k && cur != null){
+				next = cur.next;
+				cur.next = pre;
+				pre = cur;
+				cur = next;
+			}
+			if(cur == null) return pre;
+			node.next = reverseKGroup(cur, k);
+			return pre;
+		}
+	}
+	```
diff --git a/leetcode/716. Max Stack.md b/leetcode/716. Max Stack.md
@@ -81,3 +81,50 @@ Note:
    * int param_5 = obj.popMax();
    */
   ```
+
+### Amazon session
+* Method 1: LinkedList + PriorityQueue
+	```Java
+	class MaxStack {
+		private PriorityQueue<Integer> pq;
+		private LinkedList<Integer> list;
+		/** initialize your data structure here. */
+		public MaxStack() {
+			this.pq = new PriorityQueue<>((a, b)->{
+				return b - a;
+			});
+			this.list = new LinkedList<>();
+		}
+		public void push(int x) {
+			this.list.addFirst(x);  // O(1)
+			this.pq.offer(x);   //O(NlogN)
+		}
+		public int pop() {
+			Integer res = list.pollFirst();
+			this.pq.remove(res);    // O(NlogN)
+			return res;
+		}
+		public int top() {
+			return list.get(0);
+		}
+		public int peekMax() {
+			return this.pq.peek();
+		}
+		
+		public int popMax() {
+			Integer res = pq.poll();    // O(1)
+			this.list.remove(res);  // O(n)
+			return res;
+		}
+	}
+
+	/**
+	 * Your MaxStack object will be instantiated and called as such:
+	 * MaxStack obj = new MaxStack();
+	 * obj.push(x);
+	 * int param_2 = obj.pop();
+	 * int param_3 = obj.top();
+	 * int param_4 = obj.peekMax();
+	 * int param_5 = obj.popMax();
+	 */
+	```
