Java--冒泡、选择排序，二分查找-蒲公英云

Java--冒泡、选择排序，二分查找

一、冒泡排序，选择排序，二分查找

package com.cat.stringbuffer;
public class BubbleSort {
    public static void main(String[] args) {
        //排序
        int[] array = {33,11,22,55,44};
        bubbleSort(array);//冒泡排序
        selectSort(array);//选择排序
        //二分查找
        int[] arr = {11,22,33,44,55,66,77,88};
        int i = binarySearch(arr,44);//二分查找
        System.out.print("二分查找索引：" + i);
    }
    //二分查找
    private static int binarySearch(int[] arr,int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        while (arr[mid] != value) {
            if(arr[mid] < value){         //中间值 < 指定要找值，最小索引 min = mid + 1
                min = mid + 1;
            }else if(arr[mid] > value){   //中间值 > 指定要找值，最大索引 max  = mid - 1
                max = mid - 1;
            }
            mid = (min + max) / 2;
            if(min > max){
                return -1;
            }
        }
        return mid;
    }
    //选择排序
    public static void selectSort(int[] array) {
        /*
         * 选择排序 
         *     用一个索引位置上的元素，依次和其他索引位置上的元素比较，小的在前，打的在后
         * 第一次：array[0]分别与array[1-4]比较4次
         * 第二次：array[1]分别与array[2-4]比较3次
         * 第三次：array[2]分别与array[3-4]比较2次
         * 第四次：array[3]与array[4]比较1次
         * */
        System.out.println();
        for (int i = 0; i < array.length - 1; i++) {  //外循环需要比较array.length - 1次
            for (int j = i+1 ; j < array.length; j++) {  
                if (array[i] > array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println("选择排序：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
    //冒泡排序
    public static void bubbleSort(int[] array) {
        /*
         * 冒泡排序 
         *     轻的上浮，沉的下降
         *     两个相邻位置比较，如果前面的元素比后面的大就换位置
         * 第一次：array[0]与array[1],array[1]与array[2],array[2]与array[3],array[3]与array[4]比较4次
         * 第二次：array[0]与array[1],array[1]与array[2],array[2]与array[3]比较3次
         * 第三次：array[0]与array[1],array[1]与array[2]比较2次
         * 第四次：array[0]与array[1]比较1次
         * */
        for (int i = 0; i < array.length - 1; i++) {  //外循环需要比较array.length - 1次
            for (int j = 0; j < array.length - 1 - i; j++) {  //-1防止数组越界，提高效率
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println("冒泡排序：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

Center

冒泡排序原理：

Center 1

选择排序原理：

Center 2

二分查找原理：

Center 3

二、Java中有提供了一个Arrays类，JDK文档下解释如下：此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

1、Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。

2、成员方法
[1]public static String toString(int[] a)
[2]public static void sort(int[] a)
[3]public static int binarySearch(int[] a,int key)

package com.cat.stringbuffer;
import java.util.Arrays;
public class ArraysDemo {
    public static void main(String[] args) {
        /*Arrays类的概述和方法使用)
          1、Arrays类概述
             针对数组进行操作的工具类。
             提供了排序，查找等功能。
          2、成员方法
                [1]public static String toString(int[] a)
                [2]public static void sort(int[] a)
                [3]public static int binarySearch(int[] a,int key)
         * */
        //数组转字符串
        int[] array = {33,11,22,55,44};
        System.out.println("数组转字符串：" + Arrays.toString(array));
        //排序
        Arrays.sort(array);
        System.out.println("排序：" + Arrays.toString(array));
        //二分查找
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println("二分查找：" + Arrays.binarySearch(arr, 44));
        System.out.println("二分查找：" + Arrays.binarySearch(arr, 99));  //-插入点 - 1
    }
}