java数据结构之数组基本使用

实现数组的添加元素

public class testArray {
    public static void main(String[] args) {
        //实现数组的扩容

        //定义一个新的数组
        int[] arr = new int[]{7,8,9};

        //打印该数组
        System.out.println(Arrays.toString(arr));

        //如何将该数组后面添加一个新的元素
        int dest = 6;
        int[] newArr = new int[arr.length+1];
        //遍历改新数组

        for (int i = 0; i < arr.length; i++) {
            //将原数组的值赋值给新的数组
            newArr[i] = arr[i];

            }
        //再把6赋值给新数组
        newArr[arr.length] = dest;


    //查看新的数组
        System.out.println(Arrays.toString(newArr));
    //将新数组赋值给原数组

        arr = newArr;
        System.out.println(Arrays.toString(arr));

    }
}

实现数组的删除元素

public class testArray2 {
    public static void main(String[] args) {
        //实现删除一个数组的元素
       //先创建一个数组
       int[] arr = new int[]{9,8,7,6,5,4};
       //查看一下这个数组
        System.out.println("原数组的数据是: ");
        System.out.println(Arrays.toString(arr));
        //然后标记你要删除的哪一个元素的下标
        int des = 3;
        //给一个新数组
        int[] newArr=new int[arr.length-1];

        //通过一个循环吧数据放入新数组中
        for (int i = 0; i <newArr.length ; i++) {
            if (i < des){
                //如果是删除袁术之前，那么可以直接取原数组中的元素，放入新数组中
                newArr[i] = arr[i];
            }
            else {
                //如果是删除元素之后，那么的话就就是旧数组的长度加一
                newArr[i] = arr[i+1];

            }
        }

        System.out.println("新数组的数据是：");
        System.out.println(Arrays.toString(newArr));

        arr = newArr;
        System.out.println("删除过后的数据是：");
        System.out.println(Arrays.toString(arr));
    }
}

数组的顺序查找

public class testSearch {
    public static void main(String[] args) {
        //给定一个数组,目标数给定一个元素，查找数组的index,这是线性查找 效率比较低
        //因为是从头开始查找
        int arr[] =  new int[]{2,3,5,6,8,4,9,0};
        int target = 5;

        //默认的index
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target){
                index = i;
                break;
            }
        }
        System.out.println(index);
    }
}

数组 的二分法查找指定元素的索引（index）

public class TestBinarySearch {
    public static void main(String[] args) {

        //二分法 查找数组的指定值的index，前提是这个数组是顺序排列

        //首先的有一个数组
        int arr[] = new int[]{1,2,3,4,5,6,7,8,9};

        //定义目标值
        int target = 2;

        //起始位置
        int begin = 0;

        //结束位置
        int end = arr.length-1;
        
        //初始index
        int index = -1;

        //中间位置
        int mid = (begin + end) / 2;

        //来一个循环
        while (true){
            //判断是否是中间值
            if (arr[mid] == target){
                index = mid;
                break;
            }
            else {
                //判断是否在min之前
                if (arr[mid] > target){
                    end = mid - 1;
                }
                else {
                    begin = mid +1;
                }
                //取出新的中间位置
                mid=(begin+end)/2;
            }
        }
        System.out.println("index:"+index);
    }
}

=================================================================

将前面所写的封装起来，通过方法去调用数组的操作的 添加元素，删除元素，添加到指定位置，替换指定位置的元素，顺序查找，二分法查找数组指定值得索引

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){
        //还是需要一个新的数组

        int newArr[] = new int[elements.length-1];
        //判断一下是否下表越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("数组下标越界啦");
        }
        //进行一个数组的遍历
        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 element){
        return elements[element];
    }



    // 插入一个元素到指定位置
    public void insert(int index,int element){
        //创建一个新数组
        int newArr[] = new int[elements.length+1];
        //判断一下是否下表越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("数组下标越界啦");
        }
        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){
       elements[index] = element;

    }


    //给定一个数组,目标数给定一个元素，查找数组的index,这是线性查找 效率比较低
    //因为是从头开始查找
    public int search(int element){
        //默认的index
        int index = -1;
        for (int i = 0; i < elements.length; i++) {
            if (elements[i] == element){
                index = i;
                break;
            }
        }
        return index;
    }




    //创建一个二分法查找数据index的方法

    public int BinarySearch(int element){
        //起始位置
        int begin = 0;

        //结束位置
        int end = elements.length-1;

        //初始index
        int index = -1;

        //中间位置
        int mid = (begin + end) / 2;


        //来一个循环
        while (true){
            //判断是否是中间值
            if (elements[mid] == element){
                index = mid;
                break;
            }
            else {
                //判断是否在min之前
                if (elements[mid] > element){
                    end = mid - 1;
                }
                else {
                    begin = mid +1;

                }
                //取出新的中间位置
                mid=(begin+end)/2;
            }
        }
       return index;
    }
}

通过测试类去调用
test：

public class test {
    public static void main(String[] args) {
        MyArray ma = new MyArray();
        ma.add(90);
        ma.add(80);
        ma.add(70);
        ma.add(60);
        ma.show();
        System.out.println("========================");

        ma.delete(1);
        ma.show();
        System.out.println("========================");
        int i = ma.get(2);
        System.out.println(i);
        System.out.println("=========================");

        ma.insert(2,99);
        ma.show();
        System.out.println("========================");
        ma.set(3,900);
        ma.show();
    }
}

测试二：

public class TestSearch01 {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        //向数组中添加数据
        myArray.add(1);
        myArray.add(2);
        myArray.add(3);
        myArray.add(4);
        myArray.add(5);
        myArray.add(6);
        myArray.add(7);
        myArray.add(9);
        int search = myArray.search(5);
        System.out.println("index:"+search);
        System.out.println("================================");
        int binarySearch = myArray.BinarySearch(2);
        System.out.println("index:"+binarySearch);


    }
}