多种函数排序

public class Myarray {
    public static void main(String[] args) {
        int[] arr = {5, 1, 9, 7, 2, 8, 4, 3, 6};
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            int temp = arr[j];
            while (j > 0 && temp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = temp;
        }
        printArray(arr);
        int index = halfSeek(arr,7);
        if (index == -1) {
            System.out.println("not found");
        }else {
            System.out.println(index);
        }        
    }

 

    /**
     * 插入排序
     * @param array
     */
    static void insertSort(int[] array) {
        //向前插入元素的前提是前面元素必须是有序的
        //从下标为1的元素开始逐一向前插入
        for (int i = 1; i < array.length; i++) {
            //把当前i的位置定位向后顶元素的坑
            int j = i;
            //从坑中把需要向插入的元素取出保存
            int temp = array[j];
            //如果向前插入的元素的值小于坑前面的值，如果j==0表示1位置就是插入元素的位置，退出循环
            while (j > 0 && temp < array[j - 1]) {
                //向后顶前面的元素
                array[j] = array[j - 1];
                //向前移坑
                j--;
            }
            //如果循环结束，当前j的位置就是要插入元素的位置
            array[j] = temp;
        }
    }
    /**
     * 折半查找
     * @param array
     * @param target
     * @return
     */
    static int halfSeek(int[] array, int target) {
        int start = 0;
        int end = array.length - 1;
        while (start <= end) {
            int mid = (start + end) / 2;
            //如果中间点大于目标
            if (array[mid] > target) {
                //收缩终点
                end = mid - 1;
                //如果中间点小于目标
            }else if (array[mid] < target) {
                //收缩起点
                start = mid + 1;
            }else {
                //不大于也不小于，代表找到目标，返回mid
                return mid;
            }
        }
        //如果循环正常结束，代表没有找到目标，返回-1
        return -1;
    }
    /**
     * 选择排序
     * @param array
     */
    static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = minIndex + 1; j < array.length; j++) {
                if (array[minIndex] > array[j]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }    
    }
    /**
     * 打乱数组
     * @param array
     */
    static void breakArray(int[] array) {
        for (int i = array.length - 1; i >= 0; i--) {
            int r = (int)(Math.random() * (i + 1));
            int temp = array[r];
            array[r] =array[i];
            array[i] = temp;
        }
    }
    
    /**
     * 计算数组中最大值
     * @param array
     * @return
     */
    static int maxValueOfArray(int[] array) {
        return array[maxValueIndexOfArray(array)];
    }
    
    /**
     * 计算数组中最大值的位置
     * @param array
     * @return
     */
    static int maxValueIndexOfArray(int[] array) {
        //假定下标为0的位置是最大值的位置
        int maxIndex = 0;
        //从下标1开始向后比较
        for (int i = 1; i < array.length; i++) {
            //如果最小值下标位置的元素比当前i指向的元素小
            if (array[maxIndex] < array[i]) {
                //保存当前下标为最大值的下标
                maxIndex = i;
            }
        }
        return maxIndex;
    }
    
    /**
     * 计算数组中的最小值
     * @param array
     * @return
     */
    static int minValueOfArray(int[] array) {
        return array[minValueIndexArray(array)];
    }
    
    /**
     * 计算数组中最小值的位置
     * @param array
     * @return
     */
    static int minValueIndexArray(int[] array) {
        //假定0位最小值位置
        int minIndex = 0;
        for (int i = 1; i < array.length; i++) {
            if (array[minIndex] > array[i]) {
                minIndex = i;
            }
        }
        return minIndex;
    }
    static void bubbleSort(int[] array) {
        boolean flag = false;
        int iMax = array.length - 1;
        for (int i = 0; i < iMax; i++) {
            flag = true;
            for (int j = 0; j < iMax - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;
                }
            }
        }
    }
    
    static String array2String(int[] array) {
        if (array == null) {
            return "null";
        }
        int iMax = array.length - 1;
        if (iMax == -1) {
            return "[]";
        }
        StringBuilder s = new StringBuilder();
        s.append("[");
        for (int i = 0; ; i++) {
            s.append(array[i]);
            if (i == iMax) {
                return s.append("]").toString();
            }
            s.append(",");
        }
    }
    
    
    static void printArray(int[] array) {
        System.out.println(array2String(array));
    }
}