【Java数据结构】数组

看B站的数据结构视频照着打的，留着自己复习方便看。
B站链接：Java数据结构

数组的基本使用：

package demo1;

public class TestArray {
    public static void main(String[] args){
        //创建一个数组
        int[] arr1 = new int[3];
        //获取数组长度
        int length1 = arr1.length;
        System.out.println("arr1's length "+length1);
        //访问数组中的元素
        int element = arr1[0];
        System.out.println("element0 "+element);
        //为数组中的元素赋值
        arr1[0]=99;
        System.out.println("element0 "+arr1[0]);
        arr1[1]=98;
        arr1[2]=97;
        //遍历数组
        for (int i=0;i<arr1.length-1;i++){
            System.out.println("arr1 element"+i+":"+arr1[i]);
        }
        //创建数组的同时为数组中的元素赋值
        int[] arr2 = new int[]{90,80,70,64,50};
        //获取数组的长度
        System.out.println("arr2's length: "+arr2.length);
    }
}

数组末尾添加一个元素：

package demo1;

import java.util.Arrays;

public class TestOpArray {
    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(arr));

    }
}

如何删除数组中的元素：

package demo1;

import java.util.Arrays;

public class TestOpArray2 {
    //如何删除数组中的元素
    public static void main(String[] args){
        //目标数组
        int[] arr = new int[]{9,8,7,6,5,4};
        //要删除的元素的下标
        int dst = 2;
        System.out.println(Arrays.toString(arr));

        //创建一个新的数组，长度是原数组的长度-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));
    }
}

查找算法之线性查找：

package demo1;

//查找算法之线性查找
public class TestSearch {
    public static void main(String[] args){
        //目标数组
        int[] arr = new int[]{2,3,5,8,4,9,0};
        //目标元素
        int target = 9;
        //目标元素的下标
        int index = -1;

        for (int i=0;i<arr.length-1;i++){
            if (arr[i] == target){
                index = i;
                break;
            }
        }
        //打印目标元素的下标
        System.out.println("index:"+ index);
    }
}

查找算法之二分法：

package demo1;

//查找算法之二分法
public class TestBinarySearch {
    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 (true){
            //判断中间的是否为要查找的元素
            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);
    }
}

数组：MyArray

package demo1.util;

import java.util.Arrays;

public class MyArray {
    //用于存储数据的数组
    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 int search(int target) {
        //遍历数组
        for (int i = 0; i < elements.length - 1; 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;
        //记录目标位置
        while (true){
            //什么情况下没有这个元素，开始在结束位置之后，没有这个元素
            if (begin>end){
                return -1;
            }
            //判断中间的是否为要查找的元素
            if (elements[mid] == target){
                return mid;
                //中间这个元素不是要查找的元素
            }else {
                //判断中间这个元素是不是比目标元素大
                if (elements[mid] > target){
                    end=mid-1;
                }else {
                    begin=mid+1;
                }
                //取出新的中间位置
                mid=(begin+end)/2;
            }
        }
    }
}

TestArray:

package demo1;

public class TestArray {
    public static void main(String[] args){
        //创建一个数组
        int[] arr1 = new int[3];
        //获取数组长度
        int length1 = arr1.length;
        System.out.println("arr1's length "+length1);
        //访问数组中的元素
        int element = arr1[0];
        System.out.println("element0 "+element);
        //为数组中的元素赋值
        arr1[0]=99;
        System.out.println("element0 "+arr1[0]);
        arr1[1]=98;
        arr1[2]=97;
        //遍历数组
        for (int i=0;i<arr1.length-1;i++){
            System.out.println("arr1 element"+i+":"+arr1[i]);
        }
        //创建数组的同时为数组中的元素赋值
        int[] arr2 = new int[]{90,80,70,64,50};
        //获取数组的长度
        System.out.println("arr2's length: "+arr2.length);
    }
}

TestMyArraySearch:

package demo1;

import demo1.util.MyArray;

public class TestMyArraySearch {
    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(0);
        System.out.println("index:"+index);
        //调用二分法查找
        int index2 = ma.binarySearch(4);
        System.out.println("index2:"+index2);
    }
}