20180604

Author: fay111101

.gitignore

@@ -1,9 +1,7 @@
-test/target/*
-test/.idea/*
-/.idea/*
+target/*
+.idea/*
 
-test/.idea/*
-test/out/*
+out/*
 *.xml
 *.iml
 

algorithm.iml

@@ -4,6 +4,7 @@
     <exclude-output />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/test/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />

src/main/java/leetcode/dfsbacktracing/Permutations2.java

@@ -1,73 +1,4 @@
-<<<<<<< HEAD
-package leetcode.dfsbacktracing;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-
-/**
- * Created by fay on 2017/12/12.
- * <p>
- * Given a collection of numbers that might contain duplicates, return all possible unique permutations.
- * For example,
- * [1,1,2]have the following unique permutations:
- * [1,1,2],[1,2,1], and[2,1,1].
- */
-public class Permutations2 {
-    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
-        HashSet<ArrayList<Integer>> res = new HashSet<>();
-        int level = 0;
-        backtracking(num, level,num.length-1,res);
-        //Set转换成List
-        ArrayList<ArrayList<Integer>> result=new ArrayList<>();
-        result.addAll(res);
-        return result;
-    }
-    private void backtracking(int[] num, int level, int n,HashSet<ArrayList<Integer>> result) {
-        if (level == n) {
-            ArrayList<Integer> res=new ArrayList<>();
-            for(int i:num){
-                res.add(i);
-            }
-            result.add(res);
-            return;
-        }
-        for (int i = level; i <= n; i++) {
-           if(i!=level&&num[i]==num[level]){
-                continue;
-            }
-            swap(num, level, i);
-            backtracking(num, level + 1, n, result);
-            swap(num, level, i);
-        }
-    }
-    public void swap(int[] num, int i, int j) {
-        int temp = num[i];
-        num[i] = num[j];
-        num[j] = temp;
-    }
-    public static void main(String[] args) {
-        Permutations2 test = new Permutations2();
-        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
-        int[] num = {1, 1, 2,2};
-        /*java.util.Arrays$ArrayList cannot be cast to java.util.ArrayList
-            List res=Arrays.asList(num);
-            result.add((ArrayList) res);
-            List res = Arrays.asList(num);
-            result.add(new ArrayList<Integer>(res));*/
-       /* ArrayList<ArrayList<String>> stuff = new ArrayList<ArrayList<String>>();
-        String[] titles = {"ticker", "grade", "score"};
-        stuff.add(new ArrayList<String>(Arrays.asList(titles)));*/
-        result=test.permuteUnique(num);
-        for (ArrayList<Integer> res : result) {
-            for (Integer i : res) {
-                System.out.print(i + " ");
-            }
-            System.out.println();
-        }
-    }
-}
-=======
+
 package leetcode.dfsbacktracing;
 
 import java.util.ArrayList;
@@ -135,4 +66,3 @@ public static void main(String[] args) {
         }
     }
 }
->>>>>>> 66d83aa3e6ef68f1f21311bddb82a3035d08cb85

src/main/java/leetcode/list/AddTwoNumbers.java

@@ -1,48 +1,6 @@
-<<<<<<< HEAD
-package leetcode.list;
-/**/
-public class AddTwoNumbers {
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        if(l1==null||l2==null){
-            return null;
-        }
-        ListNode dummy=new ListNode(-1);
-        ListNode curr=dummy;
-        int carry=0;
-        int num=0;
-        while(l1!=null&&l2!=null){
-            num=l1.val+l2.val+carry;
-            carry=num>=10?1:0;
-            num=num>=10?num-10:num;
-            curr.next=new ListNode(num);
-            curr=curr.next;
-            l1=l1.next;
-            l2=l2.next;
-        }
-        while(l1!=null){
-            num=l1.val+carry;
-            carry=num>=10?1:0;
-            num=num>=10?num-10:num;
-            curr.next=new ListNode(num);
-            curr=curr.next;
-            l1=l1.next;
-        }
-        while(l2!=null){
-            num=l2.val+carry;
-            carry=num>=10?1:0;
-            num=num>=10?num-10:num;
-            curr.next=new ListNode(num);
-            curr=curr.next;
-            l2=l2.next;
-        }
-        if(carry!=0){
-            curr.next=new ListNode(carry);
-        }
-        return dummy.next;
-    }
-}
-=======
 package leetcode.list;
+import utils.*;
+
 /*
 You are given two linked lists representing two non-negative numbers. 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.
 Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
@@ -88,4 +46,3 @@ public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
         return dummy.next;
     }
 }
->>>>>>> 66d83aa3e6ef68f1f21311bddb82a3035d08cb85

src/main/java/leetcode/sort/BubbleSort.java

@@ -0,0 +1,25 @@
+package leetcode.sort;
+
+public class BubbleSort {
+    public int[] bubbleSort(int[] arr){
+        for(int i=0;i<arr.length;i++){
+            for(int j=i+1;j<arr.length;j++){
+                if(arr[i]>arr[j]){
+                    int temp=arr[i];
+                    arr[i]=arr[j];
+                    arr[j]=temp;
+                }
+            }
+        }
+        return arr;
+    }
+    public static void main(String[] args) {
+        int[] arr = {49, 38, 65, 97, 76, 13, 27, 49};
+        BubbleSort qs = new BubbleSort();
+        arr = qs.bubbleSort(arr);
+        for (int num : arr) {
+            System.out.println(num);
+
+        }
+    }
+}

src/main/java/leetcode/sort/MergeSort.java

@@ -0,0 +1,79 @@
+package leetcode.sort;
+
+public class MergeSort {
+    public void merge(int[] arr,int[] temp,int i,int l1,int l2){
+        int k,j;
+        for(k=i, j=l1+1;i<=l1&&j<=l2; k++){
+            if(arr[i]<=arr[j]){
+                temp[k]=arr[i++];
+            }else{
+                temp[k]=arr[j++];
+            }
+        }
+        if(i<=l1){
+            temp[k++]=arr[i++];
+        }
+        if(j<=l2){
+            temp[k++]=arr[j++];
+        }
+    }
+    public void mergeSort(int[] arr,int[] result,int start,int end){
+        if(start==end){
+            result[start]=arr[start];
+        }else{
+            int m=(start+end)/2;
+            mergeSort(arr,result,start,m);
+            mergeSort(arr,result,m+1,end);
+            merge(arr,result,start,m,end);
+        }
+    }
+
+    public static void mergeSort1(int[] arr,int p,int r){
+        if(p<r){
+            int q=(p+r)/2;
+            mergeSort1(arr,p,q);
+            mergeSort1(arr,q+1,r);
+            merge1(arr,p,q,r);
+
+
+        }
+    }
+
+    public static void merge1(int[] arr,int p,int q,int r){
+        int n1=q-p+1;
+        int n2=r-q;
+        int [] arr1=new int [n1+1];
+        int [] arr2=new int [n2+1];
+
+        for(int i=0;i<n1;i++){
+            arr1[i]=arr[p+i];
+        }
+        for(int j=0;j<n2;j++){
+            arr2[j]=arr[q+1+j];
+        }
+        arr1[n1]=Integer.MAX_VALUE;
+        arr2[n2]=Integer.MAX_VALUE;
+        int i=0;
+        int j=0;
+        for(int k=p;k<=r;k++){
+            if(arr1[i]<arr2[j]){
+                arr[k]=arr1[i];
+                i++;
+            }else{
+                arr[k]=arr2[j];
+                j++;
+            }
+        }
+    }
+    public static void main(String[] args) {
+        int[] arr = {49, 38, 65, 97, 76, 13, 27, 49};
+        int[] result=new int[arr.length];
+        MergeSort qs = new MergeSort();
+        qs.mergeSort1(arr, 0, arr.length-1 );
+        for (int num : arr) {
+            System.out.println(num);
+
+        }
+    }
+
+}

src/main/java/leetcode/sort/QuikSort.java

@@ -0,0 +1,45 @@
+package leetcode.sort;
+
+public class QuikSort {
+    int partition(int[] arr, int low, int high) {
+        int base = arr[low];
+
+        while (low < high) {
+            while (low < high && arr[high] >= base) {
+                high--;
+            }
+            int temp = arr[low];
+            arr[low] = arr[high];
+            arr[high] = temp;
+            while (low < high && arr[low] <= base) {
+                low++;
+            }
+            temp = arr[high];
+            arr[high] = arr[low];
+            arr[low] = temp;
+        }
+        return low;
+    }
+
+    int[] quickSort(int[] arr, int low, int high) {
+        if (low <high) {
+            int base = partition(arr, low, high);
+            quickSort(arr, 0, base - 1);
+            quickSort(arr, base + 1, high);
+        }
+
+        return arr;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {49, 38, 65, 97, 76, 13, 27,49};
+        QuikSort qs = new QuikSort();
+        arr = qs.quickSort(arr, 0, arr.length - 1);
+        for (int num : arr) {
+            System.out.println(num);
+
+        }
+
+    }
+
+}