java面向对象的数组

拼搏现实的明天。 2022-12-19 08:47 183阅读 0赞

**面向对象数组的方法**

//面向对象的数组
    public class MyArray {
        private int elements [];
        public MyArray(){
            elements = new int[0];
        }
        public  int size(){
            return elements.length;
        }
        //输出数组元素
        public void show(){
            System.out.println(Arrays.toString(elements));
        }
        //向数组末尾添加一个元素
        public void add(int element){
            int newArray[] = new int[elements.length+1];
            //把原数组的元素复制到新数组中
            for (int i = 0; i <elements.length ; i++) {
                newArray[i]=elements[i];
            }
            //把添加的元素放到新数组中
            newArray[elements.length]=element;
            elements = newArray;
        }
       //删除数组的元素  指定要删除元素的索引
        public void delArray(int index){
            int newArray[] = new int[elements.length-1];
            if(index<0||index>newArray.length){
            throw new RuntimeException("数组下标越界");
            }
            for (int i = 0; i <newArray.length ; i++) {
                if(i<index){
                    newArray[i]=elements[i];
                }else{
                    newArray[i]=elements[i+1];
                }
            }
            elements=newArray;
        }
        //取出指定索引的元素
        public int get(int index){
            return elements[index];
        }
        //插入元素到指定的位置
        public  void insert(int index,int element){
            int newArray[] = new int[elements.length+1];
            for (int i = 0; i < elements.length; i++) {
    
                if(i<index){
                    newArray[i] = elements[i];
                }else{
                    newArray[i+1]= elements[i];
                }
            }
            newArray[index]=element;
            elements = newArray;
        }
        //线性查找
        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;
                    }else {
                        //把开始位置调整到中间位置的后一个位置
                        begin= mid+1;
                    }
                    mid=(begin+end)/2;
                }
            }
            return -1;
        }
    }

**测试**

public class TestMyArray {
        public static void main(String[] args) {
            MyArray myArray = new MyArray();
            myArray.show();
            myArray.size();
            myArray.add(78);
            myArray.add(79);
            myArray.add(80);
            myArray.show();
            myArray.size();
           // myArray.delArray(2);
            myArray.show();
            myArray.insert(1,66);
            myArray.size();
            myArray.show();
            System.out.println(myArray.search(79));
            System.out.println(myArray.binarySearch(79));
        }
    }

**总结二分法查找**

二分查找针对的是有序数组 二分查找的底层数据结构必须是数组

一组数据 找到最中间的数 把要查找的数据跟这个中间数比较

大于的话，就去这个中间数的右边，再找中间数进行比较 小于的话，就去这个中间数的左边，再找中间数进行比较

1.  循环退出条件。注意是 begin<= end，而不是begin<end，否则可能会查找不到数组，反回 -1。
2.  mid 的取值。因为如果 begin 和 end 比较大的话，两者之和就有可能会溢出。写成 begin+ (end - begin) / 2，或改写成位运算 start+ ((end - start) >> 1)，或 (start + end) >>> 1。