Java实现常见的几种排序

package Sort;

/**
 * Created by lenovo on 2017/9/6.
 */
/*
* 优化的冒泡排序
* 如果数组i之后元素之间没有发生交换，那么说明i之后的元素已经排好序了，此时flag标记为false，
* 数组排序结束，否则继续进行比较、交换。
* */
public class BubbleSort {
    public void bubbleSort(int[] array) {
        int length = array.length;
        boolean flag = true;
        for (int i = 0; i < length-1 && flag; i++) {
            flag = false;
            for (int j = length-2; j >=i; j--) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    flag = true;
                }
            }
        }
    }
    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void main(String[] args){
        BubbleSort bubbleSort=new BubbleSort();
        int[] a={5,2,3,4,1};
        bubbleSort.bubbleSort(a);
        for (int n:a)System.out.println(n);
    }
}

package Sort;

/**
 * Created by lenovo on 2017/9/6.
 */
/*
*简单选择排序
* 每轮比较过后，找出最小值的下标minIndex，如果i==minIndex，则找到最小值，不需要交换;
* 如果i!=minIndex，则需要交换i与minIndex位置的数值
* */
public class SelectSort {
    public void selectSort(int[] array){
        int length=array.length;
        int minIndex;
        for (int i=0;i<length-1;i++){
            minIndex=i;
            for (int j=i+1;j<length;j++){
                if (array[j]<array[minIndex])
                    minIndex=j;
            }
            if (minIndex!=i)
                swap(array,minIndex,i);
        }
    }
    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void main(String[] args){
        SelectSort selectSort=new SelectSort();
        int[] a={5,2,3,4,1};
        selectSort.selectSort(a);
        for (int n:a)System.out.println(n);
    }
}

package Sort;

/**
 * Created by lenovo on 2017/9/5.
 */
public class HeapSort {
    //堆排序:
    // 将无序序列{50,10,90,30,70,40,80,60,20}转换成{0,50,10,90,30,70,40,80,60,20}
    // 使原序列数字下标一次为1,2,3,4,5,6,7,8,9；
    // 1，将无序序列构建成一个大顶堆（大顶堆：任意结点的值大于其所有子结点的值）;
    // 2，结合完全二叉树性质，找出该大顶堆中的根结点（下标为在[1，length/2]范围的结点都是根结点）;
    // 3，将所有的根结点所在的子树构建成一个大顶堆;
    // 4，将整个无序序列构建成一个大顶堆后，将堆顶结点值与当前大顶堆最后一个结点值交换,
    // 此时大顶堆结构被破坏，再将[1,i-1]重构成大顶堆，i的初始值为length，之后重复步骤4;
    public void heapSort(int[] array) {
        int length = array.length;
        int i;
        int[] heapArray = new int[length + 1];
        System.arraycopy(array, 0, heapArray, 1, length);
        for (i = length / 2; i > 0; i--)
            HeapAdjust(heapArray, i, length);
        for (i = length; i > 1; i--) {
            swap(heapArray, 1, i);
            HeapAdjust(heapArray, 1, i - 1);
        }
        System.arraycopy(heapArray, 1, array, 0, length);
    }

    public void HeapAdjust(int[] array, int i, int length) {
        int root = array[i];
        for (int j = 2 * i; j <= length; j = 2 * j) {
            if (j < length && array[j + 1] > array[j])
                j = j + 1;
            if (root < array[j]) {
                array[i] = array[j];
                i = j;
            } else break;
        }
        array[i] = root;
    }

    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

package Sort;

/**
 * Created by lenovo on 2017/9/4.
 */
public class StraightInsertSort {
    //直接插入排序
    public void straightInsertSort(int[] array) {
        int length = array.length;
        int soldier, i, j;
        for (i = 1; i < length; i++) {
            if (array[i - 1] > array[i]) {
                soldier = array[i];//设置哨兵
                for (j = i - 1; j >= 0 && array[j] > soldier; j--)
                    array[j + 1] = array[j];
                array[j + 1] = soldier;
            }
        }
    }

    public static void main(String[] args) {
        StraightInsertSort s = new StraightInsertSort();
        int[] a = {5, 3, 4, 6, 2};
        s.straightInsertSort(a);
        for (int n : a) System.out.print(n);
    }
}

package Sort;

/**
 * Created by lenovo on 2017/9/5.
 */
public class ShellSort {
    //希尔排序：设置增量，将序列分割成几个子序列，分别对子序列进行“直接插入排序”，使整个序列基本有序；
    // 最后increment=1再对整个序列进行直接插入排序。
    public void shellSort(int[] array) {
        int length = array.length;
        int increment = length;
        int soldier, i, j;
        do {
            increment = increment / 3 + 1;
            for (i = increment; i < length; i += increment) {
                if (array[i - increment] > array[i]) {
                    soldier = array[i];
                    for (j = i - increment; j >= 0 && array[j] > soldier; j -= increment)
                        array[j + increment] = array[j];
                    array[j + increment] = soldier;
                }
            }
        } while (increment > 1);
    }

}

package Sort;

/**
 * Created by lenovo on 2017/9/5.
 */
public class MergeSort {
    //归并排序
    public void mergeSort(int[] array) {
        int length = array.length;
        int[] newArray = new int[length];
        int k = 1;
        while (k < length) {
            //将array序列分割成若干长度为k的子序列，再将这些子序列两两合并，放进序列newArray
            MergePass(array, newArray, k, length);
            //长度k加倍
            k = k * 2;
            //将进行过一轮排序以及合并后的序列newArray再分割成若干长度为k的子序列，再将这些子序列两两合并，放进序列Array
            MergePass(newArray, array, k, length);
            //长度k再加倍
            k = k * 2;
        }
    }

    public void MergePass(int[] array, int[] newArray, int dis, int length) {
        int i = 0;
        /*
        * 情况1：按长度为dis来分割整个序列array，分割过程中当剩余的序列array长度>=2dis时，
        * 可以进行分割归并，如下
        * */
        while (i <= length - 2 * dis) {
            Marge(array, newArray, i, i + dis - 1, i + 2 * dis - 1);
            i = i + dis * 2;
        }
        /*
        *情况2：分割过程中当最后剩余的序列array长度在(dis,2dis)范围时，将序列仅且分为2个子序列，
        *  一个长度为dis,另一个长度不足dis，将两个子序列进行归并
        * */
        if (i < length - dis)
            Marge(array, newArray, i, i + dis - 1, length - 1);
        /*
        * 情况3：分割过程中当最后剩余的序列array长度在<dis时,那么只有一个长度不足dis的子序列，
        * 无法进行归并，则剩下的这个子序列直接添加进newArray末尾
        * */
        else
            for (int j = i; j < length; j++) {
                newArray[j] = array[j];
            }
    }

    public void Marge(int[] array, int[] newArray, int i, int mid, int last) {
        int k = i;//newArray下标k
        int j = mid + 1;
        //待合并的两个子序列array[i,mid]和array[mid+1,last]的元素逐个进行比较，
        // 从小到大依次存入newArray数组里面，算是完成了两个子序列的合并
        for (; i <= mid && j <= last; k++) {
            if (array[i] < array[j]) newArray[k] = array[i++];
            else newArray[k] = array[j++];
        }
        //上述比较过后，将第一个子序列的剩余元素存入newArray
        if (i <= mid)
            for (int l = i; l <= mid; l++)
                newArray[k++] = array[l];
        //上述比较过后，将第二个子序列的剩余元素存入newArray
        if (j <= last)
            for (int l = j; l <= last; l++)
                newArray[k++] = array[l];
    }
}

package Sort;

/**
 * Created by lenovo on 2017/9/5.
 */
public class QuickSort {
    //快速排序
    //找一个分割点part，part左边的数小于part，右边的数大于part，依次规则，
    // 将子序列的首个数字设置成一个哨兵，将它与该子序列的其他元素进行比较交换，
    // 使得整个子序列最终的排序结果为：哨兵左边的数小于哨兵，右边的数大于哨兵，返回part的下标；
    //然后以part下标为分割点将序列分为左右两个子序列。
    //依次对左右子序列进行寻找分割点、分割成更小的子序列的操作，直到序列不能再分割。
    public void quickSort(int[] array) {
        int length = array.length;
        QSort(array, 0, length - 1);
    }

    public void QSort(int[] array, int low, int high) {
        int partIndex;
        if (low < high) {
            partIndex = getPartIndex(array, low, high);
            QSort(array, low, partIndex);
            QSort(array, partIndex + 1, high);
        }
    }

    public int getPartIndex(int[] array, int low, int high) {
        int soldier = array[low];
        while (low < high) {
            while (low < high && array[high] >= soldier)
                high--;
            swap(array, low, high);
            while (low < high && array[low] <= soldier)
                low++;
            swap(array, low, high);
        }
        return low;
    }
    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

}