排序（二分法查找、冒泡排序、选择排序、插入排序以及快速排序）

二分法查找

• 二分查找也称为折半查找，它是一种效率较高的查找方法。
• 首先，假设表中元素是按照升序排列，将表中间位置记录的关键字与查找关键字比较，，如果两者相等，则查找成功，得出答案，否则利用中间位置记录的关键字将表分成前后两个子表，如果中间位置记录的关键字大于查找关键字，则在前一个字表中查找，否则，在后一个子表中查找，重复操作，找到符合记录，则成功，或者查到子表不存在为止，查找失败
• 它的思路是将数组分成前后元素差不多相等两个部分，即arr[左]和arr[右]，取arr[n/2]与查找关键字x比较，相等则停止，如果arr[n/2]>x,则在arr[左】里面查找，如果arr[n/2]<x,则在arr[右】里面查找

代码展示：

​
public class BinarySearch {
    public static void main(String[] args) {
        //二分法查找
        int[] arr={1,2,3,4,5,6,7,8,9};
        int i= Arrays.binarySearch(arr,2,7,6);
        System.out.println(i);
    }
    public static int binarySearch(int[] a,int formIndex,int toIndex,int key){
        int low=formIndex;//开始索引
        int high=toIndex-1;//最大索引
        while(low<=high){
            int mid=(low+high)>>>1;//中间值 除2
            int midval=a[mid];
            if(midval<key)
                low=mid+1;
            else if(midval>key)
                high=mid-1;
            else return mid;
        }
        return -(low+1);
    }

}

​

冒泡排序

• 它是一种计算机科学领域的较简单的排序算法。
• 它重复地走访过要排序的元素列，一次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来，走访元素的工作是重复进行，直到没有相邻元素需要交换。
• 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，如同碳酸饮料中二氧化碳的气泡浮到顶端一样，故名”冒泡排序“；
• 其主要代码表现就是前一个元素大于后一个元素时，将两个元素互换位置，然后进行下一组相邻元素，假设给a,b,c,d,e,已知a、b依次增大,c、d、e都比a、b大，但是c要比d、e都大，d要比e大，即c与d互换位置，c与e比较又互换位置，然后d与e比较，互换位置，得到最终答案a、b、e、d、c

代码展示：

public class Sort {
    public static void main(String[] args) {
        int array[]=new int[]{1,2,5,9,3};
        System.out.println("输入五个数字");
        for(int i=0;i<5;i++){
            System.out.println(array[i]);
        }
        BubbleSort(array,5);
        System.out.println("冒泡排序为：");
        for(int i=0;i<5;i++){
            System.out.println(array[i]);
        }
    }
   public static void BubbleSort(int array[],int size){
        for(int i=0;i<size-1;i++){
            for(int j=1;j<size-i;j++){
                if(array[j-1]>array[j]){
                    int temp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=temp;
                }
            }
        }
    }
}

public class Sort{  
 public static void main(String[] args) {
        //冒泡排序
        int[] arr={12,15,35,20,54,46,89,75};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));;

    }
    public static void sort(int[] arr){
        //外层循环
        for(int i=0;i<arr.length;i++){
            //内层循环
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[i]>arr[j+1]){
                    //不断交换位置，直至成功
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

选择排序

• 选择排序是一种简单直观的排序算法
• 它炫耀在未排序数列中找到最小（最大）元素，存放在排序数列的起始位置，然后，再从未排序数列中继续寻找最小（最大）元素，然后放在已排序的元素的后面，依次反复，直到所有元素排列完毕

代码演示

public class Sort {
    public static void main(String[] args) {
        int[] array = new int[]{1, 2, 5, 9, 3};
        System.out.println("输入五个数字");
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
        SelectionSort(array);
        System.out.println("选择排序为：");
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
    }
  public static void SelectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[min] > arr[j])
                    min = j;
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }
}

插入排序

• 插入排序，一般也别称之为直接插入排序，插入排序是一个最简单的排序方法
• 它的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表
• 它的意思就是先把数组中的第一个当作一个有序列，数组中剩下的全部为无序列，然后从无序列中拿出每次第一个数插入到有序列表中，（根据需求是升序还是降序），进行数的比较，比较完成，得到一个新的，记录数增1 的有序列表，重复操作，知道将无序列表中的元素全部插入到有序列表中来

代码演示

​public class Sort {
    public static void main(String[] args) {
        int[] array = new int[]{12, 15, 35, 20, 54, 46, 89, 75};

        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        InsertSort(array);
        System.out.println("插入排序为：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }


    public static void InsertSort(int[] arr) {
        int temp,j;
        for (int i = 1; i < arr.length; i++) {
            //这一步最重要，确立有序数列第一个
            if (arr[i] < arr[i - 1]) {
                temp = arr[i];
                //重新进行数列排序，每一次插入都是从前一个数开始
                for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                        arr[j + 1] = arr[j];
                    }
                    arr[j + 1] = temp;
                }
            }
        }
    }


​

快速排序 

• 快速排序是在一个无序的数列中选取一个任意的基准元素pivot,利用它将数组元素序列分成两部分前面部分元素均小于或等于基准元素，后面部分均大于或等于基准元素，然后采用递归的方法分别对前后两部分重复上述操作，直到无序变为有序数列
• 总之，首设分界值分数列为一左一右，左边的值小于或等于分界值，右边的值大于或等于分界值，然后再在一左一右中选择各选一个分界值，重复操作，使无序变有序