2022-07-15 第十小组 石晓荟

                                       算法！！！

学习心得：

2022年7月15日，已经不是第一次接触算法了，但还是云里雾里，虽然老师讲的是一些简单的算法，但对于我来说需要一些时间慢慢理解

今天讲了数据结构通过数据结构又引出了一些算法

知识总结：

一：数据结构：

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

2.链表

3、树

4、图
二：查找算法
1.线性查找：例子：找出一个数在数组中的位置需求：如果存在在这个数，就返回这个数的下标，如果不存在，就返回-1；
     如果找到了，就把这个数的下标存起来，显示你要找的数是***，在目标数组中的下标是***
     如果没找到，则显示你要找的数字是***，数组中不存在这个数
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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.二分法查找：

如果使用二分法查找一个数字，前提是数组必须有顺序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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);
        }

3.冒泡排序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int [] arr = new int[]{1,58,460,-33,10,5,-8};
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();
        }

4.选择排序

例子：给下列数组排序{1,25,48,12,10,-8,127,56}

第一轮
    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;
......
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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();
        }

5.插入排序

　

第一轮：
    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

　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 + "、");
        }

　　

　　

 
posted @   Romantic_SXH  阅读(20)  评论(0)  编辑  收藏  举报
相关博文：
·  2022-08-07 第十小组 石晓荟
·  2022-07-16 第十小组 石晓荟
·  2022-07-15 第三小组 赖哲栋 学习笔记
·  2022-07-15 第七小组姜珊 学习笔记
·  2022.07.15 第三小组 陈迪 学习笔记
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手