长春人文学院第四组孙乃宇https://www.cnblogs.com/sunnaiyu/数组和算符

数据结构

数组

1. 数据结构：数组，线性表，就是在这个表中数据元素之间是一对一的关系，除了第一个和最后一个之外，其余元素都是首位连接，所以可以使用下标，有顺序。

链表

1.什么是链：单项和双向，

数组

1. 判断一个数在数组中是否存在，存在返回下标

   算法

2. 线性查找：

int [] arr=new int []{1,3,59,5,34,33,21};
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数");//线性查找
        int number=sc.nextInt();
        int index=-1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==number){
                index=i;
                break;
            }
        }
        if(index==-1){
            System.out.println("你要找的数不存在");
        }else {
            System.out.println("你要找的数是"+number+"在数组中的下标是"+index);
        }

1. 二分法查找：

案例：

/要使用二分法查找找数字
        //这个数组必须有顺序
        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[target]){
            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){
                    right=middle-1;
                }else{
                    left=middle+1;
                }
            }
            System.out.println(res);
        }

1. 冒泡排序法
   1. 案例

//冒泡排序法
        /*
        从小到大
        思路：
        1.先拿第一个数和后面的数一一比较大小，如果比这个数小就换位，经过一轮比较最大的数就会在最后
        2.经过数组长度减一次的比较，就会排序完成
        3.外层循环：表示排序几轮
        4.里层循环：实现数和数之间的比较，*/
        int[] arr=new int[]{3,-9,-12,9,3,44,22,55};
        for(int i=0;i<arr.length-1-i;i++){//比较的次数就是长度减一
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=0;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i : arr) {
            System.out.println(i);
        }

2. 选择排序：

   1. 第一轮：架设第一个数是最小的数，然后让1和每个数比较，1和25 1和48 1和101和-8和127 -8和56，找到了整个数组中最小的值min=arr[5],把最小的值和第一位换位置

   2. 第二轮，假设第二个数就是最小的数25arr[1]，25和4825和1212和1010和11和127 1和56找到了整个数组中第二小的值min = arr[5]，把第二小的值和第二位换位置

/*
    * 第一轮：i=0,minIndex=0里层的for循环int j=1;j<7;
    * if(arr[0]>arr[1]由于if不满足，则继续下一次的比较
    * j=2,
    j = 2,if(arr[0] > arr[2])0。由于if不满足，则继续下一次的比较
    * j = 3,if(arr[o] > arr[3])0。由于if不满足，则继续下一次的比较
    * j = 4,if(arr[o] > arr[4])0。由于if不满足，则继续下一次的比较
    * j = 5,if(arr[o] > arr[5])0。由于if满足条件，执行了minindex=5
    * j = 6,if(arr[5] > arr[6]){。由于if不准足，则继续下一次的比较
    * j = 7,if(arr[5] > arr[7])0。
    * 到此为止，里层的fFor循环执行完毕。minIndex = 5。执行的
    int temp = arr[5];
    * arr[5] = arr[0];
    * arr[o] = temp;
    i=0的这次外层循环执行完毕。数组变成了-8、25、48、12、10、1、127、
    * */
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;
        }
        for (int i : arr) {
            System.out.print(i+"，");
        }

学习心得：今天学的都是算法，线性查找法，二分法，冒泡排序法，选择排序法，插入排序法。
我的感受就是虽然代码量不多，但是很考逻辑，不是能够很好的，很容易的写出来，就算看懂了，一边也是写不出来的，虽然已经听了几遍了，但是每次听都有不同的收获，老师说，能够理解其中的含义，能够分清每一步的执行流程，就可以。就今天的作业来说，对于只学了几天的java基础的小白同学来说，是很困难的，没有用面向对象的知识对于我这种有些基础的来说，也是有一点坎坷的。就拿我的同桌来说，她昨天生病没有来上课，在我做完之后，他还啥都没写，啥都没写。我就从头开始给他讲解今天的作业，发现她真的什么都不会，什么都不会。我就从最基础的地方开始讲，如数组的定义，数组的索引，数组的长度，等等，经过了几个小时的苦战，终于讲完了今天的作业。但是给别人讲完之后我自己也，更加熟悉了些。
建议：我觉得老师讲的有点快，有很多的同学跟的都有些困难。但老师流的作业都可以让我们能够理解这些。让我们能够快速掌握知识，还是不错的。我建议老师之后流的作业可以减轻一些难度。对于小白来说可以减轻一些压力。