排序算法

直接插入排序

import java.util.Arrays;

//直接插入排序
public class StraightInsertionSort {
    public static void InsertSort(int[] A) {
        for (int i = 1; i < A.length; i++) {
            int target = A[i];
            int j = i;
            while (j > 0 && target < A[j - 1]) {
                A[j] = A[j - 1];
                j--;
            }
            A[j] = target;
            System.out.println(Arrays.toString(A));
        }
    }

    public static void main(String[] args) {
        int[] A = { 49, 38, 65, 97, 76, 13, 27, 49 };
        InsertSort(A);
    }

}

折半插入排序

import java.util.Arrays;

//二叉排序
public class BinaryInsertionSort {
    public static void BInsertSort(int A[]){
        for(int i=1;i<A.length;i++){
            int low = 0;
            int high = i-1;
            int target = A[i];
            while(low<=high){
                int mid = (low+high)/2;
                if(target<A[mid]){
                    high = mid - 1;
                }else{
                    low = mid+1;
                }
            }
            for(int j=i; j>high+1;j--){
                A[j] = A[j-1];
            }
            A[high+1] = target;
            System.out.println(Arrays.toString(A));
        }
    }

    public static void main(String[] args) {
        int[] A={49,38,65,97,76,13,27,49};
        BInsertSort(A);
    }
}

希尔排序

import java.util.Arrays;

//希尔排序
public class ShellSort {
    public static void shellSort(int[] A, int dk) {
        for (int i = dk; i < A.length; i++) {
            int target = A[i];
            int j = i - dk;
            while (j >= 0 && target < A[j]) {
                A[j + dk] = A[j];
                j -= dk;
            }
            A[j + dk] = target;
        }
    }
    public static void main(String[] args) {
        int[] dks = { 5, 3, 1 };
        int[] A = { 49, 38, 65, 97, 76, 13, 27, 49, 55, 04 };
        for (int i = 0; i < dks.length; i++) {
            shellSort(A, dks[i]);
            System.out.println(Arrays.toString(A));
        }
    }
}

堆排序

import java.util.Arrays;

public class HeapSortTest {

    /**
     * 数组下标从0开始，根节点下标为i，则它的左右子树的根节点为2*i+1,2*i+2
     * 
     * @param args
     */
    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void HeapAdjust(int[] A, int i, int n) {
        int child = 0;
        int tmp;// 需要调整的结点
        for (tmp = A[i]; leftChild(i) < n; i = child) {//自上向下调整，每次i指向当前待调整节点的孩子节点中的最大值
            child = leftChild(i);
            if (child != n - 1 && A[child] < A[child + 1])
                child++;
            if (tmp < A[child])
                A[i] = A[child];
            else
                break;
        }
        A[i] = tmp;
    }

    private static void swap(int[] a, int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    private static void HeadSort(int[] A) {
        for (int i = A.length / 2 - 1; i >= 0; i--) {// 建立大顶堆
            HeapAdjust(A, i, A.length);
        }
        for (int i = A.length - 1; i > 0; i--) {
            swap(A, 0, i);
            HeapAdjust(A, 0, i);
        }
    }

    public static void main(String[] args) {
        // int[] A = { 1,3,4,5,7,2,6,8,0 };
        int[] A = { 49, 38, 65, 97, 76, 13, 27, 49 };
        HeadSort(A);
        System.out.println(Arrays.toString(A));

    }
}

快速排序

import java.util.Arrays;

//快速排序
public class QuickSort {

    public static int Partition(int[] A, int low, int high) {
        int pivotkey = A[low];
        while (low < high) {
            while (low < high && A[high] >= pivotkey)
                --high;
            A[low] = A[high];
            while (low < high && A[low] <= pivotkey)
                ++low;
            A[high] = A[low];
        }
        A[low] = pivotkey;
        System.out.println(Arrays.toString(A));
        return low;
    }

    public static void QSort(int[] A, int low, int high) {
        int pivotloc;
        if (low < high) {
            pivotloc = Partition(A, low, high);
            QSort(A, low, pivotloc - 1);
            QSort(A, pivotloc + 1, high);
        }
    }

    public static void main(String[] args) {
        int[] A = { 49, 38, 65, 97, 76, 13, 27, 49 };
        QSort(A, 0, A.length - 1);
        System.out.println("最终结果：" + Arrays.toString(A));
    }
}

归并排序

import java.util.Arrays;

public class MergeSort {

    private static void merge(int[] s, int[] t, int leftPos, int rightPos, int rightEnd) {
        // 将有序的S[leftPos...rightPos-1]和S[rightPos...rightEnd]归并为有序的T[leftPos...rightEnd]
        int tmpPos = leftPos;
        int leftEnd = rightPos - 1;
        while (leftPos <= leftEnd && rightPos <= rightEnd) {
            if (s[leftPos] <= s[rightPos]) {// 将较小的数移到新数组中
                t[tmpPos++] = s[leftPos++];
            } else {
                t[tmpPos++] = s[rightPos++];
            }
        }
        while (leftPos <= leftEnd) {
            t[tmpPos++] = s[leftPos++];
        }
        while (rightPos <= rightEnd) {
            t[tmpPos++] = s[rightPos++];
        }
    }

    private static void MSort(int[] s, int[] t, int left, int right) {
        int mid;
        if (left < right) {
            mid = (left + right) / 2;
            MSort(s, t, left, mid);
            MSort(s, t, mid + 1, right);
            merge(s, t, left, mid + 1, right);
        }
    }

    public static void main(String[] args) {
        int[] s = { 49, 38, 65, 97, 76, 13, 27 };
        int[] t = new int[s.length];
        MSort(s, t, 0, s.length - 1);
        System.out.println(Arrays.toString(t));
    }
}