2022-07-15 第二组 卢睿 学习心得

Java(数据结构与算法)

知识点

数组

数组的反转

算法

1. 线性查找
2. 折半查找
3. 冒泡排序
4. 选择排序
5. 插入排序

感想

学算法是真的痛苦，插入排序不太好跟上，老师讲的是真的块，跟不上，学了两天就要写管理系统，十分考验对java基础的掌握，感谢帮助我的同学，使我能顺利地写出这个程序。

学习内容

数据结构

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

案例

找出目标数在数组中的位置，存在输出下标
找到了把下标保存在i里，输出
若不存在则输出不存在

package com.morning;

import java.util.Scanner;

public class Ch01 {
    public static void main(String[] args) {
        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 (num == arr[i]) {
                index = i;
            }
        }
        if (index != -1) {
            System.out.println("你要找的数是：" + num + ",在数组中的下标是：" + index);
        } else {
            System.out.println("你要找的数是：" + num + ",在目标数组中不存在");
        }
    }
}

这个案例是线性查找

折半查找

package com.morning;

import java.util.Scanner;

/*
查找算法
二分法查找
如果要使用二分法查找数字，前提是这个数组必须有顺序
 */
public class Ch02 {
    public static void main(String[] args) {
        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;
                    System.out.println("你要找的数是：" + arr[middle] + "，下标是：" + middle);
                    break;
                } else if (arr[middle] > target) {
                    /*
                    说明我们要找的数在数组的前半区
                        如果在前半区
                        维护left和right
                        left是不需要动的
                        right应该移动到中间的位置
                     */
                    right = middle - 1;
                } else {
                    //条件实际上就是arr[middle]<target
                    /*
                        说明在后半区
                        right是不需要动的
                        right应该向右移位到中间位置
                     */
                    left = middle + 1;
                }
            }
        }
    }
}

排序算法

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

冒泡排序

package com.morning;

//冒泡排序
public class Ch03 {
    public static void main(String[] args) {
        int[] arr = new int[]{99, 58, 464, 33, -10, 5, -8};
        //从小到大
        /*
            冒泡排序思路分析：
            1.我先拿第一个数和后面的数一一比较大小
         */
        /*
            冒泡排序需要两层循环嵌套：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 = 0;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第" + (i+1) + "轮的比较结果是：");
            for (int i1:arr) {
                System.out.print(i1 + "、");
            }
            System.out.println(" ");
        }
    }
}

冒泡排序的简便操作

package com.morning;

import java.lang.reflect.Array;
import java.util.Arrays;

//冒泡排序的简便操作
public class Ch04 {
    public static void main(String[] args) {
        int[] arr = new int[]{99, 58, 464, 33, -10, 5, -8};
        Arrays.sort(arr);
        for (int i: arr) {
            System.out.println(i);
        }
    }
}

选择排序

package com.afternoon;

//选择排序
public class Ch01 {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 25, 48, 12, 10, -8, 127, 56};
        for (int i = 0; i < arr.length ; i++) {
            //假设arr[0]是最小的
            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.print("第" + (i+1) + "比较次数结果是：");
            for (int i1:arr
            ) {
                System.out.print(i1 + "、");
            }
            System.out.println(" ");
        }
    }
}

解说一下

        /*
        * 第一轮，
        *   i = 0 ，minIndex = 0， 里层的for循环int j = 1;j<7;
        *   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 = j
        *   j = 6,if(arr[5]>arr[6]){}。由于if不满足，则继续下一次的比较
        *   j = 7,if(arr[5]>arr[7]){}。由于if不满足，则继续下一次的比较
        *   里层循环完毕
        *   int temp = arr[5];
        *   arr [5] = arr[0];
        *   arr[0] = temp;
        *   数组变成了-8,25,48,12,10,1,127,56,打印输出
        * 第二轮i = 1继续循环 
        *   
        * */

插入排序

public class InsertionSort {
    //核心代码---开始
    public static void sort(Comparable[] arr){

        int n = arr.length;
        for (int i = 0; i < n; i++) {
            // 寻找元素 arr[i] 合适的插入位置
           for( int j = i ; j > 0 ; j -- )
                if( arr[j].compareTo( arr[j-1] ) < 0 )
                    swap( arr, j , j-1 );
                else
                    break;
        }
    }
    //核心代码---结束
    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {

        int N = 20000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        InsertionSort.sort(arr);
        for( int i = 0 ; i < arr.length ; i ++ ){
            System.out.print(arr[i]);
            System.out.print(' ');
        }
    }

}

数组的反转

我的写法

package com.afternoon;
//数组的反转
public class Ch03 {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 25, 48, 12, 10, -8, 127, 56};
        /*
        思路1
        重新创建一个等长的数组，把当前输入的每一个元素倒着添加到新数组里
        新数组赋值给老数组
        int[] newArr = new int[arr.lenth];
         */
        int [] newArr = new int [arr.length];
        for (int i = arr.length-1; i >=0 ; i--) {
            int j = 0;
            newArr[j] = arr[i];
            System.out.print(newArr[j] + "、");
            j++;
        }
    }
}

老师的写法1

        int[] arr = new int[]{1, 25, 48, 12, 10, -8, 127, 56};
        int [] newArr = new int [arr.length];
        for (int i = arr.length-1; i >=0 ; i--) {
            newArr[i] = arr[arr.length-i-1];
        }
        arr = newArr;
        for (int i:arr
             ) {
            System.out.println(i);
        }

写法2

        int[] arr = new int[]{1, 25, 48, 12, 10, -8, 127, 56};
        for (int i = 0; i <=arr.length/2 ; i++) {
            int temp = arr[arr.length-1-i];
            arr[arr.length-1-i] = arr[i];
            arr[i] = temp;
        }
        for (int i: arr
             ) {
            System.out.println(i);
        }