数据结构和算法基础之数组-Java版

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_40833790/article/details/90598147

一、面向对象数组

import java.util.Arrays;

public class MyArray {
    private int[] elements;

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

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

    /**
     * 添加一个元素
     * @param element
     */
    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;
    }

    /**
     * 删除指定元素
     * @param index
     */
    public void delete(int index) {
        if (index < 0 || index > elements.length - 1) {
            throw new RuntimeException("索引值越界");
        }
        int[] newArr = new int[elements.length - 1];
        //4.数组赋值
        for (int i = 0; i < newArr.length; i++) {
            if (index > i) {
                newArr[i] = elements[i];
            } else {
                newArr[i] = elements[i + 1];
            }
        }
        //5.新数组赋值给旧数组
        elements = newArr;
    }

    /**
     * 获取某个元素
     * @param index
     * @return
     */
    public int get(int index){
        if(index < 0 ||index > elements.length -1){
            throw new RuntimeException("索引值越界");
        }
        return elements[index];
    }

    /**
     * 往指定位置插入数据
     * @param index
     * @param element
     */
    public void insert(int index,int element){
        if(index < 0 || index > elements.length){
            throw new RuntimeException("索引值越界");
        }
        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;
    }

    /**
     * 替换指定位置的元素
     * @param index
     * @param element
     */
    public void set(int index,int element){
        if(index < 0 || index > elements.length){
            throw new RuntimeException("索引值越界");
        }
        elements[index] = element;
    }

    /**
     * 线性查找
     * @param target
     */
    public int search(int target){
        for (int i = 0; i < elements.length; i++) {
            if(elements[i] == target){
                return i;
            }
        }
        return -1;
    }

    /**
     * 二分法查找
     * @param target
     * @return
     */
    public int binarySearch(int target){
        int begin = 0;
        int end = elements.length-1;
        int mid = (begin+end)/2;
        int index = -1;
        while (true){
            if(begin >= end){
                break;
            }
            if(elements[mid] == target){//等于中间元素
                index = mid;
                break;
            }else{
                if(elements[mid] < target){//大于中间元素
                    begin = mid + 1;
                }else{
                    end = mid -1;
                }
                mid = (begin+end)/2;
            }
        }
        return index;
    }

    /**
     * 查看数组中的元素
     */
    public void show() {
        System.out.println(Arrays.toString(elements));
    }
}

二、查找算法（以数组为例）

1、线性查找

线性查找即从数组初始下标开始遍历查找，当查找到该目标数据之后中止查找

public static void main(String[] args) {
        int[] arr = new int[]{0,1,2,3,4,5,6};//目标数组
        int index = -1;
        int target = 4;//目标数据
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == target){
                index = i;
                break;
            }
        }
        System.out.println("index="+index);
 }

2、二分法查找

二分法查找的前提是数组必须有序

public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8};//目标数组
        int target = 6;//目标数据
        int begin = 0;//开始位置
        int end = arr.length-1;//结束位置
        int mid = (begin+end)/2;
        int index = -1;
        while (true){//查找数据不在有序范围内
            if(begin >= end){
                break;
            }
            if(arr[mid] == target){//中间位置是否等于查找数据
                index = mid;
                break;
            }else{
                if(arr[mid] > target){//中间数据比查找数据大
                    end = mid-1;
                }else if(arr[mid] < target){//中间数据比查找数据小
                    begin = mid+1;
                }
                mid = (begin+end)/2;
            }
        }
        System.out.println("index="+index);
 }