amazon

Author: anduo

readme.md

@@ -180,3 +180,11 @@ doc中有好几份文档，比较经典，可以参考。
     - 题解 [WordLadder.java](./src/learn/freq05/WordLadder.java)
 
 ## frequency4
+
+
+# 刷题总结
+
+## chapter02 binary search & sorted array
+这一部分都可以使用bs模板来解决问题 [二分搜索模板](./src/template/bs_template.md)
+
+- [question01:first position of target](./src/ninechapter/ch02_binary_search_and_sorted_array/Question01FirstPositionOfTarget.java) || [lintcode](http://www.lintcode.com/zh-cn/problem/first-position-of-target/)

src/amazon/AddTwoNumbers.java

@@ -0,0 +1,49 @@
+package amazon;
+
+import entity.ListNode;
+// You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+
+// You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+// Output: 7 -> 0 -> 8
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ */
+
+/**
+ * leetcode 2 -> https://leetcode.com/problems/add-two-numbers
+ * 扩展:https://leetcode.com/problems/add-two-numbers-ii/
+ */
+
+public class AddTwoNumbers {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(0);// 哨兵节点，用来做返回值的头结点使用。
+        ListNode tail = dummy; // 用一个tail指针来操作dummy的下一个节点
+        int sum = 0; // 每次遍历两个链表的和
+        while (l1 != null || l2 != null) {
+            sum /= 10; // 每次进来之后都取上次sum的十位
+            if (l1 != null) {
+                sum += l1.val;
+                l1 = l1.next;
+            }
+            if (l2 != null) {
+                sum += l2.val;
+                l2 = l2.next;
+            }
+            tail.next = new ListNode(sum % 10);// 尾插新节点，新节点的值为sum的个位数，十位进一
+            tail = tail.next;
+        }
+        if (sum / 10 == 1) {
+            tail.next = new ListNode(1);
+        }
+
+        return dummy.next;
+    }
+}

src/amazon/BinaryTreeLevelOrderTraversal.java

@@ -0,0 +1,73 @@
+package amazon;
+// Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+
+// For example:
+// Given binary tree [3,9,20,null,null,15,7],
+//     3
+//    / \
+//   9  20
+//     /  \
+//    15   7
+// return its level order traversal as:
+// [
+//   [3],
+//   [9,20],
+//   [15,7]
+// ]
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode(int x) { val = x; }
+ * }
+ */
+
+import entity.TreeNode;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * leetcode 102 https://leetcode.com/problems/binary-tree-level-order-traversal
+ * 二叉树的层次遍历，其实也就是图的宽度优先遍历，记住使用数据结构Queue
+ * 两层循环：
+ * 外层：while 队列不为空
+ * 内层：while 队列元素大小的所有元素全部出队，打印该层元素；把下层元素入队
+ *
+ * 扩展练习:https://leetcode.com/problems/binary-tree-level-order-traversal-ii
+ * Created by anduo on 17-3-13.
+ */
+public class BinaryTreeLevelOrderTraversal {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if (root == null) return result;
+        // bfs 算法
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        TreeNode node;
+        while (!queue.isEmpty()) {
+            List<Integer> levels = new ArrayList<>();
+            int nums = queue.size();
+            while (nums-- > 0) {
+                // 把该层的所有节点放到levels中，并且把这层的下级节点依次放入队列中
+                node = queue.poll();
+                levels.add(node.val);
+                if (node.left != null) {
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    queue.add(node.right);
+                }
+            }
+            // 把该层节点的list加到result中
+            result.add(levels);
+        }
+        return result;
+    }
+}

src/amazon/MergeKSortedLists.java

@@ -0,0 +1,55 @@
+package amazon;
+
+import entity.ListNode;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+/**
+ * Created by anduo on 17-3-13.
+ */
+public class MergeKSortedLists {
+    public ListNode mergetKLists(ListNode[] lists) {
+        if (lists == null || lists.length == 0) return null;
+
+        PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length, new Comparator<ListNode>() {
+            @Override
+            public int compare(ListNode o1, ListNode o2) {
+                if (o1.val < o2.val) {
+                    return -1;
+                } else if (o1.val == o2.val) {
+                    return 0;
+                } else {
+                    return 1;
+                }
+            }
+        });
+
+        ListNode dummy = new ListNode(0);
+        ListNode head = dummy;
+
+        for (ListNode node : lists) {
+            if (node != null) {
+                queue.add(node);
+            }
+        }
+
+        while (!queue.isEmpty()) {
+            head.next = queue.poll();
+            head = head.next;
+
+            if (head.next != null) {
+                queue.add(head.next);
+            }
+        }
+
+        return dummy.next;
+    }
+}

src/amazon/PalindromeLinkedList.java

@@ -0,0 +1,53 @@
+package amazon;
+
+import entity.ListNode;
+/**
+ * https://leetcode.com/problems/palindrome-linked-list/
+ * 判断链表是不是回文
+ * 做法，快慢指针就可以了。
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ */
+
+/**
+ * Created by anduo on 17-3-13.
+ */
+public class PalindromeLinkedList {
+    public boolean isPalindrome(ListNode head) {
+        if (head == null || head.next == null) return true;
+
+        ListNode slow = head, fast = head.next;
+
+        // 找到中间的节点
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        if (fast != null) {// 奇数的情况
+            slow = slow.next;
+        }
+
+        // 翻转后边的节点
+        ListNode reverse = reverse(slow);
+        while (head != null && reverse != null && head.val == reverse.val) {
+            head = head.next;
+            reverse = reverse.next;
+        }
+        return reverse == null;
+    }
+
+    private ListNode reverse(ListNode head) {
+        ListNode now = null;
+        while (head != null) {
+            ListNode next = head.next;
+            head.next = now;
+            now = head;
+            head = next;
+        }
+        return now;
+    }
+}

src/amazon/ReverseLinkedList.java

@@ -0,0 +1,23 @@
+package amazon;
+
+import entity.ListNode;
+
+// Reverse a singly linked list.
+
+/**
+ * 直接尾插法
+ * Created by anduo on 17-3-13.
+ */
+public class ReverseLinkedList {
+    public ListNode reverseList(ListNode head) {
+        if (head == null) return null;
+        ListNode now = null;
+        while (head != null) {
+            ListNode next = head.next;// 保存下一个节点
+            head.next = now; // 断开原链表的头节点，并把next指向上一个节点
+            now = head;
+            head = next;
+        }
+        return now;
+    }
+}

src/amazon/RotateImage.java

@@ -0,0 +1,45 @@
+package amazon;
+// You are given an n x n 2D matrix representing an image.
+
+// Rotate the image by 90 degrees (clockwise).
+
+// Follow up:
+// Could you do this in-place?
+
+/**
+ * 旋转图像
+ * <p>
+ * 1 2 3                      1 4 7                     7 4 1
+ * 4 5 6  ----正对角线翻转--->  2 5 8  ----竖对角线翻转---> 8 5 2
+ * 7 8 9                      3 6 9                     9 6 3
+ * Created by anduo on 17-3-13.
+ */
+public class RotateImage {
+    public void rotate(int[][] matrix) {
+        if (matrix == null || matrix.length == 0) {
+            return;
+        }
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+
+        // 正对角线翻转
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < i; j++) {
+                // swap
+                // a ^= b; b ^= a; a ^= b;
+                matrix[i][j] ^= matrix[j][i];
+                matrix[j][i] ^= matrix[i][j];
+                matrix[i][j] ^= matrix[j][i];
+            }
+        }
+
+        // 竖对角线翻转
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols / 2; j++) {
+                matrix[i][j] ^= matrix[i][cols - j - 1];
+                matrix[i][cols - j - 1] ^= matrix[i][j];
+                matrix[i][j] ^= matrix[i][cols - j - 1];
+            }
+        }
+    }
+}

src/amazon/ThreeSum.java

@@ -0,0 +1,74 @@
+package amazon;
+
+
+// Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+
+// Note: The solution set must not contain duplicate triplets.
+
+// For example, given array S = [-1, 0, 1, 2, -1, -4],
+
+// A solution set is:
+// [
+//   [-1, 0, 1],
+//   [-1, -1, 2]
+// ]
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by anduo on 17-3-13.
+ */
+public class ThreeSum {
+
+    // 把3sum的问题，降级到2sum问题
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {// 这道题用不到这个条件，因为题目说了不考虑重复元素
+                continue;
+            }
+            int left = i + 1;
+            int right = nums.length - 1;
+            int target = -nums[i];
+            twoSum(nums, left, right, target, result);
+        }
+        return result;
+    }
+
+    public void twoSum(int[] nums,
+                       int left,
+                       int right,
+                       int target,
+                       List<List<Integer>> results) {
+        // 充分利用有序这样一个特点
+        while (left < right) {
+            if (nums[left] + nums[right] == target) {
+                ArrayList<Integer> triple = new ArrayList<>();
+                triple.add(-target);
+                triple.add(nums[left]);
+                triple.add(nums[right]);
+                results.add(triple);
+
+                left++;
+                right--;
+                // skip duplicate pairs with the same left
+                while (left < right && nums[left] == nums[left - 1]) {
+                    left++;
+                }
+                // skip duplicate pairs with the same right
+                while (left < right && nums[right] == nums[right + 1]) {
+                    right--;
+                }
+            } else if (nums[left] + nums[right] < target) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+    }
+
+}