20220715 十组 袁清清 学习笔记

Java学习序列3

今日学习重点

• 线性查找
• 二分法查找
• 冒泡排序
• 选择排序
• 插入排序
• 数组的反转
• 数组的扩容

线性查找

在常规无序数组中，设数组项个数为N，则一个数组项平均查找长度为N/2。极端情况下，查找数据项在数组最后，则需要N步才能找到。

今日实例

public class Ch01 {

public static void main(String[] args) {

    /*
        找出一个数在数组中的位置
        在数组中是否存在，如果存在，返回下标，如果不存在，返回-1

        如果找到了，则把下标i保存起来，显示的你要找的数是xxx，在目标数组中的下标是xxx
        如果没找到，则显示你要找的数是xxx，在目标数组中是不存在的。
     */
    int [] arr = new int[]{1,58,46,33,10,5,-8};
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个数：");
    int num = sc.nextInt();
    int index = -1;
    for (int i = 0;i < arr.length; i++) {
        if(arr[i] == num) {
            index = i;
            break;
        }
    }
    if(index != -1) {
        System.out.println("你要找的数是：" + num + "，在目标数组中的下标是：" + index);
    }else {
        System.out.println("你要找的数是：" + num + "，在目标数组中不存在");
    }
}

}

二分查找

前提是查找的数组为有序数组。相对于线性查找，待查数组项查找范围越大，体现的查找效率就更为显著。

例如，在1~100中找33

步数	切点数	可能值的范围
1	50	1~49
2	25	26~49
3	37	26~36
4	31	32~36
5	34	32~33
6	32	33~33
7	33	正确

今日实例

public class Ch02 {

public static void main(String[] args) {
    int [] arr = new int[]{1,2,3,4,5,6,7};
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入要查找的数字：");
    int target = sc.nextInt();

    // 最左边的下标
    int left = 0;
    // 最右边的下标
    int right =  arr.length - 1;
    if(target < arr[left] || target > arr[right]){
        System.out.println(target + "在目标数组中不存在！");
    }else {
        // 用来保存找到的下标的值
        int res = -1;
        while(left <= right) {
            // 找出中间的下标
            int middle = (left + right) / 2;
            if(arr[middle] == target) {
                // 中间的数恰巧就是我们要找的数
                res = middle;
                break;
            }else if(arr[middle] > target){
                // 说明我们要找的数在数组的前半区
                /*
                    如果在前半区
                    维护left和right
                    left是不需要动的
                    right应该移位到中间位置
                 */
                right = middle - 1;
            }else {
                // 条件实际上就是arr[middle]<target
                /*
                    说明在后半区
                    right是不需要动的
                    left应该向右移位到中间位置
                 */
                left = middle + 1;
            }
        }
        System.out.println(target + "在目标数组中的下标是：" + res);
    }
}

}

冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。



今日实例

public class Ch03 {

public static void main(String[] args) {
    int [] arr = new int[]{1,58,460,-33,10,5,-8};
    /*
        1和58 58和46 58和33 58和10 58和5 58和-8
        1 46 33 10 5 -8 58

        1和46 46和33 46和10 46和5 46和-8
        1 33 10 5 -8 46 58

        1和33 33和10 33和5 33和-8
        1 10 5 -8 33 46 58

        1和10 10和5 10和-8
        1 5 -8 10 33 46 58

        1和5 5和-8
        1 -8 5 10 33 46 58
        1和-8
        -8 1 5 10 33 46 58
     */
    // 从小到大
    /*
        冒泡排序思路分析：
        1.我先拿第一个数和后面的数一一比较大小
     */
    /*
        冒泡排序需要两层循环嵌套：for
        外层for循环控制的是需要各个数之间比较几轮
        内层的for循环控制的是每个数的真正的比较
     */
    for (int i = 0; i < arr.length - 1; i++) {
        //已经控制好了比较的次数
        // 比较的次数 = 数组的长度 - 1
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if(arr[j] < arr[j+1]){
                // 如果前面的比后面的大，换位
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.print("第" + (i + 1) + "轮的比较结果是：");
        for (int i1 : arr) {
            System.out.print(i1 + "、");
        }
        System.out.println();
    }

}

}

选择排序

算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。



今日实例

public class Ch01 {

public static void main(String[] args) {
    /*
        第一轮
            i=0,minIndex=0，里层的for循环int j = 1;j < 7;
            if(arr[0] > arr[1]){}。由于if不满足，则继续下一次的比较。
            j = 2,if(arr[0] > arr[2]){}。由于if不满足，则继续下一次的比较。
            j = 3,if(arr[0] > arr[3]){}。由于if不满足，则继续下一次的比较。
            j = 4,if(arr[0] > arr[4]){}。由于if不满足，则继续下一次的比较。
            j = 5,if(arr[0] > arr[5]){}。由于if满足条件，执行了minIndex = 5.
            j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
            j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
            到此为止，里层的for循环执行完毕。minIndex = 5。执行的
            int temp = arr[5];
            arr[5] = arr[0];
            arr[0] = temp;
            i=0的这次外层循环执行完毕。
            数组变成了-8、25、48、12、10、1、127、56
         第二轮
            i=1,minIndex = 1,
            j = 2,if(arr[1] > arr[2]){}。由于if不满足，则继续下一次的比较。
            j = 3,if(arr[0] > arr[3]){}。由于if满足，minIndex = 3;
            j = 4,if(arr[3] > arr[4]){}。由于if满足，minIndex = 4;
            j = 5,if(arr[4] > arr[5]){}。由于if满足，minIndex = 5;
            j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
            j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
            到此为止，里层的for循环执行完毕。minIndex = 5。执行的
            int temp = arr[5];
            arr[5] = arr[1];
            arr[1] = temp;
            数组变成了-8、1、48、12、10、25、127、56
         第三轮
            i=2;
     */
    int [] arr = new int[]{1,25,48,12,10,-8,127,56};
    for (int i = 0; i < arr.length; i++) {
        // 假设最小数的下标
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if(arr[minIndex]>arr[j]){ // 找到了最小值
                minIndex = j; //保存最小值的下标
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
        System.out.print("第" + (i+1) + "次比较结果是：");
        for (int i1 : arr) {
            System.out.print(i1 + "、");
        }
        System.out.println();
    }
}

}

插入排序

算法步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）



今日实例

public class Ch02 {

public static void main(String[] args) {
    /*
        第一轮：
            i=0,current=arr[1],int preIndex=0,
            while(0 >= 0 && 25 < arr[0]){}不成立，while循环不启动
            arr[0+1] = arr[0+1]
        第二轮：
            i=1,current=arr[2]=48,int preIndex=1
            while(1 >= 0&&48<25){}不成立，while循环不启动
            arr[1+1] = arr[1+1]
        第三轮：
            i=2,current=arr[3]=12,int preIndex=2
            while(2 >=0 && 12 < 48){
                arr[3] = arr[2]
                2--;
            }
            preIndex=1;
            while(1 >=0 && 12 < 25){
                arr[2] = arr[1];
                1--;
            }
            preIndex = 0;
            while(0 >=0 && 12 < 1){}不成立，while完事
            arr[1] = 12;
            1,12,25,48,10,-8,127,56
         第四轮：
            i=3,current = arr[4] = 10,int preIndex = 3,
            while(3>=0 && 10 < 48){
                arr[4] = arr[3];
                1,12,25,48,48,-8,127,56
                3--;
            }
            preIndex = 2;
            while(2>=0 && 10 < 25){
                arr[3] = arr[2];
                1,12,25,25,48,-8,127,56
                2--;
            }
            preIndex = 1;
            while(1>=0&& 10 < 12){
                arr[2] = arr[1];
                1,12,12,25,48,-8,127,56
                1--;
            }
            preIndex = 0;
            while(0>=0&&10 < 1){}不成立，while完事
            arr[1] = current = 10;
            1,10,12,25,48,-8,127,56
     */
    int [] arr = new int[]{1,25,48,12,10,-8,127,56};
    // 定义参照物
    int current;
    for (int i = 0; i < arr.length - 1; i++) {
        current = arr[i + 1];
        // 定义上一个元素的下标
        int preIndex = i;
        // 当上一个数的下标有效不能小于0
        // 并且还要保证当前的数比他上一个数小，
        // 这时候，才能让当前数向前移位
        while(preIndex >= 0 && current < arr[preIndex]){
            // 移位
            // 前面的数后移一位
            arr[preIndex + 1] = arr[preIndex];
            //
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    for (int i : arr) {
        System.out.print(i + "、");
    }
}

}

数组

数组的反转

今日实例

方法1

import java.util.Arrays;
public class Ch03 {

public static void main(String[] args) {
    int [] arr = new int[]{1,25,48,12,10,-8,127,56};
    for (int i = arr.length - 1; i >= 0 ; i--) {
        System.out.println(arr[i]);
    }
    /*
        思路1：
            创建一个等长的数组
            把当前数组的每一个元素倒着添加到新数组里
            新数组赋值给老数组
            int [] newArr = new int[arr.lenth];
     */
    int [] newArr = new int[arr.length];
    for (int i = arr.length - 1; i >= 0 ; i--) {
        newArr[i] = arr[arr.length - 1 - i];
    }
    // 新数组赋值给老数组
    arr = newArr;
    for (int i : arr) {
        System.out.println(i);
    }

方法2

import java.util.Arrays;
public class Ch03 {

public static void main(String[] args) {/*
        思路2：
        利用交换的方式
     */
    int [] arr = new int[]{1,25,48,12,10,-8,127,56};
    for (int i = 0; i < arr.length / 2; i++) {
        // temp存储的时最后一位
        int temp = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = arr[i];
        arr[i] = temp;
    }
    for (int i : arr) {
        System.out.println(i);
    }
    Arrays是操作数组的一个工具类
    System.out.println(Arrays.toString(arr));
}

}

数组的扩容

今日实例

import java.util.Arrays;
public class Ch04 {

public static void main(String[] args) {
    int [] nums = new int[]{3,4,6};
    // 定义一个新的临时数组
    int [] temp = new int[6];
    for (int i = 0; i < nums.length; i++) {
        temp[i] = nums[i];
    }
    nums = temp;
    System.out.println(Arrays.toString(nums));
}

今天总结

今天学习了数据结构的几种排序算法，感觉比较难理解代码，算法的排序原理还是比较好理解的，代码的设计需要考虑的点有点多，感觉只能勉强跟上老师的讲解，老师真的讲的特别细致，步骤写得很清楚，晚上还得好好去看看回放，加强理解才行。今天的作业感觉结合的知识点有点多，自己写起来有点困难。