java面向对象的数组

面向对象数组的方法

//面向对象的数组
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。