2022-07-15 第二小组 张鑫 学习笔记

### 实训第八天 简单算法

1.学习重点

1.数据结构

2.线性查找

3.二分法查找

4.冒泡排序

5.选择排序

6.插入排序

7.数组反转

8.数组扩容

2.学习心得

今天主要对基本算法进行了学习，老师讲的十分细致，五个算法我已经差不多都能理解了，但是还需要自己多练习，冒泡排序，线性查找，这些算法都是很常见的算法，今晚也是结合这几天所学的内容进行了代码的编写，知识学起来还能接受，自己做的话真的有些吃力，好多地方都不够严谨，还需要继续努力啊！

3.学习内容

数据结构：

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

写程序的思路分享

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

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

案例

找出一个数在数组中的位置
如果存在，返回下标，如果不存在，返回-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 ){
//                System.out.println("你要找的数是："+num+",在目标数组的下标是"+i);
                index = i ;
                break;
            }
//            else {
//                System.out.println("你要找的数是："+num+",在目标数组中不存在");
//            }

        }
        if(index != -1){
            System.out.println("你要找的数是："+num+",在目标数组的下标是"+index);
        }else {
            System.out.println("你要找的数是："+num+",在目标数组中不存在");
        }

二分法查找

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

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应该移动到中间位置
                     */
                    right = middle-1;
                }else{
                    //条件实际上就是arr[middle]<target
                    /*
                        在后半区
                        right不需要切，
                        left应该移动到中间位置
                     */
                    left = middle +1;
                }
                }
            System.out.println(target+"在目标数组中的下标是"+res);
            }

排序算法

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

冒泡排序

1.拿第一个数和后面的数一一比较大小（比较出最大值）
2.重复上一次操作...

冒泡排序需要两层循环嵌套：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();

        }

简便操作

int [] arr=new int[]{1,58,46,33,10,5,-8};
        //从小到大
        Arrays.sort(arr);
        for (int i : arr) {
            System.out.println(i);
        }

选择排序

代码

int [] arr =new int[]{127,56,48,25,12,10,1,-8};
        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.println("第"+(i+1)+"次比较的结果是:");
            for (int i1 : arr) {
            System.out.print(i1+"、");
        }
            System.out.println();
      }

执行流程

第一轮，
i=0,minIndex=0,里面的for循环int j = 1 ;j <8;
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[1]>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
i=1时的外层循环执行完毕，数组发生改变 -8、1、48、12、10、25、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 i1 : arr) {
            System.out.print(i1+"、");
        }

执行流程

第一轮：
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]，int preIndex=1,
while（1>=0 && 48<arr[1]）{}不成立，while循环不启动
arr[1+1]=arr[1+1]
第三轮：
 i=2,current=arr[3]，int preIndex=2,
while（2>=0 && 12<arr[2]）{}成立，
while循环启动{
arr[3] = arr[2]
2--
}
preIndex=1;
while（1>=0 && 12<arr[1]）{}成立，
while循环启动{
arr[2]=arr[1]
1--
}
preIndex=0;
while（0>=0 && 12<arr[0]）{}不成立，while循环不启动
arr[1]=12
结果变为：1，12，25，48，10，-8，127，56...

数组反转

思路1：
创建等长的数组
把当前输入的每一个元素倒着添加到新数组里
新数组赋值给了老数组

int[] neaArr =new int[arr.length];
for (int i = 0; i < arr.length; i++) {
    neaArr[i] = arr[arr.length-1-i];
}
arr=neaArr;
for (int i1 : arr) {
    System.out.print(i1+" ");
}

思路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.print(i);
    //Arrays是操作数组的一个工具类
}

数组的扩容

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