排序方法的介绍（冒泡，插入，选择，快速）以及实现二分搜索

排序方法的介绍

冒泡排序

冒泡原理：通过对每一对相邻数据的比较与两个值的交换实现数组的有序（对于数组的操作）
代码的实现

import java.util.Arrays;

public class Text2 {


    public static void main(String[] args) {
        int[] arr = {12, 134, 123, 6, 78, 32, -1};


        int c = 0;
        for (int j = 0; j < arr.length - 1; j++) {

            for (int i = 0; i < arr.length - 1 - j; i++) {  //控制两两比较的次数当每完成需要比较的数字就少一个，比较次数也就减小了
                if (arr[i] > arr[i + 1]) {   //实现大值往后放（每一轮结束大值都依次排列）
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }

            }
        
        System.out.println(Arrays.toString(arr));///利用Arrays.tostring可以直接打印，也可已再次遍历数组输出

    }
}

插入排序

实现原理：插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

代码实现：

import java.util.Arrays;

public class Text2 {


    public static void main(String[] args) {
        int[] arr = {12, 134, 123, 6, 78, 32, -1};

        for (int i =1; i < arr.length; i++) {  //直接从索引 1 处进行比较

            int j=i;
            while (j>0&&arr[j]<arr[j-1]){  //通过与之前的数比较实现交换类似实现将小的插到前边
                int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;
                j--; //实现当索引大于1的数据插入
            }
        }
        System.out.println(Arrays.toString(arr));*/

    }
}

选择排序

实现原理：它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

代码实现

import java.util.Arrays;

public class Text2 {

    public static void main(String[] args) {
        int[] arr = {12, 134, 123, 6, 78, 32, -1};
 for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i]) {
                    int c = arr[i];
                    arr[i] = arr[j];
                    arr[j] = c;
                }

            }
                  System.out.println(Arrays.toString(arr));
        }
      

快速排序

实现原理：
）设置两个变量i、j，排序开始的时候：i=0，j=N-1（一个为开始索引一个为结束索引）；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

代码实现：

public class QuickSort {
    //start 默认是0
    //end 是数组长度-1
    public void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //获取分区索引
            int index = getIndex(arr, start, end);
            //对左右两个分区 再进行同样的步骤 ，即是递归调用
            quickSort(arr, start, index - 1);//左半部分
            quickSort(arr, index + 1, end);//右半部分
        }
    }

    private int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        //循环
        while (i < j) {
            //从右往左比较
            while (i < j && arr[j] >= x) {
                j--;
            }
            //从右往左找到比基准数小的数了后，填坑
            if (i < j) {
                //把这个数填到上一个坑位
                arr[i] = arr[j];
                //让 i++;
                i++;

            }

            //从左往右找
            while (i < j && arr[i] < x) {
                i++;
            }
            // 找比基准数大的数，找到后填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分
        arr[i] = x; //把基准数填进去
        return i; //返回基准数所在位置的索引
    }

}

二分搜索的实现

实现原理：二分查找的基本是数组有序，设置三个变量分别表示开头，中间，末尾的索引值，输入需要找寻的值（i），用i与数组中中间索引进行判断，相等返回索引，i>中间索引所指向的值则（头部索引=上一轮的中间索引+1）；i<中间索引所指向的值则（尾部索引=上一轮的中间索引-1）重复此操作知道找到此元素

代码实现：

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

public class Text2 {


    public static void main(String[] args) {
        int[] arr = {12, 134, 123, 6, 78, 32, -1};
        Arrays.sort(arr);       //调用Array.sort();对数组排序
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        int head = 0;
        int last = arr.length - 1;
        int index = (head + last) / 2;
        while (head <= last)
            if (i < arr[index]) {
                last = index - 1;
                index = (head + last) / 2;
            } else if (i > arr[index]) {
                head = index + 1;
                index = (head + last) / 2;
            } else if (i == arr[index]) {
                System.out.println(index);
                break;


            } else {
                System.out.println("不存在这个数");
            }


    }
}