数据结构与算法(一)（数组、线性查找、二分查找）

 根据B站视频做的笔记及一些个人理解

https://www.bilibili.com/video/av33835237

 

一、数组(有索引下标，所以查找快，增删慢)

 

　　1.1数组元素的基本使用

　　

结果：

 

public static void main(String[] args) {
        //创建一个数组
        int[] arr = new int[3];
        //获取数组长度
        int length1 = arr.length;
        System.out.println("数组的长度为:"+length1);
        //访问数组中的元素:数组名[下标],注意:下标从0开始，最大到数组长度-1,如果大于这个长度会抛异常
        int element0 = arr[0];
        System.out.println("element0"+":"+element0);
        //为数组中的元素赋值
        arr[0] = 99;
        System.out.println("element0"+":"+arr[0]);
        arr[1] = 98;
        arr[2] = 97;
        //遍历数组
        for(int i = 0 ; i < arr.length ; i++){
            System.out.println("arr element"+i+":"+arr[i]);
            
        }
        //创建数组的同时给数组赋值
        int[] arr1 = new int[]{10,2,0,30,40};
        //获取数组长度
        System.out.println("arr1 length"+arr1.length);
    }

 　　1.2数组元素的增加

　　　　其实也就是解决数组长度不可变的问题

　　　　思路：我们可以创建一个新的数组，然后新的数组长度为原数组的长度+1，在放入原数组的元素，替换原数组

　　　　

　　　　结果

　　　　

　　　　

public static void main(String[] args) {
        //解决数组长度不可变的问题
        //创建数组
        int[] arr = new int[]{9,8,7};
        //快速查看数组中的元素
        System.out.println(Arrays.toString(arr));
        //要加入数组的目标元素
        int dst=6;
        
        //创建一个新的数组,长度是原数组长度+1
        int[] newArr = new int[arr.length+1];
        //把原数组中的数据全部复制到新数组中
        for(int i = 0 ; i < arr.length;i++){
            newArr[i] = arr[i];
        }
        //把目标元素放入新数组的最后
        newArr[arr.length] = dst;
        //新数组替换原数组
        arr = newArr;
        System.out.println(Arrays.toString(newArr));
    }

　　1.3数组元素的删除

 　　思路：我们可以创建一个新的数组，然后新的数组长度为原数组的长度-1，复制原数组中除了要删除的那个元素以外其他的元素

　　

　　结果　　

　　

　　

　　

public class arrayTest3 {
    //如何删除数组中的元素
    public static void main(String[] args) {
        //创建数组
        int[] arr = new int[]{9,8,7,6,5,4};
        System.out.println(Arrays.toString(arr));
        //要删除的元素下标
        int dst = 3;
        
        //创建一个新的数组,长度是原数组的长度-1
        int[] newArr = new int[arr.length-1];
        //复制原数组中除了要删除的那个元素以外其他的元素
        for(int i=0;i<newArr.length;i++){
            //要删除的元素之前的元素(直接对应赋值)
            if(i<dst){
                newArr[i]=arr[i];
            //要删除的元素之后的元素
            }else{
                newArr[i]=arr[i+1];
            }
        }
        //新数组替换旧数组
        arr = newArr;
        System.out.println(Arrays.toString(arr));
    }
}

 　　1.4面向对象的数组(我个人理解就是动态数组)

　　　　感觉就是写一个简略版的ArrayList，可以帮助我们理解ArrayList的源码

　　　　首先写一个工具类，封装数组及方法

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

    // 用于存储数据的数组
    private int[] elements;

    public MyArray() {
        elements = new int[0];
    }

    // 获取数组长度的方法
    public int size() {
        return elements.length;
    }

    // 往数组的末尾添加一个元素
    public void add(int element) {
        // 创建一个新的数组
        int[] newArr = new int[elements.length + 1];
        // 把原数据复制到新数组中
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }
        // 把添加的元素放入新数组中
        newArr[elements.length] = element;
        // 使用新数组替换久数组
        elements = newArr;

    }

    // 打印所有元素到控制台
    public void show() {
        System.out.println(Arrays.toString(elements));
    }

    // 删除数组中的元素
    public void delete(int index) {
        // 判断下标是否越界
        if (index < 0 || index > elements.length - 1) {
            throw new RuntimeException("下标越界");
        }
        // 创建一个新数组,长度为原数组长度-1
        int[] newArr = new int[elements.length - 1];
        // 复制原有元素到新数组
        for (int i = 0; i < newArr.length; i++) {
            // 想要删除的元素前面的元素
            if (i < index) {
                newArr[i] = elements[i];
                // 想要删除的元素后面的元素
            } else {
                newArr[i] = elements[i + 1];
            }
        }
        // 新数组替换老数组
        elements = newArr;

    }

    // 获取指定位置的元素
    public int get(int index) {
        return elements[index];
    }

    // 插入一个元素到指定位置
    public void insert(int index, int element) {
        // 创建一个新的数组
        int[] newArr = new int[elements.length + 1];
        // 将原数组中的元素放入新数组
        for (int i = 0; i < elements.length; i++) {
            // 目标位置之前的元素
            if (i < index) {
                newArr[i] = elements[i];
                // 目标位置之后的元素
            } else {
                newArr[i + 1] = elements[i];
            }
        }
        // 插入新的元素
        newArr[index] = element;
        elements = newArr;
    }

    // 替换指定位置的元素
    public void set(int index, int element) {
        // 判断下标是否越界
        if (index < 0 || index > elements.length - 1) {
            throw new RuntimeException("下标越界");
        }
        elements[index] = element;
    }

测试类

　　

    public static void main(String[] args) {
        //创建一个动态数组
        MyArray ma = new MyArray();
        //获取长度
        int size = ma.size();
        System.out.println("长度为"+size);
        //往可变数组中添加一个元素
        ma.add(99);
        ma.add(98);
        ma.add(97);
        System.out.println(ma.size());
        ma.show();
        //删除元素
        ma.delete(1);
        ma.show();
        System.out.println(ma.size());
        //插入指定位置元素
        System.out.println(ma.get(0));
        System.out.println("---------------------------------");
        ma.add(96);
        ma.add(95);
        ma.add(94);
        ma.show();
        ma.insert(3, 3);
        ma.show();
        //替换指定位置元素
        ma.set(3, 4);
        ma.show();
        
        
    }

　　结果：

 　　1.6查找算法

　　　　　　1.6.1线性查找(效率低，如果特别多数据不建议)　

　　　　　　　　定义：

　　　　　　　　　　　　在一列给定的值中进行搜索，从一端开始逐一检查每个元素，直到找到所需元素的过程。

　　　　　　　　　　　　线性查找又称为顺序查找·

　　　　　　　　　　　　如果查找池是某种类型的一个表，比如一个数组，简单的查找方法是从表头开始，一次将每一个值与目标元素进行比较，最后，或者查找到目标，或者达到表尾，而目标不存在于组中，这个方法称为线性查找。

　　　　　　　　我们这里使用数组来学习线性查找，遍历数组，将目标值与数组值从头开始对比，当值相同，退出循环，打印下标，若查找不到，下标值为-1

　　　　　　　　

　　　　　　　　

//目标数组
        int[] arr = new int[]{2,3,4,5,6,8,9};
        //目标元素
        int target = 8;
        //目标元素所在下标
        int index = -1;
        //遍历数组
        for(int i = 0 ;i<arr.length;i++){
            if(arr[i] == target){
                index = i;
                break;
            }
        }
        //打印目标元素的下标
        System.out.println("index:"+index);

　　　　　　结果：

　　　　　　　　　　

 

　　　　　　　　　　

　　　　　　1.6.2二分查找

　　　　　　　　　　定义：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好，占用系统内存较少;其缺点是要求待查表为有序表，且插入删除困难。

　　　　　　　　　　　　　因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

　　　　　　　　　　　　   首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功;

　　　　　　　　　　　　　否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。

　　　　　　　　　　　　　重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

　　　　　　　　　　　因为是需要有序的数组才能使用二分查找，我们可以定义一个begin和end还有mid，通过目标值比较中间值，对比大小，来移动begin或end到之前mid的位置，从而得到目标值的位置

　　　　　　

　　　　　　while()中的条件本来是true,但是这样如果目标值不在数组中，会导致死循环(因为走不到break那里。)

　　　　　　我们改成while(begin<=end)这样的话，如果的话，当程序走到最后剩中间两个数，再走下去begin就大于end了，程序终止

　　　　　　结果：

　　　　　　　　

 

　　　　      

public static void main(String[] args) {
        //目标数组
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
        //目标元素
        int target = 8;
        //记录开始位置
        int begin = 0;
        //记录结束位置
        int end = arr.length-1;
        //记录中间位置
        int mid = (begin+end)/2;
        //记录目标位置
        int index = -1;
        while (begin<=end) {
            //判断中间这个元素是不是要找的元素
            if(arr[mid] == target){
                index = mid;
                break;
            //中间这个元素不是要查的元素
            }else {
                //判断中间这个元素是不是比目标元素要大
                if(arr[mid]>target){
                    //把结束位置调整到中间位置前一个位置
                    end = mid-1;
                //中间这个元素比目标元素小
                }else{
                    //把开始位置调整到中间位置的后一个位置
                    begin = mid+1;
                }
                //取出新的中间位置
                mid = (begin + end)/2;
            }
            
        }
        System.out.println("index:"+index);
    }

　　　　　　1.6.3整合查找算法

　　　　　　　　　　将线性查找和二分查找整合到我们的动态数组工具类里

　　　　　　　　　

//线性查找
    public int search(int target){
        // 遍历数组
        for (int i = 0; i < elements.length; i++) {
            if (elements[i] == target) {
                return i;
            }
        }
        return -1;
    }
    
    //二分法查找
    public int binarySearch(int target){
        // 记录开始位置
        int begin = 0;
        // 记录结束位置
        int end = elements.length - 1;
        // 记录中间位置
        int mid = (begin + end) / 2;
        // 记录目标位置
        int index = -1;
        while (begin <= end) {
            // 判断中间这个元素是不是要找的元素
            if (elements[mid] == target) {
                return mid;
                // 中间这个元素不是要查的元素
            } else {
                // 判断中间这个元素是不是比目标元素要大
                if (elements[mid] > target) {
                    // 把结束位置调整到中间位置前一个位置
                    end = mid - 1;
                    // 中间这个元素比目标元素小
                } else {
                    // 把开始位置调整到中间位置的后一个位置
                    begin = mid + 1;
                }
                // 取出新的中间位置
                mid = (begin + end) / 2;
            }

        }
        return index;
        
    }

 

 测试类：

　　　　

public static void main(String[] args) {
        MyArray ma = new MyArray();
        ma.add(1);
        ma.add(2);
        ma.add(3);
        ma.add(4);
        ma.add(5);
        //调用线性查找方法
        int index = ma.search(4);
        System.out.println(index);
        //调用二分法查找
        int index1 = ma.binarySearch(5);
        System.out.println(index1);
    }