2022-07-15 第九组 王佳齐

ALGO

 

 

 

 

数据结构

 

1.数组

 

是最基本的数据结构（线性表：在表当中数据元素之间是一对一的关系【除了第一个和最后一个之外其余的元素都是首尾连接】1-2-3-5-6）

 

2.链表

 

3.图

 

4.树

 

写程序的思路启发

 

1.先完成需求的功能

 

2.再根据程序运行的结果进行优化处理

 

3.研究代码重构(减少代码量)

 

4.提升效率

 

查找算法

 

练习

 

 

 

找出一个数在数组中的位置
* 存在返回下标，否则返回-1
* 找到了把下表i存起来，显示你要找的数是什么，在目标数组中的下标是什么
* 没找到显示你要找的数是什么，在目标数组中不存在

 

 

 

线性查找

 

   int arr []=new int[]{1,2,5,85,96,45};
        Scanner sf = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = sf.nextInt();
        boolean flag = false;
        int index=-1;
        for(int i = 0;i<= arr.length;i++){
            if(arr[i]==num){


                System.out.println("下标已保存为"+i);
//                System.out.println("你要找的数字为"+" "+num+" "+"下标为"+d);
//                flag = true;
                index=i;






            }
            break;
//            else{
//                System.out.println("-1");
//                System.out.println("你要找的数字为:"+num+" "+"在目标数组中不存哎！");




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

 

 

 

 

二分法查找

 

      int arr[] = new int[]{1,2,3,4,5,6,7};
        Scanner sf = new Scanner(System.in);
        System.out.println("输入数字");
        int target = sf.nextInt();
//        最左边下标
        int left=0;
//        最右边下标
        int right=arr.length-1;
        if (target<arr[0] || target>arr[arr.length-1]){
            System.out.println(target+"在目标数组中不存在");
        }else {
//            用来保存找到的1下标值
            int res = -1;


            while (left<=right){
//                找出中间位置
                int mid = (left+right)/2;
                if(arr[mid]==target){
//                    中间的数是我要找的数
                    res = mid;
//                    left= arr.length;
                    break;


                }else if (arr[mid]>target){
//                    数在前半区
                    /**
                     *left不动
                     * right移到中间位置 */
//                    中间的数在上一步已经判断过了
                    right = mid-1;


                }else {
//                    条件实际上是arr[mid]<target
                    /**
                     * 左半区
                     * right不动
                     * left变*/
                    left = mid-1;


                }


            }
            System.out.println("下标为"+res);

 

 

 

 

 

 

排序

 

八大排序算法

 

1.冒号

 

思路分析

 

1.先拿第一个数和后面的数一一比较大小

 

15，85，65，45，74，52

 

第一次比较：15和85 85和65（换位） 85和45（换位） 85和74（换位） 85和52（换位） 数组变为 15，65，45，74，52，85 第一轮结束【最大数归位】

 

第二次比较：15和65 65和45（换位）65和74 74和52（换位）数组变为 15 45 65 52 74 85 第二轮结束【第二大数归位】以后同上，直到全部归位。

 

代码实现

 

需要两层循环

 

外层for循环控制的是需要各个数之间比几轮，，，，只需要比较长度减一次

 

内层fot循环控制的是每个数之间真正的比较、、、、只需要比较长度减一次

 

//        排序
//        冒泡排序
        int [] arr=new int[]{45,98,12,13,15,456,74,18};
//       从小到大
        for (int i = 0; i < arr.length-1; i++) {
//           i=0 i<a-1 相当于没了俩数 比如 a=5 i<4 剩4个数
            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("");


        }
//        简便写法【只能从小到大】
//        Arrays.sort(arr);
//        for (int i : arr) {
//            System.out.println(i);
//     

 

 

 

2.选择

 

思路分析

 

1 28 58 64 -8 12 17

 

第一轮，假设第一个数是最小的数1arr[0]，让1和每个数都比一次，1和28 1和58 1和64 1和-8（）-8和12 -8和17 找到了最小的值-8，把最小的值和第一位换位置

 

-8 28 58 64 1 12 17

 

第二轮，假设第二个数是最小的数28arr[1]，让28和每个数都比一次，28和58 28和64 28和1 1和12 1和17 找到第二小的值1，把它和第二位换位置

 

-8 1 58 64 28 12 17

 

代码实现

 

需要两层循环

 

外层for循环控制的是需要各个数之间比几轮，，，，只需要比较长度减一次

 

内层fot循环控制的是每个数之间真正的比较、、、、只需要比较长度减一次

 

 

 

        int [] arr=new int[]{1,28,58,64,-8,12,17};
        for (int i = 0; i < arr.length; i++) {
//            假设最小数的下标
            int minIndex=i;
            for (int j = i; 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("");

 

 

 

 

3.插入

 

5 8 2 99 40 -1 4

 

假设这个数组是从小到大排列的，10最小，4最大

 

第一轮：【拿5比】2 5 8 99 40 -1 4 ， 2 -1 5 8 99 40 4，2 -1 4 5 8 99 40

 

第二轮：【拿8比】 2 -1 4 5 8 99 40

 

第三轮：【拿2比】 -1 2 4 5 8 99 40

 

第四轮：【拿99比】

 

代码实现

 

1.从第1个元素开始，假设该元素已经被排过序了

 

2.取出下一个元素，在已经排过序的序列中向前扫瞄

 

3.如果该元素（已排序）比下一个元素大，将该元素移到下个位置

 

4.将新元素插入到原来那个数的位置，以此类推

 

        int [] arr=new int[]{1,28,58,64,-8,12,17};
//        定义参照物[当前数]
        int current;
        for (int i = 0; i < arr.length-1; i++) {
            current=arr[i+1];
//            涉及到i+1 ,上边都减一
//            定义上一个元素的下标
            int preIndex = i;
//            当上一个数的下标有效不小于零
//            且保证当前数比上一个数小
//            这时候才能让当前数往前移


            while (preIndex>=0 && current<arr[preIndex]){
//                移位
//                前面的数往后移一位
                arr[preIndex+1]=arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1]=current;


        }
        for (int i : arr) {
            System.out.print(i+"、");

 

 

 

 

4.快速

 

以上常见

 

5.希尔

 

6.归并

 

7.堆

 

8.桶

 

数组的反转

 

思路一

 

创建一个等长数组int [] newArr=new int[arr.length];

 

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

 

        int [] arr=new int[]{1,28,58,64,-8,12,17};
        int [] newArr=new int[arr.length];


        for (int i = arr.length-1; i>=0 ; i--) {
            newArr[i]=arr[arr.length-1-i];
        }
//        新数组赋值给老数组
        arr = newArr;
        for (int i : arr) {
            System.out.println(i);

 

 

 

 

思想二

 

利用交换的方式

 

for (int i = 0; i < arr.length/2; i++) {
    int temp = arr[arr.length-i-1];
    arr[arr.length-1-i]=arr[i];
    arr[i]=temp;
}
for (int i : arr) {
    System.out.println(i);


}

 

 

 

 

数组扩容

 

思路分析

 

定义一个新的临时数组，经过循环，再赋值给老数组【注意：不要把老数组里原本存在的值给弄丢】

 

代码实现

 

   public static void main(String[] args) {
        int [] num = new int[]{6,2,1};
//        定义一个新的临时数组
        int [] temp = new int[6];
        for (int i = 0; i < num.length; i++) {
            temp[i]=num[i];
        }
        num = temp;
        for (int i : num) {
            System.out.println(i);
        }

 

 

学习心得：

　　今天学习了八大排序里的三种常见算法和两种查找算法以及数组相关算法；插入排序听的不是很懂，可能学习的时间很短，相信在以后随着对Java和其他语言的深入学习，能够对这个算法有更深入透彻的理解！