Java与数据结构(上篇：排序算法)

心得：纸上得来终觉浅，绝知此事要躬行！当自己回想着算法的整个过程，然后一行一行的敲下来，发现算法太精辟了，看似简单，写起来可真不是那么回事，而且，写多了，熟悉了，思路就快了，写起来就得心应手了！可能你会觉得算法和数据结构对现在的程序员来说已经不重要了，但是，我觉得，好的程序员如果不懂数据结构和算法那么他就写不出更好的代码！作为一个计科男，掌握数据结构和算法是必须的！

 

好了，下面附上各种排序算法的Java实现，算法的思想不介绍了，网上有很多，如果发现我的代码中有什么错误，也请及时回复我哦！谢谢

 

1. 冒泡排序

package SortAlgorithm;import java.util.Arrays;/** * 冒泡排序 *  * @author yinger */public class BubbleSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // bubble sort --- time: O(n^2)    public static void sort(int[] s) {        int n = s.length;        int i, j, temp, flag;// flag: change happened?        for (i = n - 1; i >= 1; i--) {// number from end to begin            flag = 0;            for (j = 0; j < i; j++) {// range is smaller                if (s[j] > s[j + 1]) {                    temp = s[j];                    s[j] = s[j + 1];                    s[j + 1] = temp;                    flag = 1;                }            }            if (flag == 0) {// nothing change, sort is done                break;            }        }    }}

 

2. 选择排序

package SortAlgorithm;import java.util.Arrays;/** * 选择排序 *  * @author yinger */public class SelectSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // select sort --- time: O(n^2)    public static void sort(int[] s) {        int n = s.length;        int i, j, min, minIndex, temp;// minIndex: the index of the min number        for (i = 0; i < n - 1; i++) {// every time select the min number            minIndex = i;            min = s[minIndex];            for (j = i + 1; j <= n - 1; j++) {                if (s[j] < min) {                    minIndex = j;                    min = s[j];                }            }            if (minIndex != i) {// only one change                temp = s[i];                s[i] = s[minIndex];                s[minIndex] = temp;            }        }    }}

 

3. 直接插入排序

package SortAlgorithm;import java.util.Arrays;/** * 直接插入排序 *  * @author yinger */public class DirectInsertSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // direct insert sort --- time: O(n^2)    public static void sort(int[] s) {        int n = s.length;        int i, j, temp;        for (i = 1; i < n; i++) {// begin with 1,end with (n-1)            temp = s[i];            for (j = i - 1; j >= 0 && s[j] > temp; j--) {// condition: current one (s[i]) is smaller                s[j + 1] = s[j];// move back one step            }            s[j + 1] = temp;// final position:j+1        }    }}

 

4. 折半插入排序

package SortAlgorithm;import java.util.Arrays;/** * 折半插入排序 *  * @author yinger */public class HalfFindInsertSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // half find insert sort --- time: O(n^2)    public static void sort(int[] s) {        int n = s.length;        int i, j, temp;        int low, high, mid;        for (i = 1; i < n; i++) {// begin with 1,end with (n-1)            temp = s[i];            low = 0;            high = i - 1;            while (low <= high) {// find the insert position --- low                mid = (low + high) / 2;                if (s[mid] > temp) {                    high = mid - 1;                } else {// equal in here! equal can be ignored                    low = mid + 1;                }            }            for (j = i; j > low; j--) {// move back one step                s[j] = s[j - 1];            }            s[low] = temp;        }    }}

 

5. 快速排序

package SortAlgorithm;import java.util.Arrays;/** * 快速排序 *  * @author yinger */public class QuickSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // quick sort --- time: O(n*log(n))    public static void sort(int[] s) {        int n = s.length;        subSorrt(s, 0, n - 1);    }    private static void subSorrt(int[] s, int start, int end) {        // System.out.println(" start=" + start + "  end=" + end);        if (start < end) {// need to sort            int low, high, standard;            low = start;            high = end;            standard = s[start];// the standard number            while (low < high) {                while (low < high && s[high] > standard) {// move high pointer                    high--;                }// end while --> s[high]<standard                s[low] = s[high];// s[low] has been saved! --> after this,s[high] has changed to s[low] and saved!                low++;                while (low < high && s[low] < standard) {// move low pointer                    low++;                }// end while --> s[low]>standard                s[high] = s[low];                high--;            }// end while            if (low > high) {                low--;//attention: if low = high,then position is low,but if low > high,then position is high = low-1            }            s[low] = standard;// final,end the while loop,standard number should be in (low-1) index            // System.out.println(" standard=" + standard + "  position=" + low);            // System.out.println("Current Array: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]            subSorrt(s, start, low - 1);// sort left            subSorrt(s, low + 1, end);// sort right        }// else do nothing    }}

 

6. 堆排序

package SortAlgorithm;import java.util.Arrays;/** * 堆排序 *  * @author yinger */public class HeapSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // heap sort --- time: O(n*log(n))    public static void sort(int[] s) {        int n = s.length;        int last = (n - 2) / 2;// the last node that is not leaf node = the parent of last node is (n-1-1)/2        int i, j, temp;// minIndex = the index of the min node        for (i = last; i >= 0; i--) {// first:build a min heap            adjustHeap(s, i, n - 1);// then adjust the heap        }        System.out.println("Build Heap: " + Arrays.toString(s));// Build Heap: [9, 10, 43, 11, 25, 87, 56, 34, 23]        for (j = n - 1; j > 0; j--) {            temp = s[0];// first:change the start node and the end node            s[0] = s[j];            s[j] = temp;            adjustHeap(s, 0, j - 1);// after change,adjust the heap            System.out.println("Current Heap: " + " j = " + j + "   " + Arrays.toString(s));        }    }    private static void adjustHeap(int[] s, int start, int end) {// adjust the heap from start node to end node        int j, l, r, min, minIndex, temp;// minIndex = the index of the min node        j = start;        temp = s[start];// save it!        while (2 * j + 1 <= end) {//2 * j + 1 <= end means in giving range,node j still has child            l = 2 * j + 1;// left node            r = 2 * j + 2;// right node --- not always exist            if (r <= end && s[r] < s[l]) {// find the min node of childe nodes                min = s[r];// right node is smaller                minIndex = r;            } else {                min = s[l];// left node is smaller                minIndex = l;            }            if (temp > min) {// parent is bigger,so change!                s[j] = min;                s[minIndex] = temp;                j = minIndex;// change the index of the node,it means the current node has moved to index j            } else {                break;// if not,break the while loop            }        }    }}

 

 

7. 二路归并排序

package SortAlgorithm;import java.util.Arrays;/** * 合并排序 *  * @author yinger */public class MergeSort {    public static void main(String[] args) {        int[] s = new int[] { 10, 23, 43, 9, 25, 87, 56, 34, 11 };        System.out.println("Before: " + Arrays.toString(s));// Before: [10, 23, 43, 9, 25, 87, 56, 34, 11]        sort(s);// Arrays.sort(s);        System.out.println("After: " + Arrays.toString(s));// After: [9, 10, 11, 23, 25, 34, 43, 56, 87]    }    // merge sort --- time: O(n*log(n))    public static void sort(int[] s) {        int n = s.length;        mergesort(s, 0, n - 1);    }    private static void mergesort(int[] s, int start, int end) {//merge from start to end        if (start < end) {            int mid = (start + end) / 2;            mergesort(s, start, mid);// sort left            mergesort(s, mid + 1, end);// sort right            int i = start, j = mid + 1, k, len;// left and right are all sorted,then merge them!            len = end - start + 1;            int[] temp = new int[len];//use another array to merge            for (k = 0; k < len; k++) {// i range (start,mid),and j range (mid+1,end)                if ((i <= mid && j <= end && s[i] < s[j]) || j > end) {// if j>end,then copy must copy i                    temp[k] = s[i];                    i++;                } else {                    temp[k] = s[j];                    j++;                }            }            for (k = 0; k < len; k++) {// temp is sorted array                s[k + start] = temp[k];// copy temp to s            }        }    }}