排序和二分法查找

      排序和查找是我们经常用到的方法，通常编译器也会自带这类方法如java里面的Arrays.sort()和Arrays.binarySearch(a, key),排序通常有两种方法，插入排序和冒泡排序，一般来说，冒泡排序比插入排序的效率更更高。查找数组中某个值的位置，如果数组是有序数组，二分法查找是个不错的选择。以下为测试代码：

package sorts;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Sorts {
    public static void main(String[] args) {
        int[] a = random();
        int[] b = Arrays.copyOfRange(a, 0, a.length-1);
        System.out.println(Arrays.toString(a));

        sort(a);
        System.out.println(Arrays.toString(a));
        
        sort1(b);
        System.out.println(Arrays.toString(b));
        
        System.out.println("请输入要查找的值：");
        int in = new Scanner(System.in).nextInt();
        int index = binarySearch(a,in);
        System.out.println("查找到的索引为: "+index);
    }
    /**
     * 二分法查找数据，数组a一定是有序的。
     * @param a 数组
     * @param value 要查找的数值
     * @return 返回查找到数值的索引。
     */
    private static int binarySearch(int[] a, int value) {
        int min = 0;
        int max = a.length-1;
        while(min<=max){
            int mid = (min+max)/2;
            if(a[mid]>value){
                max=mid-1;
            }else if(a[mid]<value){
                min=mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }
    
    /**
     * @param 整形数组，该方法实现对数组的插入排序,从小到大排序。
     * 
     */
    private static void sort(int[] a) {
        for(int i=1;i<a.length;i++){
            for(int j=i-1;j>=0;j--){
                
                if(a[j+1]<a[j]){
                    int temp = a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }else{
                    break;
                }
            }
        }
    }
    /**、
     * 冒泡排序
     * @param a 整形数组
     */
    private static void sort1(int[] a) {
        for(int i = 0;i<a.length;i++){
            boolean flag =true;
            for(int j=a.length-1;j>i;j--){
                if(a[j]<a[j-1]){
                    int temp = a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                    flag = false;//有交换
                }
            }
            if(flag){
                break;
            }
        }
        
    }
    
    /**
     * 产生一个随机长度的随机数组
     * @return 返回一个随机长度的随机数组
     */
    private static int[] random() {
        int len = 5+ new Random().nextInt(6);
        int[] a = new int[len];
        for(int i= 0;i<len;i++){
            a[i] = new Random().nextInt(1000);
        }
        return a;
    }
}