数据结构和算法 —— 数组（三）面向对象的数组

思路

代码

数组类

public class MyArray {

    private int[] elements;

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

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

    //往数组的末尾添加一个元素
    public void add(int element) {
        //先创建一个新数组，新数组的长度是原数组的长度 + 1
        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 show() {
        System.out.println(Arrays.toString(elements));
    }

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

    //取出指定位置的元素
    public int get(int index) {
        return elements[index];
    }
    
    //插入一个元素到指定位置
    public void insert(int index, int element) {
        //创建一个新数组，新数组的长度是原数组的长度 + 1
        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) {
            throw new RuntimeException("数组下标越界");
        }
        elements[index] = element;
    }

    //线性查找
    public int search(int target) {
        //遍历数组
        for (int i = 0; i < elements.length; i++) {
            if (elements[i] == target) {
                return i;
            }
        }
        return -1;
    }
    
    //二分法查找
    public List<Integer> binarySearch2(MyArray myArray, int left, int right, int target) {
        //指定数组的left
//        left = 0;
        //指定数组的right
//        right = arr.length - 1;
        //指定我们要找的目标元素
//        int target = 89;
//        1、找到就直接结束递归
//        2、如果遍历完这个数组，还没有找到目标元素，也需要结束递归，此时，left > right
        if (left > right) {
            return new ArrayList<Integer>();
        }
//        所以，我们需要先找出数组中处于中间位置的那个元素（mid = (left + right) / 2），然后再拿这个元素 arr [mid] 和我们指定查找的元素（target）进行比较
        int mid = (left + right) / 2;
        int midVal = myArray.elements[mid];
//        如果 target > arr [mid] ，说明我们查找的元素在 mid 的右边，因此我们需要 递归 向右查找
        if (target > midVal) {
            left = mid + 1;
            return binarySearch2(myArray, left, right, target);
        }
        //        如果 target < arr [mid] ，说明我们查找的元素在 mid 的左边，因此我们需要 递归 向左查找
        else if (target < midVal) {
            right = mid - 1;
            return binarySearch2(myArray, left, right, target);
        }
        //        如果 target = arr [mid] ，说明我们查找的元素就是 mid ，就直接返回
        else {//target = midVal
            //分析
            //1、找到这个 mid 索引值，不马上返回
            //2、向该索引值的左边扫描，将所有满足target的下标，添加到集合中
            //3、向该索引值的右边扫描，将所有满足target的下标，添加到集合中
            //4、返回集合
            List<Integer> resIndexList = new ArrayList<>();
            //向该索引值的左边扫描，将所有满足target的下标，添加到集合中
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || myArray.elements[temp] != target) {//退出
                    break;
                }
                //否则，就把temp放到resIndexList中
                resIndexList.add(temp);
                temp -= 1;//temp左移
            }
            resIndexList.add(mid);
            //向该索引值的右边扫描，将所有满足target的下标，添加到集合中
            temp = mid + 1;
            while (true) {
                if (temp > myArray.elements.length - 1 || myArray.elements[temp] != target) {//退出
                    break;
                }
                //否则，就把temp放到resIndexList中
                resIndexList.add(temp);
                temp += 1;//temp右移
            }
            return resIndexList;
        }
    }
}

测试

public class TestMyArray {
    public static void main(String[] args) {
        //创建一个数组对象
        MyArray myArray = new MyArray();
        int size = myArray.size();
        System.out.println(size);
        //向数组中添加元素
        myArray.add(99);
        myArray.add(98);
        myArray.add(97);
        System.out.println(myArray.size());
        myArray.show();
        myArray.add(100);
        myArray.show();
        myArray.delete(3);//删除数组中指定位置的元素
        myArray.show();
        //在上面的[99, 98, 97]数组的索引为2的位置插入一个100的元素
        //插入成功后的数组应该是[99,98,100,97]
        myArray.insert(2, 100);
        myArray.show();
        myArray.set(3,101);
        myArray.show();
        //测试二分查找
        MyArray myArrayNew = new MyArray();//先创建一个有序数组
        myArrayNew.add(1);
        myArrayNew.add(8);
        myArrayNew.add(10);
        myArrayNew.add(89);
        myArrayNew.add(89);
        myArrayNew.add(99);
        myArrayNew.add(99);
        myArrayNew.add(1000);
        myArrayNew.add(1000);
        myArrayNew.add(1234);
        List<Integer> resultIndexList = myArray.binarySearch3(myArrayNew, 0, myArrayNew.size(), 99);
        System.out.print("找到的符合target的索引为: ");
        for (int i = 0; i < resultIndexList.size(); i++) {
            System.out.printf("%s\t",resultIndexList.get(i));
        }
}

打印结果