geet作业提交

Author: zhangruihao.zhang

Week_01/id_108/LeetCode_142_108.java

@@ -0,0 +1,44 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_142_108 {
+    /**
+     * Definition for singly-linked list.
+     * class ListNode {
+     *     int val;
+     *     ListNode next;
+     *     ListNode(int x) {
+     *         val = x;
+     *         next = null;
+     *     }
+     * }
+     */
+    public class Solution {
+        public ListNode detectCycle(ListNode head) {
+            if(head == null || head.next == null){
+                return null;
+            }
+            ListNode slow = head;
+            ListNode quick = head;
+            while(slow != null && quick != null){
+                slow = slow.next;
+                quick = quick == null || quick.next == null ? null : quick.next.next;
+                if(slow == quick){
+                    break;
+                }
+            }
+
+            if(slow == null || quick == null){
+                return null;
+            }
+            slow = head;
+            while(slow != quick){
+                slow = slow.next;
+                quick = quick.next;
+            }
+            return slow;
+        }
+    }
+}

Week_01/id_108/LeetCode_21_108.java

@@ -0,0 +1,61 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_21_108 {
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     *     int val;
+     *     ListNode next;
+     *     ListNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+            if(l1 == null){
+                return l2;
+            }
+            if(l2 == null){
+                return l1;
+            }
+            // 链表1的游标
+            ListNode cur1 = l1;
+            // 链表2的游标
+            ListNode cur2 = l2;
+            //合并后的链表的表头
+            ListNode head = null;
+            if(cur1.val < cur2.val){
+                head = cur1;
+                cur1 = cur1.next;
+            }else{
+                head = cur2;
+                cur2 = cur2.next;
+            }
+            //将head指向null，防止指针影响
+            head.next = null;
+            // 合并后的链表的游标
+            ListNode cur = head;
+            while (cur1 != null && cur2 != null){
+                if(cur1.val < cur2.val){
+                    cur.next = cur1;
+                    cur1 = cur1.next;
+                }else{
+                    cur.next = cur2;
+                    cur2 = cur2.next;
+                }
+                //游标后移，并指向空
+                cur = cur.next;
+                cur.next = null;
+            }
+            if(cur1 != null){
+                cur.next = cur1;
+            }
+            if(cur2 != null){
+                cur.next = cur2;
+            }
+            return head;
+        }
+    }
+}

Week_01/id_108/LeetCode_24_108.java

@@ -0,0 +1,87 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_24_108 {
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     *     int val;
+     *     ListNode next;
+     *     ListNode(int x) { val = x; }
+     * }
+     */
+    class Solution1 {
+        public ListNode swapPairs(ListNode head) {
+            if(head == null || head.next == null){
+                return head;
+            }
+            //标识要交换的第一个节点
+            ListNode first = head;
+            //标识要交换的第二个节点
+            ListNode second = head.next;
+            //标识下一组要交换的节点对
+            ListNode cur = second.next;
+            //交换
+            first.next = cur;
+            second.next = first;
+            head = second;
+            ListNode pre = first;
+            //下一组
+            first = cur;
+            second = cur == null || cur.next == null ? null : cur.next;
+            cur = second == null ? null : second.next;
+            while(first != null && second != null){
+                //交换
+                first.next = cur;
+                second.next = first;
+                pre.next = second;
+                pre = first;
+                //下一组
+                first = cur;
+                second = cur == null || cur.next == null ? null : cur.next;
+                cur = second == null ? null : second.next;
+            }
+            return head;
+        }
+    }
+
+    class Solution2 {
+        public ListNode swapPairs(ListNode head) {
+            if(head == null || head.next == null){
+                return head;
+            }
+            //标识要交换的第一个节点
+            ListNode first = head;
+            //标识要交换的第二个节点
+            ListNode second = head.next;
+            //标识下一组要交换的节点对
+            ListNode cur = second.next;
+            //初始化前节点
+            ListNode pre = null ;
+            //第一次交换
+            first.next = cur;
+            second.next = first;
+            head = second;
+            while(true){
+                pre = first;
+                first = cur;
+                second = cur == null || cur.next == null ? null : cur.next;
+                cur = second == null ? null : second.next;
+                if(first == null || second == null){
+                    break;
+                }
+                swap(pre,first,second,cur);
+            }
+            return head;
+        }
+
+        private void swap(ListNode pre,ListNode first,ListNode second,ListNode cur){
+            //交换
+            first.next = cur;
+            second.next = first;
+            pre.next = second;
+        }
+    }
+}

Week_01/id_108/LeetCode_25_108.java

@@ -0,0 +1,81 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_25_108 {
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     *     int val;
+     *     ListNode next;
+     *     ListNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        public ListNode reverseKGroup(ListNode head, int k) {
+            if(k == 1){
+                return head;
+            }
+            if(head == null){
+                return head;
+            }
+            ListNode tail = needReverse(head,k);
+            if(tail == null){
+                return head;
+            }
+            //下一组要翻转的起点
+            ListNode nextFirst = tail.next;
+            tail.next = null;
+            ListNode[] pair = reverse(head);
+            head = pair[0];
+            ListNode lastTail = pair[1];
+            //翻转起点
+            ListNode reverseStart = nextFirst;
+            while(true){
+                tail = needReverse(nextFirst,k);
+                if(tail == null){
+                    lastTail.next = nextFirst;
+                    break;
+                }
+                //翻转起点
+                reverseStart = nextFirst;
+                //跳到未来的下一组
+                nextFirst = tail.next;
+                tail.next = null;
+                pair = reverse(reverseStart);
+                lastTail.next = pair[0];
+                lastTail = pair[1];
+            }
+            return head;
+        }
+
+        //判断链表是否可以翻转,如果可以翻转，则返回翻转链表的最后一个节点
+        private ListNode needReverse(ListNode head,int k){
+            int i = 1;
+            ListNode cur = head;
+            while(i<k && cur != null && cur.next != null){
+                cur = cur.next;
+                i++;
+            }
+            return i == k ? cur : null;
+        }
+
+        //返回翻转后的链表的首尾对
+        private ListNode[] reverse(ListNode head){
+            ListNode pre = head;
+            ListNode cur = head.next;
+            ListNode tmp = cur == null ? null : cur.next;
+            head.next = null;
+
+            while(cur != null){
+                cur.next = pre;
+                pre = cur;
+                cur = tmp;
+                tmp = tmp == null ? null : tmp.next;
+            }
+            return new ListNode[]{pre,head};
+        }
+    }
+
+}

Week_01/id_108/LeetCode_83_108.java

@@ -0,0 +1,35 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_83_108 {
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     *     int val;
+     *     ListNode next;
+     *     ListNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        public ListNode deleteDuplicates(ListNode head) {
+            if(head == null || head.next == null){
+                return head;
+            }
+            ListNode pre = head;
+            ListNode tmp = head.next;
+            while(pre != null){
+                if(tmp != null && pre.val == tmp.val){
+                    pre.next = tmp.next;
+                    tmp.next = null;
+                    tmp = pre.next;
+                } else {
+                    pre = pre.next;
+                    tmp = pre != null ? pre.next : null;
+                }
+            }
+            return head;
+        }
+    }
+}

Week_01/id_108/LeetCode_905_108.java

@@ -0,0 +1,51 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_905_108 {
+    class Solution1 {
+        public int[] sortArrayByParity(int[] A) {
+            int left = 0;
+            int right = A.length - 1;
+            while(left < right){
+                while( left< A.length && (A[left] & 1) == 0){
+                    left ++;
+                }
+                while( right>0 && (A[right] & 1) == 1){
+                    right --;
+                }
+                if(left < right) {
+                    swap(A,left,right);
+                }
+            }
+            return A;
+        }
+
+        private void swap(int[] A,int left,int right){
+            int tmp = A[left];
+            A[left] = A[right];
+            A[right] = tmp;
+        }
+    }
+
+    class Solution2 {
+        public int[] sortArrayByParity(int[] A) {
+            int[] even = new int[A.length];
+            int[] odd = new int[A.length];
+            int evenIndex = 0;
+            int oddIndex = 0;
+            for(int i=0 ;i<A.length;i++){
+                if((A[i] & 1) == 0){
+                    even[evenIndex ++] = A[i];
+                }else{
+                    odd[oddIndex ++] = A[i];
+                }
+            }
+            for(int i=0 ;i<oddIndex;i++){
+                even[evenIndex ++] = odd[i];
+            }
+            return even;
+        }
+    }
+}

Week_01/id_108/LeetCode_922_108.java

@@ -0,0 +1,24 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/20
+ */
+public class LeetCode_922_108 {
+    class Solution {
+        public int[] sortArrayByParityII(int[] A) {
+            int oddIndex = 1;
+            int evenIndex = 0;
+            int[] tmp = new int[A.length];
+            for(int i= 0;i<A.length;i++){
+                if((A[i] & 1) == 0){
+                    tmp[evenIndex] = A[i];
+                    evenIndex = evenIndex + 2;
+                }else{
+                    tmp[oddIndex] = A[i];
+                    oddIndex = oddIndex + 2;
+                }
+            }
+            return tmp;
+        }
+    }
+}