今日内容：数组的一些算法

数据结构

数组

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]，把第二小的值和第二位换位置

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CjqYSBI9-1657895743691)(C:\Users\17451\Desktop\Snipaste_2022-07-15_14-24-22.png)]

/*
    * 第一轮：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+"，");
        }

好难。。。