Java进阶：冒泡排序、选择排序、二分查找

冒泡排序

• 两两比较，左边>右边，进行交换，经过一轮交换,最大的在最后一个位置，下一次循环排除掉已确定位置的值

/* 
    初始值：9,3,2,7,6
    第一次冒泡：3,9,2,7,6
              3,2,9,7,6
              3,2,7,9,6
              3,2,7,6,9
    第二次冒泡：2,3,7,6
              2,3,7,6
              2,3,6,7
    第三次冒泡：2,3,6
              2,3,6
    第四次冒泡：2,3
    结果：2,3,6,7,9
*/
public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {9,3,2,7,6};
        int count = 0;  //比较次数
        int count1 = 0; //交换次数
        for (int i = array.length-1; i > 0; i--){   //4 3 2 1
            for (int j = 0; j < i; j++){            //01234 0123 012 01
                if (array[j] > array[j+1]){ //左边>右边，两两交换
                    int a;
                    a = array[j];
                    array[j] = array[j+1];
                    array[j+1] = a;

                    count1++;
                }
                count++;
            }
        }
        System.out.println("比较次数：" + count);    //10
        System.out.println("交换位置次数：" + count1); //6
        for (int i =0; i < array.length; i++){
            System.out.print(array[i]);
        }
    }
}

选择排序

• 数组中的最小值和数组中第一个值交换,下一次循环排除掉已确定位置的值

/*
    初始值：9,3,2,7,6
    第一次选择：2,9,3,7,6
    第二次选择：  3,9,7,6
    第三次选择：    6,9,7
    第四次选择：      7,9
    结果：2,3,6,7,9
*/
public class SelectSort {
    public static void main(String[] args) {
        int[] array = {9,3,2,7,6};
        int count = 0;  //比较次数
        int count1 = 0; //交换次数
        for (int i = 0; i < array.length-1; i++){      //0,1,2,3
            //System.out.println("i ==== "+i);
            int min = i;
            for (int j = i+1; j < array.length; j++){  //01234,1234,234,34
                //System.out.println("j ===== "+j);
                if (array[min] > array[j]) {
                    min = j;
                }
                count++;
            }
            if (min != i){  //如果最小值不是本组的第一个值，交换位置
                int a;
                a = array[i];
                array[i] = array[min];
                array[min] = a;

                count1++;
            }
        }
        System.out.println("比较次数：" + count);    //10
        System.out.println("交换位置次数：" + count1); //2
        for (int i =0; i < array.length; i++){
            System.out.print(array[i]);
        }
    }
}

二分查找（折半查找）

1. 二分查找建立在排序的基础之上
2. 效率高于遍历查找

public class ArrayUtil {
    public static void main(String[] args) {
        int[] array = {100,200,300,400,500,600};

        int index = binarySearch(array,200);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标为" + index);
    }

    public static int binarySearch(int[] array, int dest) {
        //开始下标
        int begin = 0;
        //结束下标
        int end = array.length - 1;

        while (begin <= end){   //开始元素下标在结束元素下标的左边，继续循环
            //中间元素下标
            int mid = (begin + end) / 2;
            if (array[mid] == dest){    //中间元素刚好等于查找的元素，返回该下标
                return mid;
            }else if (array[mid] > dest){   //查找的元素在中间元素的左边
                end = mid - 1;
            }else { //array[mid] < dest  查找元素在中间元素的右边
                begin = mid + 1;
            }
        }
        return -1;
    }
}

调用Arrays类中的方法，实现排序与查找

java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        int[] array = {9,3,2,7,6};
        //排序
        Arrays.sort(array);
        //输出
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");   //2 3 6 7 9
        }
        System.out.println();

        //二分法查找（建立在排序基础之上）
        int index = Arrays.binarySearch(array,6);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标为" + index);
    }
}