20220715 第二组 刘世琦 学习记录

JAVA

（今日知识）

1. 数据结构（掌握）

2. 查找算法

• 2.1 线性查找（掌握）

• 2.2 二分法查找（理解）

3. 排序算法

• 3.1 冒泡排序（掌握）

• 3.2 选择排序（理解）

• 3.3 插入排序（掌握）

4. 数组（掌握）

• 4.1 数组的反转
• 4.2 数组的扩容

总结

1. 数据结构

数据结构：

1.数组是最基本的数据结构，是一张表，线性表（数据元素之间是一对一的关系， 除了第一个和最后一个之外，其余的元素都是首尾连接）
2.链表
3、树
4、图

2. 查找算法

• 2.1 线性查找

线性查找：简单，便于理解。

例：
找出一个数在数组中的位置
在数组中是否存在，如果存在，返回下标，如果不存在，返回-1
如果找到了，则把下标i保存起来，显示的你要找的数是xxx，在目标数组中的下标是xxx
如果没找到，则显示你要找的数是xxx，在目标数组中是不存在的。

写程序的思路分享：
 1.先完成需求要求的功能
 2.根据程序运行的结果进行优化处理
 3.代码重构
 4.提升效率

public class Ch01 {

    public static void main(String[] args) {
        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 + "，在目标数组中不存在");
        }
    }
}

• 2.2 二分法查找
  

/**
 * 查找算法：
 * 二分法查找。
 *
 * 如果要使用二分法查找找数字，前提是这个数组必须有顺序
 */
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;
//                    left = arr.length;
                    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);
        }
    }
}

3. 排序算法

3.1 冒泡排序

冒泡排序的算法：

1、从第一个数开始，比较相邻的元素，如果前一个比后一个大，就把它们交换位置
2、对每一对相邻元素作相同的操作，从开始的一对到结束的一对，最后的元素就是最大的数
3、针对所有的元素作相同的工作，除了最后一个
4、持续每次对越来越少的元素进行如上操作，直到没有一对数字需要比较

例如这样一组数据：[18, 16, 12, 23, 48, 24, 2, 32, 6, 1]

下面通过具体代码来实现：

public class Ch01 {

    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();
        }

    }
}

3.2 选择排序

选择排序的思路：从0下标开始，设此处元素下标为i， 找到i后面比它的小元素的下标，然后将小元素与i处的元素交换，这样数组就会呈升序排列，如果要降序就找大值交换就可以了。简单说，就是找到最小元素将它排在最前面， 然后继续选择出此元素的最小值排在该元素后面，这样遍历完数组后，数组也变得有序了。
以[18, 16, 12, 23, 48, 24, 2, 32, 6, 1]为例。

下面通过具体代码来实现：

 /**
 * 选择排序
 */
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();
        }
    }
}

3.3 插入排序

图示：

下面通过具体代码来实现：

/**
 * 插入排序
 */
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 + "、");
        }
    }
}

4. 数组

4.1 数组的反转

思路1：

            创建一个等长的数组
            把当前数组的每一个元素倒着添加到新数组里
            新数组赋值给老数组
            int [] newArr = new int[arr.lenth];

public class Ch01 {

    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]);
        }
       
        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：

        利用交换的方式

public class Ch03 {

    public static void main(String[] args) { 
        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));
    }
}

4.2 数组的扩容

思路：建立一个长度大的临时数组，将原数组的值赋给临时数组，再将临时数组赋值给原数组实现扩容

public class Ch01 {

    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));
    }
}

总结：

今天学习的查找和排序算法让我重新记起以前学过的知识，但是将整体思路转化为代码来实现，这使得我理解起来有些无从下手，所以在课后我又重新将思路完整清晰的写下来，理清楚，一步一步去思考每一步应该如何实现。同时，通过今天晚上的作业我发现自己在写之前缺少思维框架，将各个功能分块实现后无法将这些功能串联起来，出现能理解但不会用的问题，这是我的薄弱部分，我会继续在以后的学习中在认真学习的同时，复习已经学过的知识，努力的提升自己，每一天都在进步！