简单选择排序、直接插入排序、归并排序

转载：http://blog.csdn.net/pzhtpf/article/details/7559943

一、简单选择排序

基本思想：

在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

实例：

Java实现：

package com.tao.algorithm;

/**
 * Created by michael on 17-8-13.
 */
public class 简单选择排序 {

    public static void main(String[] args) {

        int[] a = new int[] {49,38,65,97,76,13,27,49,78,34,12,64,5,4,
                62,99,98,54,56,17,18,23,34,15,35,25,53,51};

        System.out.println("排序前：");
        print(a);

        //冒泡排序
        selectSort(a);

        System.out.println("排序后：");
        print(a);
    }


    /**
     * 简单选择排序
     * @param array
     */
    public static void selectSort(int[] array) {

        int length = array.length;
        int temp, minIndex;

        for(int i = 0; i < length; i++) {
            minIndex = i;
            for(int j = i+1; j < length; j++) {
                if(array[j] < array[minIndex]) {
                    //找到最小值的索引
                    minIndex = j;
                }
            }
            temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }

    }



    /**
     * 打印函数
     * @param array
     */
    public static void print(int[] array) {
        for (int a : array) {
            System.out.print(a + " ");
        }
        System.out.println();
    }
}

二、直接插入排序

基本思想：

在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

实例：

Java实现：

package com.tao.algorithm;

/**
 * Created by michael on 17-8-13.
 */
public class 直接插入排序 {

    public static void main(String[] args) {

        int[] a = new int[] {49,38,65,97,76,13,27,49,78,34,12,64,5,4,
                62,99,98,54,56,17,18,23,34,15,35,25,53,51};

        System.out.println("排序前：");
        print(a);

        //直接插入排序
        insertSort(a);

        System.out.println("排序后：");
        print(a);
    }


    /**
     * 直接插入排序
     * @param array
     */
    public static void insertSort(int[] array) {

        int length = array.length;
        int temp, j;

        for(int i = 1; i < length; i++) {
            temp = array[i];
            for(j = i; j > 0 && temp < array[j-1]; j--) {
                array[j] = array[j-1];
            }
            array[j] = temp;
        }
    }


    /**
     * 打印函数
     * @param array
     */
    public static void print(int[] array) {
        for (int a : array) {
            System.out.print(a + " ");
        }
        System.out.println();
    }
}

三、归并排序

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

实例：

Java实现：

package com.tao.algorithm;

import jdk.nashorn.internal.runtime.Context;

/**
 * Created by michael on 17-8-13.
 */
public class 归并排序 {

    public static void main(String[] args) {

        int[] a = new int[] {49,38,65,97,76,13,27,49,78,34,12,64,5,4,
                62,99,98,54,56,17,18,23,34,15,35,25,53,51};

        System.out.println("排序前：");
        print(a);

        //归并排序
        mergeSort(a, 0, a.length-1);

        System.out.println("排序后：");
        print(a);
    }


    /**
     * 归并排序
     * @param array
     * @param start
     * @param end
     */
    public static void mergeSort(int[] array, int start, int end) {

        if(start < end) {
            //找出中间位置
            int mid = (start+end)/2;
            //分别对左右进行归并排序
            mergeSort(array, start, mid);
            mergeSort(array, mid+1, end);
            //合并
            merge(array, start, mid, end);
        }
    }


    /**
     * 合并,合并的时候，左右两边是排好序的序列
     * @param array
     * @param start
     * @param mid
     * @param end
     */
    public static void merge(int[] array, int start, int mid, int end) {

        //暂存中间结果的数组
        int[] tempArray = new int[array.length];
        int pLeft = start;  //左边序列的游标
        int pRight = mid+1; //右边序列的游标
        int pTemp = start;  //临时数组的游标

        while(pLeft <= mid && pRight <= end) {
            //每次从两个序列中取出最小的放入临时数组
            if(array[pLeft] <= array[pRight]) {
                tempArray[pTemp++] = array[pLeft++];
            } else {
                tempArray[pTemp++] = array[pRight++];
            }
        }

        //剩余部分以此放入中间数组
        while(pLeft <= mid) {
            tempArray[pTemp++] = array[pLeft++];
        }
        while(pRight <= end) {
            tempArray[pTemp++] = array[pRight++];
        }

        //将临时数组的内容复制回原数组
        pTemp = start;
        while(pTemp <= end) {
            array[pTemp] = tempArray[pTemp++];
        }
    }



    /**
     * 打印函数
     * @param array
     */
    public static void print(int[] array) {
        for (int a : array) {
            System.out.print(a + " ");
        }
        System.out.println();
    }
}