java排序算法：选择排序、插入排序、冒泡排序、归并排序

 一、选择排序

时间复杂度O(n^2),不稳定。

package com.algorrithms.learn;

/**
 * @program: com.algorrithms.learn
 * @description: 选择排序
 * @author: liujinghui
 * @create: 2019-02-17 10:13
 **/
public class SelectSort {
    public static int[] selectSort(int ... num){
        for(int i=0;i<num.length;i++){
            int minIndex = i;
            for(int j=i;j<num.length;j++){
                if(num[j]<num[minIndex]){
                    minIndex = j;
                }
            }
            if(minIndex>i){
                int temp = num[i];
                num[i] = num[minIndex];
                num[minIndex] = temp;
            }
        }
        return num;
    }

    public static void main(String[] args) {
        int[] a = SelectSort.selectSort(new int[]{32,4,5,76,7,4,546,4435,5634,5654,654,876,8,67,43,534,6,554,8,6754,7,4523,4,2156,43,7653,8,7639,4});
        for(int i=0;i<a.length;i++){
            System.out.print(a[i] + ",");
        }
    }
}

二、插入排序

时间复杂度O(n^2),稳定。

package com.algorrithms.learn;

/**
 * @program: com.algorrithms.learn
 * @description: 插入排序
 * @author: liujinghui
 * @create: 2019-02-17 10:14
 **/
public class InsertSort {
    public static int[] insertSort(int ... num){
        for(int i=0 ;i<num.length;i++){
            for(int j=i+1;j>0 && j<num.length;j--){
                if(num[j]<num[j-1]){
                    int temp = num[j-1];
                    num[j-1] = num[j];
                    num[j] = temp;
                }else{
                    break;
                }
            }
        }
        return num;
    }

    public static void main(String[] args) {
        int[] a = InsertSort.insertSort(new int[]{32,4,5,76,7,4,546,4435,5634,5654,654,876,8,67,43,534,6,554,8,6754,7,4523,4,2156,43,7653,8,7639,4});
        for(int i=0;i<a.length;i++){
            System.out.print(a[i] + ",");
        }
    }
}

三、冒泡排序

时间复杂度O(n^2),稳定。

package com.algorrithms.learn;

/**
 * @program: com.algorrithms.learn
 * @description:冒泡排序
 * @author: liujinghui
 * @create: 2019-02-17 12:15
 **/
public class BubbleSort {
    public static int[] bubbleSort(int ... num){
        for(int i=0 ;i<num.length-1;i++){
            for(int j=0;j<num.length-1;j++){
                if(num[j+1]<num[j]){
                    int temp = num[j+1];
                    num[j+1] = num[j];
                    num[j] = temp;
                }
            }
        }
        return num;
    }

    public static void main(String[] args) {
        int[] a = BubbleSort.bubbleSort(new int[]{32,4,5,76,7,4,546,4435,5634,5654,654,876,8,67,43,534,6,554,8,6754,7,4523,4,2156,43,7653,8,7639,4});
        for(int i=0;i<a.length;i++){
            System.out.print(a[i] + " ");
        }
    }
}

四、归并排序

时间复杂度O(nlogn),稳定。

package com.algorrithms.learn;

/**
 * @program: com.algorrithms.learn
 * @description: 归并排序
 * @author: liujinghui
 * @create: 2019-02-17 13:27
 **/
public class MergeSort {
    private void merge(int[] num, int leftIndex, int midIndex, int rightIndex){
        int[] aux = new int[rightIndex-leftIndex+1];
        for(int i = leftIndex;i<=rightIndex;i++){
            aux[i-leftIndex] = num[i];
        }
        //临时空间的左部分头指针
        int auxLeftPartHeadIndex = 0;
        //临时空间的右部分头指针
        int auxRighPartHeadIndex = midIndex-leftIndex+1;
        //需要遍历num数组的头指针
        int numIndex = leftIndex;
        for(; numIndex<=rightIndex;numIndex++){
            System.out.println(auxLeftPartHeadIndex + " " + auxRighPartHeadIndex);
            // 如果左部分的头指针已经递增至右部分的域内时，
            // 说明左部分已经遍历完毕
            // 只需要将右部分头指针指向的节点顺序拷贝到num中即可
            if(auxLeftPartHeadIndex>midIndex-leftIndex) {
                num[numIndex] = aux[auxRighPartHeadIndex];
                auxRighPartHeadIndex++;
            }
            //如果右部分的头指针一直自增导致超出了右边界，
            // 那么说明右部分的值遍历完毕，该遍历左部分的值。
            //这时候只需要将左部分头结点的值拷贝到num中即可
            else if(auxRighPartHeadIndex>rightIndex-leftIndex){
                num[numIndex] = aux[auxLeftPartHeadIndex];
                auxLeftPartHeadIndex++;
            }
            //如果临时空间的左部分头指针 小于 临时空间的右部分头指针
            //说明需要将临时空间aux的[auxLeftHeadIndex]的值放入数组的index位置
            //同时临时空间的左部分头指针向右移动一位
            else if(aux[auxLeftPartHeadIndex]<aux[auxRighPartHeadIndex]){
                num[numIndex] = aux[auxLeftPartHeadIndex];
                auxLeftPartHeadIndex++;
            }
            //如果临时空间的右部分头指针 小于等于 临时空间的左部分头指针
            //说明需要将临时空间aux的[auxMidHeadIndex]的值放入数组的index位置
            //同时临时空间的右部分头指针向右移动一位
            else if(aux[auxRighPartHeadIndex]<=aux[auxLeftPartHeadIndex]){
                num[numIndex] = aux[auxRighPartHeadIndex];
                auxRighPartHeadIndex++;
            }else{
                //否则什么也不做
            }
        }
    }

    public void mergeSort(int[] num, int leftIndex, int rightIndex){
        if(leftIndex < rightIndex){
            int midIndex = (rightIndex-leftIndex)/2 +leftIndex ;//防溢出
            mergeSort(num, leftIndex, midIndex);
            mergeSort(num, midIndex+1, rightIndex);
            merge(num, leftIndex, midIndex, rightIndex);
        }
    }

    public static void main(String[] args) {
        int[] a = new int[]{32,4,5,76,7,4,546,4435,5634,5654,654,876,8,67,9,43,534,6,554,8,6754,7,4523,4,2156,43,7653,8,7639,4};
        MergeSort mergeSort = new MergeSort();
        mergeSort.mergeSort(a,0,a.length-1);
        for(int i=0;i<a.length;i++){
            System.out.print(a[i] + " ");
        }
    }
}