閒暇之餘，將自己之前敲過的資料結構與演算法程式碼整理了一下，

最後放在一個工程下面：

具體分類：

剛看了下專案目錄，少了排序分類介紹圖，在這裡補上（此圖來源於網上）

最後，程式碼比較多，只展示下排序演算法的程式碼。

package com.lzz.algorithm.sorting;
import java.util.Arrays;
/**
 * 1.順序儲存結構
* 2.整型陣列為例
* 3.從小到大排序
* Author lzz
 * Date   2018/5/27
 */
public class MyArrays {
    //兩個整型陣列交換
private static void swap(int[] arr, int 
 
i, int j) {
        int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

    /**
     * 直接插入排序
* 時間複雜度：O(n2)
     * 空間複雜度：O(1)
     * 穩定的排序演算法
*/
public static int[] insertSort(int[] arr) {
        if (arr.length == 0) {
            return arr;
}
        int i, j ,temp;
        for (i = 1; i < arr.length
 
; i++) {
            temp = arr[i];          //暫存待插入資料
for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
                arr[j + 1] = arr[j];   //將前面比arr[i]大的資料向後移動
}
            arr[j + 1] = temp;       //插入到j+1的位置
}
        return arr;
}

    /**
     * 希爾排序
* 時間複雜度：平均：O(nlogn), 最壞為O(n2)
     * 
 
空間複雜度：O(1)
     * 不穩定的排序演算法
*/
public static int[] shellSort(int[] arr, int[] d) { //d[]為增量陣列
if (arr.length == 0) {
            return arr;
}
        int i, j, temp;
        for (int k = 0; k < d.length; k++) {
            int dk = d[k];       //取增量，注意最後一次增量值必須是1
for (i = dk; i < arr.length; i++) {
                temp = arr[i];
                for (j = i - dk; j >= 0 && arr[j] > temp; j -= dk) {
                    arr[j + dk] = arr[j];
}
                arr[j + dk] = temp;
}
        }
        return arr;
}

    /**
     * 氣泡排序
* 時間複雜度：O(n2)
     * 空間複雜度：O(1)
     * 穩定的排序演算法
*/
public static int[] bubbleSort(int[] arr) {
        if (arr.length == 0) {
            return arr;
}
        int i, j;
        boolean flag = true;
        for (i = 1; i < arr.length && flag; i++) {
            flag = false;
            for (j = 0; j < arr.length-i; j++) {
                if (arr[j] > arr[j + 1]) {
                   swap(arr, j, j+1);
flag = true;
}//一次交換都未發生時，為false，表明已排序好
}
        }
        return arr;
}

    /**
     * 快速排序
* 時間複雜度：平均：O(nlogn), 最壞為O(n2)
     * 空間複雜度：O(logn), 最壞為O(n)
     * 不穩定的排序演算法
*/
public static int[] quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotLoc = partition(arr, low, high);
quickSort(arr, low, pivotLoc-1);   //低子表遞迴排序
quickSort(arr, pivotLoc+1, high);  //高字表遞迴排序
}
        return arr;
}
    //一趟快速排序
private static int partition(int[] arr, int i, int j) {
        int pivot = arr[i];       //暫存基準資料
while (i != j) {
           while (i < j && arr[j] >= pivot) {
               j--;         //從後遍歷查詢小於基準的資料
}
           if (i < j) {
               arr[i] = arr[j];
i++;
}

           while (i < j && arr[i] <= pivot) {
               i++;         //從前遍歷查詢大於基準的資料
}
           if (i < j) {
               arr[j] = arr[i];
j--;
}
        }
        arr[i] = pivot;
        return i;
}

    /**
     * 直接選擇排序
* 時間複雜度：O(n2)
     * 空間複雜度：O(1)
     * 穩定的排序演算法
*/
public static int[] selectSort(int[] arr) {
        if (arr.length == 0) {
           return arr;
}
        for (int i = 0; i < arr.length; i++) {
           int min = i;
           for (int j = i+1; j < arr.length; j++) {
               if (arr[j] < arr[i])
                  min = j;
}
           swap(arr, i, min);
}
        return arr;
}

    /**
     * 歸併排序
* 時間複雜度：O(nlogn)
     * 空間複雜度：O(n)
     * 穩定的排序演算法
*/
public static int[] mergeSort(int[] arr) {
        if (arr.length < 2) {
            return arr;
}
        int mid = arr.length / 2;
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        return merge(mergeSort(left), mergeSort(right));
}
    //將兩段排序好的陣列結合成一個排序陣列
private static int[] merge(int[] left, int[] right) {
        int[] r = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < r.length; index++) {
            if (i >= left.length)
                r[index] = right[j++];
            else if (j >= right.length)
                r[index] = left[i++];
            else if (left[i] > right[j])
                r[index] = right[j++];
            else
r[index] = left[i++];
}
        return r;
}

    /**
     * 測試
*/
public static void main(String[] args) {

        int[] arr = {7,2,4,5,3,6,2,8};
        int[] brr = MyArrays.insertSort(arr);
System.out.println(Arrays.toString(brr));
        int[] d = {5, 3, 1};
brr = MyArrays.shellSort(arr, d);
System.out.println(Arrays.toString(brr));
brr = MyArrays.bubbleSort(arr);
System.out.println(Arrays.toString(brr));
brr = MyArrays.quickSort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(brr));
brr = MyArrays.selectSort(arr);
System.out.println(Arrays.toString(brr));
brr = MyArrays.mergeSort(arr);
System.out.println(Arrays.toString(brr));
}
}

測試結果：

最後，全部原始碼已經上傳到github，需要的小夥伴可以自己去下載哈~~

=================

=================