Java排序并查找对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找元素 6 并输出排序后的下标。

题目：

排序并查找对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找元素 6 并输出排序后的下标。

语言类型：Java语言

操作环境：Window 10

使用工具：IntelliJ IDEA 2020.1.4

分析：

首先把题目拆分，对数组排序，对数组查找，查找完后输出下标。

排序：排序有很多方法，比如：简单排序有冒泡排序、简单选择排序和直接插入排序，改进算法有希尔排序、快速排序、堆排序、归并排序等。不论哪种排序算法，通常要比较两个元素的大小，然后移动元素位置。

我这里使用的是冒泡排序。

冒泡排序：

冒泡排序是一种简单的交换类排序方法，其基本思想是：（这里默认是升序）第一轮，从数组第1个元素进行标记，与第2个元素，如果第1个元素大于第2个元素，那么这时候需要一个临时存放的变量来存储第1个元素，然后把第2个元素放到第1个，最后把临时存放的元素放到第2个，这样就完成了一次交换。以此类推，第一轮完成后，可以把最大的元素像泡泡一样往一个方向逐渐冒出来，并放到最后一个元素的位置上。然后进行迭代n-1轮，直到没有发生交换元素，说明整个数组已经全部达到要求，冒泡排序完成。

int temp;                      //设数组的第一个数为临时变量
boolean flag;                  //用于判断是有数据进行交换
for (int i=1; i<arr.length-1; i++){     //对数组进行两轮迭代比较
    flag = false;                       //每次迭代时都把flag置为false
    for (int j=0; j<arr.length-i;j++){  //
        if (arr[j]>arr[j+1]){           //如果数组的第一个比第二个大
          temp = arr[j];              //就先把第一个放到临时数
          arr[j] = arr[j+1];          //然后把第二个放到第一个
          arr[j+1] = temp;            //最后把临时数也就是之前的第一个数放到第二个
          flag = true;                //如果有数据交换就把flag置为true
         }
     }
     if (!flag) {          //如果没有发生交换那么这一轮就中断
         break;
      }
}

对数组进行冒泡排序后就可以进行二分查找了。

二分查找：

二分查找也叫折半查找，它主要的思想是通过将查找范围减小一半，来提高查找速度。

为了限定查找范围，需要设置3个标识minIndex、maxIndex和centerIndex，

其中centerIndex=（minIndex+maxIndex）/ 2，分别用来标记查找范围内的最小下标、最大下标和中间下标。

二分查找要求查找的数组中所有的元素，已经按有序（升序）排列。实现方法：

步骤1：定义标识的初始值，即minIndex = 0和maxIndex = arr.length - 1，也就是minIndex标记数组的第1个元素，maxIndex标记数组最后1个元素。

步骤2：如果minIndex大于maxIndex，则查找失败，说明数组中没有这个数据，结束查找；否则继续计算centerIndex的值，直到与目标值相等。

步骤3：将centerIndex所标记下标的值与目标值进行比较，如果相等，则查找成果，结束查找；否则又分为以下两种情况。

①如果centerIndex标记下标的值大于目标值，则数组查找的范围缩小到[minIndex,centerIndex-1],即保持minIndex不变，maxIndex=centerIndex-1；

②如果centerIndex标记下标的值小于目标值，则数组查找的范围缩小到[centerIndex+1,maxIndex],即保持maxIndex不变，minIndex=centerIndex+1；

        int minIndex = 0;                           //最小下标
        int maxIndex = arr.length - 1;              //最大下标
        int centerIndex = (minIndex + maxIndex) / 2;//中间下标
        while(true){
            if (tar > arr[centerIndex]){            //如果目标值大于数组中间下标的值
                minIndex = centerIndex + 1;         //就把最小下标移动到中间下标的右边，也就是加一
            }else if (tar < arr[centerIndex]){      //如果目标值小于数组中间下标的值
                maxIndex = centerIndex - 1;        //就把最大下标移动到中间下标的左边，也就是减一
            }else{                                  //如果相等了，也就是找到目标值
                break;                              //那么就中断while循环
            }
            if (minIndex > maxIndex){               //如果最小下标在最大下标的右边
                System.out.println("没有这个数据！");  //说明没有这个数据
                break;
            }
            centerIndex = (minIndex + maxIndex) / 2;//最大、最小下标有变化时，中间下标也要随之变化
        }

对数组进行二分查找后，输出就可以了。

整体代码：

public class Task_010104_002_04 {

    public static void main(String[] args) {
        int[] nums = {1,3,9,5,6,7,15,4,8};  //初始数组
        int target = 6;                     //要查找的元素
        System.out.println("排序前：");
        arrayOut(nums);                     //输出排序前的数组
        int[] sort = bubbleSort(nums);      //把初始数组传进冒泡排序函数，对数组进行冒泡排序
        int index = binarySearch(sort,target);//把排序后的数组和目标值传进二分查找函数，得到下标
        System.out.println("排序后：");
        arrayOut(sort);                       //输出排序后的数组
        System.out.println("元素 "+target+" 排序后的下标为："+ index);//输出下标
    }

    //------冒泡排序--------
    public static int[] bubbleSort(int[] arr){
        int temp;                      //设数组的第一个数为临时变量
        boolean flag;                  //用于判断是有数据进行交换
        for (int i=1; i<arr.length-1; i++){     //对数组进行两轮迭代比较
            flag = false;                       //每次迭代时都把flag置为false
            for (int j=0; j<arr.length-i;j++){  //
                if (arr[j]>arr[j+1]){           //如果数组的第一个比第二个大
                    temp = arr[j];              //就先把第一个放到临时数
                    arr[j] = arr[j+1];          //然后把第二个放到第一个
                    arr[j+1] = temp;            //最后把临时数也就是之前的第一个数放到第二个
                    flag = true;                //如果有数据交换就把flag置为true
                }
            }
            if (!flag) {          //如果没有发生交换那么这一轮就中断
                break;
            }
        }
        return arr;                             //返回排序好的数组
    }

    //------二分查找--------
    public static int binarySearch(int[] arr, int tar){
        int minIndex = 0;                           //最小下标
        int maxIndex = arr.length - 1;              //最大下标
        int centerIndex = (minIndex + maxIndex) / 2;//中间下标
        while(true){
            if (tar > arr[centerIndex]){            //如果目标值大于数组中间下标的值
                minIndex = centerIndex + 1;         //就把最小下标移动到中间下标的右边，也就是加一
            }else if (tar < arr[centerIndex]){      //如果目标值小于数组中间下标的值
                maxIndex = centerIndex - 1;        //就把最大下标移动到中间下标的左边，也就是减一
            }else{                                  //如果相等了，也就是找到目标值
                break;                              //那么就中断while循环
            }
            if (minIndex > maxIndex){               //如果最小下标在最大下标的右边
                System.out.println("没有这个数据！");  //说明没有这个数据
                break;
            }
            centerIndex = (minIndex + maxIndex) / 2;//最大、最小下标有变化时，中间下标也要随之变化
        }
        return centerIndex;                         //返回中间下标
    }

    //------数组输出--------
    public static void arrayOut(int[] arr){
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");//对数组进行迭代输出
        }
        System.out.println();//换行
    }
}

运行截图：