数组的排序和查找

---

一、数组的排序（升序）

1、选择排序

让数组中的每一位数字，依次与后面全部元素进行比较，如果后面的数字大于前面的数字，将它们进行交换，直到最后一位。

    public static void selectSort(int[] arr){
        for (int x=0;x<arr.length;x++){
            for (int y=x+1;y<arr.length-1;y++){
                if (arr[x]>arr[y]){
                    int temp=arr[x];
                    arr[x]=arr[y];
                    arr[y]=temp;
                }
            }
        }
    }

2、冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

外层n-1，内层n-1-i

    public static void bubbleSort(int arr[]) {
        for(int i =0 ; i<arr.length-1 ; i++) { 
            for(int j=0 ; j<arr.length-1-i ; j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j]=arr[j+1];    
                    arr[j+1]=temp;
               }
            }    
        }
    

3、插入排序

选定第n位（n>=2且n前面的数字已经排好序），与前面的数字进行比较，比这个数字大的数全部后移一位，然后将这个数插入进去。

   public static void inserSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    int pos = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = pos;
                }
            }
        }
    }

4、快速排序

选定一个数作为轴（基准数，一般选定第一个数），然后把比这个数大的全部放在这个数的右边，比这个数小的全部放在这个数的左边；再对这个数的左右两边重复这个步骤，直到左右两边都只剩下一个数。

public static void quickSort(int[] arr,int start,int end){
		//选定轴
        int pos=arr[start];
        //选取头、尾两边向中间靠拢判断
        int i=start;
        int j=end;
        //判断是否判断结束
        while(i<j){
            //从左到右，判断数字是否比轴大
            while (i<j&&arr[j]>pos){
                j--;
            }
            //将比轴小的数换到右边
            arr[i]=arr[j];
            i++;
            //从右到左，判断数字是否比轴小
            while (i<j&&arr[i]<pos){
                i++;
            }
             //将比轴大的数换到左边
            arr[j]=arr[i];
            j--;
        }
        //获取轴的值
        arr[i]=pos;

        //判断左边是否还有元素
        if(i-1>start){
        	//递归
            quickSort(arr,start,i-1);
        }
        //判断右边是否有元素
        if (j+1<end){
        	//递归
            quickSort(arr,j+1,end);
        }
    }

5、归并排序

    /**
     * 切分数组，使得左右两边的小数组先有序，然后在进行左右两边合并
     */
    public static class MergeSort {

        public void sort(int[] arr) {
            int[] temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
            sort(arr, 0, arr.length - 1, temp);
        }
        private void sort(int[] arr, int left, int right, int[] temp) {
            //判断数组中元素的个数是否大于1
            if (left < right) {
                int mid = (right + left) >> 1;//使数组一分为二
                sort(arr, left, mid, temp);//左边递归排序
                sort(arr, mid + 1, right, temp);//右边递归排序
                merge(arr, left, mid, right, temp);//左右子数组合并
            }
        }
        public void merge(int[] arr, int left, int mid, int right, int[] temp) {
            int i = left;
            int j = mid + 1;
            int t = 0;
            while (i <= mid && j <= right) {
                //判断数的大小，将较小数优先放入新数组
                if (arr[i] < arr[j]) {
                    temp[t++] = arr[i++];
                } else {
                    temp[t++] = arr[j++];
                }
            }
            //将左子数组剩余数放入数组
            while (i <= mid) {
                temp[t++] = arr[i++];
            }
            //将右子数组剩余数放入数组
            while (j <= right) {
                temp[t++] = arr[j++];
            }
            //将temp中的元素全部拷贝到原数组中
            t = 0;
            while (left <= right) {
                arr[left++] = temp[t++];
            }
        }
    }

二、有序数组的查找

1、顺序查找

略

2、折半查找

    public static int halfSearch(int[] arr, int key) {
        int min = 0, max = arr.length - 1, mid;
        mid = (min + max) / 2;
        while (arr[mid] != key) {
            if (key > arr[min]) {
                min = mid + 1;
            } else if (key < arr[max]) {
                max = mid - 1;
            }
            if (min > max)
                return -1;
            mid = (min + max) / 2;
        }
        return mid;
    }