简单的几种排序算法源码

package com.xun.test;

import java.util.Random;

public class Test {

    /**
     * 随机数生成器
     *
     * @param scope
     *            数值的大小范围
     * @param amount
     *            数据个数
     * @return 返回一个指定数值范围的数字个数数组
     */
    public static int[] generator(int scope, int amount) {
        int[] datas = new int[amount];

        Random random = new Random();
        for (int i = 0; i < amount; i++) {
            datas[i] = random.nextInt(scope);
        }
        return datas;
    }

    /**
     * 展示数组里面的单个信息
     *
     * @param datas
     */
    public static void showInfo(int[] datas) {
        for (int d : datas) {
            System.out.print(d + "\t");
        }
        System.out.println();
    }

    /**
     * 冒泡
     *
     * @param datas
     *            需要排序的INT类型数组
     * @return 返回一个有序的IN类型的数组
     */
    public static int[] bubble(int[] datas) {
        for (int i = 0; i < datas.length; i++) { // 以第I个索引的数值作为基点
            for (int j = (i + 1); j < datas.length; j++) { // 把这个基点和这个基点位置以后的数值进行比较，并进行大小替换，达到当前基点的位置的数值是最小数值
                int tempData = datas[i];
                if (datas[i] > datas[j]) {
                    datas[i] = datas[j];
                    datas[j] = tempData;
                }
            }
        }
        return datas;
    }

    /**
     * 选择排序：改进了冒泡排序，降低类交换的次数。通过记录交换的索引位置，在进行一次以某数值为基点的比较结束后，通过最终的索引来进行交换
     *
     * @param args
     */
    public static int[] SelectionSort(int[] datas) {
        for (int i = 0; i < datas.length; i++) { // 以第I个索引的数值作为基点
            int tempIndex = i; // 需要替换的索引
            int referenceValue = datas[i];
            for (int j = (i + 1); j < datas.length; j++) { // 把这个基点和这个基点位置以后的数值进行比较，并进行大小替换，达到当前基点的位置的数值是最小数值
                if (referenceValue > datas[j]) {
                    referenceValue = datas[j];
                    tempIndex = j;
                }
            }
            int tempValue = datas[i];
            datas[i] = datas[tempIndex];
            datas[tempIndex] = tempValue;
        }
        return datas;
    }

    /**
     * 二分查找：前提是需要一个有序的数组，在数组中通过比较进行对折的缩小范围来查找目标数据，基本的思路就是首先取平均值，通过和平均值的比较，
     * 来确定数值的范围是在左边还是右边，依次循环来减少查找的范围
     *
     * @param datas
     *            查询的数组
     * @param findData
     *            需要查询的数据
     * @return true 查询成功 false 查询失败
     */
    public static boolean binarySearch(int[] datas, int findData) {
        int startPositon = 0;
        int endPositon = datas.length;
        int pointerIndex = 0;
        boolean response = false;

        while (startPositon <= endPositon) {
            pointerIndex = (startPositon + endPositon) / 2;
            if (findData > datas[pointerIndex]) {
                startPositon = pointerIndex;
            } else if (findData < datas[pointerIndex]) {
                endPositon = pointerIndex;
            } else {
                response = true;
                break;
            }
        }
        return response;
    }
    
    /**
     * 递归实现二分法查找
     * @param data            查找的数组
     * @param startPosion    数组查找的开始范围
     * @param endPosition    数组查找的结束范围
     * @param targetValue     需要查找的数值
     * @return
     */
    public static boolean binarySearchRecursion(int[] datas, int startPostion, int endPosition, int targetValue) {
        if(startPostion <= endPosition) {
            int pointerIndex = (startPostion + endPosition) / 2;
            if (targetValue > datas[pointerIndex]) {
                startPostion = pointerIndex + 1;        //当前索引值pointerIndex已经比较了，对于程序优化，直接从下一个索引开始
                return binarySearchRecursion(datas,startPostion,endPosition,targetValue);
            } else if (targetValue < datas[pointerIndex]) {
                endPosition = pointerIndex - 1;
                return binarySearchRecursion(datas,startPostion,endPosition,targetValue);
            } else {
                return true;
            }
        }else {
            return false;
        }
    }
    
    
    /**
     * 插入排序：通过标记基点，与左边的元素挨个进行比较，如果左边的数据比右边的大，则移动到右边，依次比较，知道左边的数据比右边的数据小，那么插入当前基点到当前位置
     *             主要就是给基点在左边跟它找到适合的位置
     * @param datas
     * @return
     */
    public static int[] insertionSort(int[] datas) {
        
        int leftIndex;
        int rightIndex;
        
        for(rightIndex = 1; rightIndex < datas.length; rightIndex++) {                //设置比较的基点数据
            int tempValue = datas[rightIndex];                                        
            leftIndex = rightIndex;
            
            while(leftIndex > 0 && datas[leftIndex-1] >= tempValue) {
                datas[leftIndex] = datas[leftIndex-1];
                --leftIndex;
            }
            datas[leftIndex] = tempValue;
        }
        return datas;
    }

    public static void main(String[] args) {
        int[] datas = Test.generator(50, 10);
        Test.showInfo(datas); // 原始数据
        // Test.showInfo(Test.bubble(datas)); //冒泡算法排序
        // Test.showInfo(Test.SelectionSort(datas));
        //int[] datas = { 0, 6, 10, 12, 16, 21, 25, 26, 42, 48, 62 };
        //普通的二分查找
        /*if (Test.binarySearch(datas, 62)) {
            System.out.println("数据存在");
        } else {
            System.out.println("数据不存在");
        }*/
        //用递归进行查找
        /*if (Test.binarySearchRecursion(datas, 0, datas.length-1, 22)) {
            System.out.println("数据存在");
        } else {
            System.out.println("数据不存在");
        }*/
        //插入排序
        Test.showInfo(Test.insertionSort(datas));
    }

}