线性结构（数组）

数组

• 基本使用

    public static void main(String[] args) {
        // 创建数组
        int[] arr = new int[3];
        // 获取数组长度
        int length = arr.length;
        System.out.println("length:"+length);
        // 获取第一个【取下标】
        int arr0 = arr[0];
        System.out.println("第一个："+arr0);
        // 赋值
        arr[0]= 99;
        arr[1] = 88;
        arr[2] = 77;
        System.out.println("arr0:"+arr[0]);
        // 循环遍历
        for (int i  = 0; i < length;i++) {
            System.out.println(i);
        }

        // 创建数组时，同时赋值
        int[] arr1 = new int[] {1,2,3,4,5,6};
        System.out.println(arr1.length);
    }

• 数组元素的添加

    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = new int[] {9,8,7};
        System.out.println(Arrays.toString(arr));
        // 定义一个新元素
        int dst = 100;
        // 定义一个新数组
        int[] newArr = new int[arr.length+1];

        // 添加到后面
        // 将就数组中的数据添加到新数组中
        for (int i =0;i< arr.length;i++) {
            newArr[i] = arr[i];
        }
        // 将新元素添加到后面
        newArr[arr.length] = dst;
        // 替换数组
        arr = newArr;
        System.out.println(Arrays.toString(newArr));

        // 添加到前面
        newArr[0] = dst;
        for (int i =0;i< arr.length;i++) {
            newArr[i+1] = arr[i];
        }
        arr = newArr;
        System.out.println(Arrays.toString(newArr));
    }

• 数组元素的删除

    public static void main(String[] args) {
        int[] arr = new int[] {1,2,3,4,5,6,7,8,9};
        int index = 4;

        int[] newArr = new int[arr.length-1];
        for (int i = 0; i< newArr.length;i++) {
            if (i < index) {
                newArr[i] = arr[i];
            } else {
                newArr[i] = arr[i+1];
            }
        }
        arr = newArr;
        System.out.println(Arrays.toString(arr));
    }

面向对象的数组

public class ArrayOO {
    private int[] elements;

    public ArrayOO() {
        this.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 remove(int index) {
        if (index < 0 || index > elements.length) {
            throw new RuntimeException("越界");
        }
        int[] newArr = new int[elements.length - 1];
        for (int i = 0; i < newArr.length; i++) {
            if (i < index) {
                newArr[i] = elements[i];
            } else {
                newArr[i] = elements[i + 1];
            }

        }
        elements = newArr;
    }

    /**
     * 获取一个元素
     * @param index
     * @return
     */
    public int get(int index) {
        if (index > elements.length || index < 0) {
            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 elememt
     */
    public void set(int index, int elememt) {
        if (index < 0 || index > elements.length) {
            throw new RuntimeException("越界");
        }
        elements[index] = elememt;
    }

    /**
     * 显示所有元素
     * @return
     */
    public String show() {
        return Arrays.toString(elements);
    }
}

查找算法

线性查找

目标元素的数组中的每一个元素对比

public class LinearSearch {
    
    /**
     * @param arr    目标数组
     * @param target 待查找元素
     * @return
     */
    public int search(int[] arr, int target) {
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                index = i;
                break;
            }
        }
        return index;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{2, 5, 6, 8, 9, 22, 89, 69, 42, 63, 28};
        int target = 66;
        LinearSearch linearSearch = new LinearSearch();
        System.out.println(linearSearch.search(arr, target));
    }
}

二分法查找

对有序的数组进行查找

    public int search(int[] arr, int target) {
        int begin = 0;
        int end = arr.length-1;
        int mid = (begin+end)/2;
        int index = -1;

        while (true) {
            if (arr[mid] == target) {
                index = mid;
                break;
            } else {
                if (arr[mid] > target) {
                    end = mid-1;
                } else {
                    begin = mid+1;
                }
                mid = (begin+end)/2;
            }
        }
        return index;
    }

在大数据量的情况下，二分法查找算法优于线性查找算法

https://gitee.com/longhaicheng/Data-Structures-and-Algorithms