merger algo

Author: laileon

src/com/blankj/csutom/CircleNode.java

@@ -1,6 +1,7 @@
 package com.blankj.csutom;
 
-import com.blankj.structure.ListNode;
+
+import com.blankj.csutom.structure.ListNode;
 
 public class CircleNode {
 

src/com/blankj/csutom/sort/BubbleSort.java

@@ -0,0 +1,31 @@
+package com.blankj.csutom.sort;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+
+//核心：冒泡，持续比较相邻元素，大的挪到后面，因此 {大的会逐步往后挪}，故称之为冒泡。
+//时间：平均最坏O(n2)，空间O(1)
+//冒泡是把最大依次往后，选择是把最小依次放前
+public class BubbleSort {
+    public static void main(String[] args) {
+        int[] unsortedArray = new int[]{5,6,2,7,9,0,1};
+        bubblesort(unsortedArray);
+        System.out.println("After sort: ");
+        for (int item : unsortedArray){
+            System.out.println(item + " ");
+        }
+    }
+
+    private static void bubblesort(int[] unsortedArray) {
+        int len = unsortedArray.length;
+        for (int i = 0; i < len; i++) {
+            //运行一次后最大的被挪到最后
+            for (int j = 1; j < len - i; j++) {
+                if (unsortedArray[j - 1] > unsortedArray[j]){
+                    Utils.swap(j - 1, j, unsortedArray);
+                }
+            }
+        }
+    }
+}

src/com/blankj/csutom/sort/InsertionSort.java

@@ -0,0 +1,34 @@
+package com.blankj.csutom.sort;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+//核心：通过构建有序序列，对于未排序序列，在已排序序列中从后向前扫描(对于单向链表则只能从前往后遍历)，
+//        找到相应位置并插入。实现上通常使用in-place排序(需用到O(1)的额外空间)
+
+//    “核心：基于插入排序，使数组中任意间隔为h的元素都是有序的，即将全部元素分为h个区域使用插入排序。
+//            其实现可类似于插入排序但使用不同增量。更高效的原因是它权衡了子数组的规模和有序性。
+
+public class InsertionSort {
+    public static void main(String[] args) {
+        int[] unsortedArray = new int[]{5,6,2,7,9,0,11};
+        insertionSort(unsortedArray);
+        System.out.println("After sort: ");
+        for (int item : unsortedArray){
+            System.out.println(item + " ");
+        }
+    }
+
+    private static void insertionSort(int[] unsortedArray) {
+        int len = unsortedArray.length;
+        for (int i = 0; i < len; i++) {
+            //右边将作比较的数
+//            int temp = unsortedArray[i];
+            while (i > 0 && unsortedArray[i - 1] > unsortedArray[i]){
+                Utils.swap(i - 1, i, unsortedArray);
+                i --;
+            }
+//            unsortedArray[i] = temp;
+        }
+    }
+}

src/com/blankj/csutom/sort/MergeSort.java

@@ -0,0 +1,62 @@
+package com.blankj.csutom.sort;
+
+//时间复杂度为O(N log N ), 使用了等长的辅助数组，空间复杂度为O(N)
+//将两个有序对数组归并成一个更大的有序数组。通常做法为递归排序，并将两个不同的有序数组归并到第三个数组中。
+//        先来看看动图，归并排序是一种典型的分治应用
+
+
+//“快排的实现我们可以发现其与『归并排序』的区别主要有如下两点：
+//
+//归并排序将数组分成两个子数组分别排序，并将有序的子数组归并以将整个数组排序。递归调用发生在处理整个数组之前。
+//快速排序将一个数组分成两个子数组并对这两个子数组独立地排序，两个子数组有序时整个数组也就有序了。递归调用发生在处理整个数组之后。”
+
+import java.util.Arrays;
+
+public class MergeSort {
+    public static void merge(int[] a, int low, int mid, int high) {
+        int[] temp = new int[high - low + 1];
+        int i = low;// 左指针
+        int j = mid + 1;// 右指针
+        int k = 0;
+        // 把较小的数先移到新数组中
+        while (i <= mid && j <= high) {
+            if (a[i] < a[j]) {
+                temp[k++] = a[i++];
+            } else {
+                temp[k++] = a[j++];
+            }
+        }
+        // 把左边剩余的数移入数组
+        while (i <= mid) {
+            temp[k++] = a[i++];
+        }
+        // 把右边边剩余的数移入数组
+        while (j <= high) {
+            temp[k++] = a[j++];
+        }
+        // 把新数组中的数覆盖nums数组
+        for (int k2 = 0; k2 < temp.length; k2++) {
+            a[k2 + low] = temp[k2];
+        }
+    }
+
+    public static void mergeSort(int[] a, int low, int high) {
+        int mid = (low + high) / 2;
+        if (low < high) {
+            // 左边
+            mergeSort(a, low, mid);
+            // 右边
+            mergeSort(a, mid + 1, high);
+            // 左右归并
+            merge(a, low, mid, high);
+            System.out.println(Arrays.toString(a));
+        }
+
+    }
+
+    public static void main(String[] args) {
+        int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };
+        mergeSort(a, 0, a.length - 1);
+        System.out.println("排序结果：" + Arrays.toString(a));
+    }
+}

src/com/blankj/csutom/sort/QuickSort.java

@@ -0,0 +1,46 @@
+package com.blankj.csutom.sort;
+
+public class QuickSort {
+    public static void main(String[] args) {
+        int unsortedArray[] = new int[]{6, 5, 3, 1, 8, 7, 2, 4};
+        quickSort(unsortedArray);
+        System.out.println("After sort: ");
+        for (int item : unsortedArray) {
+            System.out.print(item + " ");
+        }
+    }
+
+    public static void quickSort2(int[] array, int l, int u) {
+        for (int item : array) {
+            System.out.print(item + " ");
+        }
+        System.out.println();
+        if (l >= u) return;
+        int pivot = array[l];
+        int left = l + 1;
+        int right = u;
+        while (left <= right) {
+            while (left <= right && array[left] < pivot) {
+                left++;
+            }
+            while (left <= right && array[right] >= pivot) {
+                right--;
+            }
+            if (left > right) break;
+            // swap array[left] with array[right] while left <= right
+            int temp = array[right];
+            array[right] = array[left];
+            array[left] = temp;
+        }
+        /* swap the smaller with pivot */
+        int temp = array[right];
+        array[right] = array[l];
+        array[l] = temp;
+        quickSort2(array, l, right - 1);
+        quickSort2(array, right + 1, u);
+    }
+
+    public static void quickSort(int[] array) {
+        quickSort2(array, 0, array.length - 1);
+    }
+}

src/com/blankj/csutom/sort/README

@@ -0,0 +1,26 @@
+时间复杂度-执行时间(比较和交换次数)
+
+空间复杂度-所消耗的额外内存空间
+使用小堆栈或表
+使用链表或指针、数组索引来代表数据
+排序数据的副本
+对具有重键的数据(同一组数按不同键多次排序)进行排序时，需要考虑排序方法的稳定性，在非稳定性排序算法中需要稳定性时可考虑加入小索引。
+
+稳定性：如果排序后文件中拥有相同键的项的相对位置不变，这种排序方式是稳定的。
+
+常见的排序算法根据是否需要比较可以分为如下几类：
+
+Comparison Sorting:
+Bubble Sort
+Selection Sort
+Insertion Sort
+Shell Sort
+Merge Sort
+Quck Sort
+Heap Sort
+
+Bucket Sort
+
+Counting Sort
+
+Radix Sort

src/com/blankj/csutom/sort/SelectionSort.java

@@ -0,0 +1,39 @@
+package com.blankj.csutom.sort;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+//核心：不断地选择剩余元素中的最小者。
+//
+//        找到数组中最小元素并将其和数组第一个元素交换位置。
+//        在剩下的元素中找到最小元素并将其与数组第二个元素交换，直至整个数组排序。
+//        性质：
+//
+//        比较次数=(N-1)+(N-2)+(N-3)+...+2+1~N^2/2
+//        交换次数=N
+//        运行时间与输入无关
+
+public class SelectionSort {
+    public static void main(String[] args) {
+        int[] unsortedArray = new int[]{5,6,2,7,9,0,11};
+        selectionSort(unsortedArray);
+        System.out.println("After sort: ");
+        for (int item : unsortedArray){
+            System.out.println(item + " ");
+        }
+    }
+
+    private static void selectionSort(int[] unsortedArray) {
+        int len = unsortedArray.length;
+        for (int i = 0; i < len; i++) {
+            //每次最小的index经转换后一定为最前
+            int min_index = i;
+            for (int j = i + 1; j < len; j++) {
+                if (unsortedArray[j] < unsortedArray[min_index]) {
+                    min_index = j;
+                }
+            }
+            Utils.swap(min_index, i, unsortedArray);
+        }
+    }
+}

src/com/blankj/csutom/sort/ShellSort.java

@@ -0,0 +1,43 @@
+package com.blankj.csutom.sort;
+
+/**
+ * Created by laileon on 2017/7/21.
+ */
+
+//希尔排序对直接插入排序进行了简单的改进：它通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而使数据项大跨度地移动，
+//        当这些数据项排过一趟序之后，希尔排序算法减小数据项的间隔再进行排序，依次进行下去，进行这些排序时的数据项之间的间隔被称为增量，
+//        习惯上用字母h来表示这个增量。
+public class ShellSort {
+    public static void main(String[] args) {
+        int[] unsortedArray = new int[]{5, 6, 2, 7, 9, 0, 11, 26, 53, 67, 48, 57, 13, 48, 32, 60, 50};
+        shellSort(unsortedArray);
+        System.out.println("After sort: ");
+        for (int item : unsortedArray) {
+            System.out.println(item + " ");
+        }
+    }
+
+    private static void shellSort(int[] unsortedArray) {
+        // 计算出最大的h值
+        int h = 1;
+        //常用的h序列由Knuth提出，该序列从1开始，通过如下公式产生：
+        while (h <= unsortedArray.length / 3) {
+            h = h * 3 + 1;
+        }
+        while (h > 0) {
+            for (int i = h; i < unsortedArray.length; i += h) {
+                if (unsortedArray[i] < unsortedArray[i - h]) {
+                    int tmp = unsortedArray[i];
+                    int j = i - h;
+                    while (j >= 0 && unsortedArray[j] > tmp) {
+                        unsortedArray[j + h] = unsortedArray[j];
+                        j -= h;
+                    }
+                    unsortedArray[j + h] = tmp;
+                }
+            }
+            // 计算出下一个h值
+            h = (h - 1) / 3;
+        }
+    }
+}

src/com/blankj/csutom/sort/Test.java

@@ -0,0 +1,10 @@
+package com.blankj.csutom.sort;
+
+public class Test {
+    public static void main(String[] args) {
+        int a = 5;
+        int b = 10;
+        a = b;
+        System.out.println(a + " " + b);
+    }
+}

src/com/blankj/csutom/sort/Utils.java

@@ -0,0 +1,12 @@
+package com.blankj.csutom.sort;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+public class Utils {
+    public static void swap(int i, int j, int[] unsortedArray){
+        int temp = unsortedArray[i];
+        unsortedArray[i] = unsortedArray[j];
+        unsortedArray[j] = temp;
+    }
+}

src/com/blankj/csutom/structure/DListNode.java

@@ -0,0 +1,29 @@
+package com.blankj.csutom.structure;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+//双向链表
+public class DListNode {
+    int val;
+    DListNode prev, next;
+
+    public DListNode(int val, DListNode prev, DListNode next) {
+        this.val = val;
+        this.prev = null;
+        this.next = null;
+    }
+
+    //双向链表核心在于next和prev的交换。
+    public DListNode reverseList(DListNode head) {
+        DListNode curr = null;
+        while (head != null) {
+            curr = head;
+            head = curr.next;
+            curr.next = curr.prev;
+            curr.prev = head;
+        }
+        return curr;
+    }
+
+}

src/com/blankj/csutom/structure/Graph.java

@@ -0,0 +1,32 @@
+package com.blankj.csutom.structure;
+
+import java.util.ArrayList;
+
+/**
+ * Created by laileon on 2017/7/20.
+ */
+public class Graph {
+    //邻接矩阵
+    int[][]g = new int[1][2];
+    //邻接表
+    class DirectGraphNode {
+        int label;
+        ArrayList<DirectGraphNode> neighbors;
+
+        public DirectGraphNode(int label) {
+            this.label = label;
+            neighbors = new ArrayList<DirectGraphNode>();
+        }
+    }
+
+    //无向图
+    class UndirectGraphNode {
+        int label;
+        ArrayList<UndirectGraphNode> neighbors;
+
+        public UndirectGraphNode(int label) {
+            this.label = label;
+            neighbors = new ArrayList<UndirectGraphNode>();
+        }
+    }
+}