有序数组的二分查找、冒泡排序案例、简单递归案例、快速排序的两种实现方法、Arrays操作数组的常用方法

最新推荐文章于 2023-09-21 15:44:20 发布

原创最新推荐文章于 2023-09-21 15:44:20 发布 · 379 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#快速排序 #java

基础专栏收录该内容

56 篇文章

订阅专栏

1. 有序数组的二分查找

二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率

案例：在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素返回其索引：

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int number = 3;
        //返回number所在索引，若没有返回-1
        int index = searchIndexByNumber(arr, number);
        System.out.println(index);
    }

    private static int searchIndexByNumber(int[] arr, int number) {
        //定义查找范围
        int min = 0;
        int max = arr.length-1;
        while(min <= max){
            //计算出中间位置mid，使用位运算符
            int mid = (min+max) >> 1;
            if (arr[mid] > number){
                //元素在mid左边
                max = mid - 1;
            }else if (arr[mid] < number){
                //元素在mid右边
                min = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
}

2. 数组的冒泡排序

冒泡排序特点：

如果有n个数据进行排序，总共需要比较n-1趟（遍历n-1次数组）
每比较一趟就将最小的数交换到最终位置，所以下一次趟的比较就会少一个数据参与

冒泡排序案例（升序）：

public class Test {
    public static void main(String[] args) {
        int[] arr = {4,5,1,2,6,3};
        bubbleSort(arr);//冒泡排序
        printArr(arr);//打印排序后的数组
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    private static void bubbleSort(int[] arr) {
        int n = arr.length - 1;
        //比较arr.length - 1趟
        for (int i = 0; i < n; i++) {
            boolean flag = false;//表示本趟排序是否发生交换
            for (int j =n; j > i; j-- ){//重最后一个元素开始判断与相邻元素大小
                if (arr[j] < arr[j-1]){//如果前面一个元素大于后面一个则交换位置
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                return;//本趟遍历若没有发生交换则证明数组已经有序了
            }
        }
    }
}

3. 递归

递归介绍：

以编程的角度来看，递归指的是方法定义中调用方法本身的现象
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归的注意事项：递归一定要有出口，否则会导致栈内存溢出

递归求阶乘和累加：

public class Test01 {
    public static void main(String[] args) {
        int jc = jcSum(5);
        int sum = getSum(100);
        System.out.println(jc);
        System.out.println(sum);
    }
    //阶乘
    private static int jcSum(int i) {
        if (i == 1){
            return 1;//出口
        }
        return i * jcSum(i-1);
    }
    //累加
    private static int getSum(int i) {
        if (i == 1){
            return 1;//出口
        }
        return i + getSum(i-1);
    }
}

4. 快速排序

快速排序概述：快速排序算法中,每一次递归时以第一个数为基准数，找到数组中所有比基准数小的，再找到所有比基准数大的，小的全部放左边，大的全部放右边，确定基准数的正确位置

方法一：（严蔚敏《数据结构》的划分方法）

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {4,5,1,2,6,3};
        int low = 0;
        int high = arr.length-1;
        quickSort(arr, low, high);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        if(low < high){//递归跳出条件
            //partition()就是划分操作，将arr划分为两个满足条件的子表
            int pivotpos =  partition(arr, low, high);
            quickSort(arr, low, pivotpos-1);
            quickSort(arr, pivotpos+1, high);
        }
    }

    public static int partition(int[] arr, int low, int high){
        //将数组第一个元素作为枢轴值
        int pivot = arr[low];
        while(low < high){//当low=high时跳出循环，找枢轴值到位置
            while (low < high && arr[high] >= pivot){
                high--;//循环找到比枢轴值小的数所在位置
            }
            arr[low] = arr[high];//将比枢轴值小的数移动到左端
            while(low < high && arr[low] <= pivot){
                low++;//循环找到比枢轴值大的数所在位置
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;//将枢轴值放到他的最终位置
        return low;//返回存放枢轴值的位置
    }
}

方法二：

//        1，从右开始找比基准数小的
//        2，从左开始找比基准数大的
//        3，交换两个值的位置
//        4，继续往左找，继续往右找，直到两个箭头指向同一个索引为止
//        5，基准数归位
public class Test02 {
    public static void main(String[] args) {
        int[] arr = {5,3,2,4,6,1};
        int left = 0;
        int right = arr.length-1;
        quickSort(arr, left, right);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void quickSort(int[] arr, int left, int right) {
        //当本应该在右边开始找的位置跑到了左边的时候就可以结束
        if(left > right){
            return;
        }
        //将数组第一个元素作为基准元素
        int baseNumber = arr[left];
        //记录范围的值，因为你在找的过程中，left和right都会改变。但是最后使用递归的时候，这个范围的值还得用
        int left0 = left;
        int right0 = right;
        while(left != right){//left==right时找到基准位置
            while(left < right && arr[right] >= baseNumber){
                right--;
            }
            while(left < right && arr[left] <= baseNumber){
                left++;
            }
            //两个要交换的数字都找到了，开始交换
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位,将基准数放到他最终的位置
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;
        //递归调用自己,将左半部分排好序
        quickSort(arr, left0, left-1);
        //递归调用自己,将右半部分排好序
        quickSort(arr, left+1, right0);
    }
}

5. API——Arrays

Arrays无构造方法，内部方法都为静态方法，用类名调用

该类包含用于操作数组的各种方法（例如排序和搜索）

Arrays的常用方法：

public static String toString(int[] a) 返回指定数组的内容的字符串表示形式
public static void sort(int[] a) 将传入数组升序排列
public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引（数组必须有序）

案例练习：

/*1. 定义一个String数组  String[] strArr={"100","20","30","15","55"};
        2. 定义一个int数组，长度和前面一个数组一样
        3. 使用Arrays的方法对int数组的元素排序
        4. 使用Arrays的方法把int数组转换为字符串，并打印
        5. 使用Arrays的方法查找int数组中20元素的索引，并打印*/
public class Exercise01 {
            public static void main(String[] args) {
                String[] strArr = {"100", "20", "30", "15", "55"};
                //定义一个int数组，长度和前面一个数组一样
                int[] numArr = new int[strArr.length];
                for (int i = 0; i < strArr.length; i++) {
                    numArr[i] = Integer.parseInt(strArr[i]);
                }
                //使用Arrays的方法对int数组的元素排序
                Arrays.sort(numArr);
                //使用Arrays的方法把int数组转换为字符串，并打印
                System.out.println(Arrays.toString(numArr));
                //使用Arrays的方法查找int数组中20元素的索引，并打印。此时数组中元素已经有顺序了
                int index = Arrays.binarySearch(numArr, 20);
                System.out.println(index);
            }
}

如有错误欢迎留言评论，及时更正。 5月27日羽露风