2022-7-15 第三小组 甘源册 学习笔记

目录

• 知识点掌握情况
• 学习心情（心路历程）
• 1.算法
  • 1.1查找算法
    • 1.1.1线性算法
    • 1.1.2二分法查找
  • 1.2排序算法
    • 1.2.1冒泡排序
    • 1.2.2插入排序
    • 1.2.3选择排序
• 2.数据结构
• 3.数组
  • 3.1数组反转
  • 3.2数组的扩容

知识点掌握情况

查找算法（理解） 冒泡排序（理解） 插入排序（了解） 选择排序（理解）

学习心情（心路历程）

今天讲了算法，其中插入算法属实是让我的发际线上升了许多。哎！

1.算法

1.1查找算法

1.1.1线性算法

• 从头到尾一个一个查询

• 优点：简单，便于理解

• 缺点：效率极低

• 例子

  •  int[] arr = new int[]{13, 13, 14131, 12, 31};
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个数");
            int anInt = scanner.nextInt();
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == anInt) {
                    System.out.println("数是" + arr[i] + "下标:" + i);
                    continue;
                }
                return;
            }
            System.out.println(anInt + "在数组中不存在");
    

1.1.2二分法查找

• 不断拆分，取半判断，减小查询量（适用于有规律的查询）

• 例子

  • int[] ints = new int[]{12,13,14,15,22,33};
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入要查找的数");
            int anInt = scanner.nextInt();
    
            int letf=0;
            int right=ints.length-1;
            if (anInt <ints[letf]||anInt>ints[right]){
                System.out.println("数组里不存在这个数"+anInt);
            }else {
                //保存找到下标的值
                int res=-1;
                while (letf<=right){
                    int mid=(letf+right)/2;
                    if (anInt>ints[mid]){
                        letf=mid+1;
                    }else if (anInt<ints[mid]){
                        right=mid-1;
                    }else {
    //                    right=letf-1;
                        res=mid;
                        break;
                    }
                }
                System.out.println(res);
            }
    

1.2排序算法

1. 冒泡排序
2. 快速排序
3. 插入排序
4. 选择排序
5. 希尔排序
6. 堆排序
7. 归并排序
8. 计数排序

1.2.1冒泡排序

• 流程图

  • 

• 思路分析：

  1. 先拿第一个数和后面的数一一比较大小
  2. 比较完后根据条件判断是否进行换位置
  3. 以此类推

• 代码实现

  •         int[] arr = new int[]{13,412,321,21114,124,12,134};
            // 冒泡排序两层循环嵌套
            // 外层for循环控制的是每个数之间需要比较几轮
            // 里层的for循环控制的是每个数的真正比较
            for (int i = 0; i < arr.length - 1; i++) {
                //外层比较的次数是长度-1
                for (int i1 = 0; i1 < arr.length-1-i; i1++) {
                    if (arr[i1]>arr[i1+1]){
                        int a=0;
                        a=arr[i1];
                        arr[i1]=arr[i1+1];
                        arr[i1+1]=a;
                    }
                }
                System.out.print("第"+(i+1)+":");
                for (int i1 : arr) {
                    System.out.print(i1+" ");
                }
                System.out.println();
    
            }
            System.out.print("arr={");
            for (int arr1:arr) {
                System.out.print(arr1+" ");
            }
            System.out.println("}");
    

1.2.2插入排序

• 流程图

  • 

• 思路分析

  1. 从第一个元素开始，假设该元素已经被排过序了
  2. 取出下一个元素，在已经排序的元素的序列中向前扫描
  3. 如果该元素（已排序)大于后面的元素，将该元素移到下一个位置i
  4. 将新元素插入到原来的位置
  5. 以此类推

• 代码实现

  •  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;
                System.out.print("第"+(i+1)+"轮:");
                for (int i1 : arr) {
                    System.out.print(i1+",");
                }
                System.out.println();
            }
    

1.2.3选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完

• 流程图

  • 

• 代码实现

  •     private static void test5(int[] arr) {      
    		for (int i = 0; i < arr.length-1; i++) {
                for (int i1 = i; i1 < arr.length-1; i1++) {
                    if (arr[i]  > arr[i1+1]){
                        int a=0;
                        a=arr[i1+1];
                        arr[i1+1]=arr[i];
                        arr[i]=a;
                    }
                }
                System.out.print("第"+(i+1)+"次比较结果");
                for (int i1 : arr) {
                    System.out.print(i1+".");
                }
                System.out.println();
            }
        }
    

2.数据结构

1. 数据结构:

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

   2. 链表

      1. 示意图
      2. 

   3. 树

   4. 图

3.数组

3.1数组反转

1. 思路

   1. 创建一个等长的数组

   2. 把当前输入的每一个元素倒着添加到新数组里新数组赋值给老数组

   3. 代码

      • private static void test7(int[] arr) {
                int[] newArr=new int[arr.length];
                for (int i = 0; i < arr.length; i++) {
                    newArr[i]=arr[arr.length-1-i];
                }
                for (int i = 0; i < arr.length; i++) {
                    arr[i]=newArr[i];
                }
                for (int i : arr) {
                    System.out.print(i+",");
                }
            }
        

2. 思路

   1. 首尾互换

   2. 代码

      • private static void test8(int[] arr) {
                int[] newArr=new int[arr.length];
                int a=0;
                for (int i = 0; i < arr.length/2; i++) {
                    a=arr[i];
                    arr[i]=arr[arr.length-i-1];
                    arr[arr.length-i-1]=a;
        
                }
                for (int i : arr) {
                    System.out.print(i+",");
                }
            }
        

3.2数组的扩容

1. 定义一个新的临时数组

private static void test9(int[] arr) {
        int[] ints = new int[16];
        for (int i = 0; i < arr.length-1; i++) {
            ints[i]=arr[i];
        }
        arr=ints;
        System.out.println(arr.length);
        for (int anInt : ints) {
            System.out.print(anInt+",");
        }
    }