算法题添加

Author: xbox1994

MD/在线编程-合并有序数组.md

@@ -0,0 +1,38 @@
+https://leetcode.com/problems/merge-sorted-array/
+
+Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
+
+Note:
+
+* The number of elements initialized in nums1 and nums2 are m and n respectively.
+* You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.
+Example:
+```
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
+
+Output: [1,2,2,3,5,6]
+```
+
+归并排序的合并操作
+
+```java
+
+class Solution {
+public void merge(int A[], int m, int B[], int n) {
+        int i=m-1;
+		int j=n-1;
+		int k = m+n-1;
+		while(i >=0 && j>=0)
+		{
+			if(A[i] > B[j])
+				A[k--] = A[i--];
+			else
+				A[k--] = B[j--];
+		}
+		while(j>=0)
+			A[k--] = B[j--];
+    }
+}
+```

MD/在线编程-第k大个数.md

@@ -0,0 +1,60 @@
+https://leetcode.com/problems/kth-largest-element-in-an-array/
+
+Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
+
+Note:
+
+* The number of elements initialized in nums1 and nums2 are m and n respectively.
+* You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.
+Example:
+```
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
+
+Output: [1,2,2,3,5,6]
+```
+
+快排的每一次排序就是找到一个第N大的数，修改快排的递归逻辑。算法复杂度为O(N)。
+
+```java
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        return sort(nums, 0, nums.length-1, k);
+    }
+    
+    private int sort(int[] nums, int left, int right, int k){
+        int base = nums[left];
+        int leftt = left;
+        int rightt = right;
+        while(leftt < rightt){
+            while(leftt < rightt && nums[rightt] > base){
+                rightt--;
+            }
+            if(leftt < rightt){
+                int temp = nums[rightt];
+                nums[rightt] = nums[leftt];
+                nums[leftt] = temp;
+                leftt++;
+            }
+            while(leftt < rightt && nums[leftt] < base){
+                leftt++;
+            }
+            if(leftt < rightt){
+                int temp = nums[rightt];
+                nums[rightt] = nums[leftt];
+                nums[leftt] = temp;
+                rightt--;
+            }
+        }
+         int rank = nums.length - leftt;
+        if(rank == k){
+            return nums[leftt];
+        }else if(rank<k){
+            return sort(nums, left, leftt-1, k);
+        }else{
+            return sort(nums, leftt+1, right, k);
+        }
+    }
+}
+```

MD/在线编程-链表相加.md

@@ -0,0 +1,54 @@
+https://leetcode.com/problems/add-two-numbers/
+
+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.
+
+Example:
+```
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+Explanation: 342 + 465 = 807.
+```
+
+ 对于这个问题还有一个很好的方法：
+
+1、将两个链表逆序，这样就可以依次得到从低到高位的数字
+
+2、同步遍历两个逆序后链表，相加生成新链表，同时关注进位
+
+3、当两个链表都遍历完成后，关注进位。
+
+4、将两个逆序的链表再逆序一遍，调整回去
+
+
+```java
+public class ListNode {
+    int val;
+    ListNode next;
+    ListNode(int x) { val = x; }
+}
+ 
+public class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode  listNode= new ListNode(0);
+        ListNode p = listNode;
+        int sum = 0;
+ 
+        while (l1 != null || l2 != null || sum != 0) {
+            if (l1 != null) {
+                sum += l1.val;
+                l1 = l1.next;
+            }
+            if (l2 != null) {
+                sum += l2.val;
+                l2 = l2.next;
+            }
+            p.next = new ListNode(sum % 10);
+            sum = sum / 10;
+            p = p.next;
+        }
+        return listNode.next;
+    }
+}
+```

README.md

@@ -45,9 +45,12 @@ PS：除开知识点，一定要准备好以下套路：
 * [服务容错保护](http://sjyuan.cc/service-fault-tolerant-protected-with-hytrix/)
 ### 在线编程
 * [二叉树反转](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-二叉树反转.md)
+* [链表相加](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-链表相加.md)
 * [LRU淘汰算法](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-LRU淘汰算法.md)
-* [连续子数组最大和](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-连续子数组最大和.md)
+* [连续子数组最大和](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-合并有序数组.md)
+* [合并有序数组](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-连续子数组最大和.md)
 * [快速排序](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-快速排序.md)
+* [第k大个数](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-第k大个数.md)
 * [交替打印奇偶数](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-交替打印奇偶数.md)
 * [排序打印关键字](https://github.com/xbox1994/2018-Java-Interview/blob/master/MD/在线编程-排序打印关键字.md)
 ### Linux