每天一道算法题——数组基础

什么是数组？

数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。

数组的特点

1. 数组是相同数据类型的元素的集合。
2. 数组中的各元素的存储是有先后顺序的，它们在内存中按照这个先后顺序连续存放在一起。
3. 数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如，a[0]表示名字为a的数组中的第一个元素，a[1]代表数组a的第二个元素，以此类推。

逻辑流程图

数组初始化逻辑流程图

数组在内存中是一块连续的空间

数组插入操作逻辑流程图

在0的位置插入3

在0的位置插入2

在0的位置插入1

数组插入操作（扩容）逻辑流程图

在0的位置插入0，此时原始数组已经被放满了，需要触发扩容操作

数组删除操作逻辑流程图

删除0位置的元素

代码实现

基于逻辑流程图，实现一个简单的数组

package com.seven.arry;

/**
 * 数组
 *
 * @author seven
 * @date 2022/09/25
 */
public class Arry {
    /**
     * 长度
     */
    private int size;
    /**
     * 当前已经存的数据大小
     */
    private int index;
    /**
     * 数据
     */
    private int[] data;

    public Arry(int size) {
        this.size = size;
        this.index = 0;
        // 分配存储空间
        data = new int[size];
    }

    public void print() {
        System.out.println("当前已经存的数据大小=======>index:" + index);
        for (int i = 0; i < index; i++) {
            System.out.print(data[i] + " ");
        }
        System.out.println();
    }

    /**
     * 插入
     *
     * @param loc 下标
     * @param n   值
     */
    public void insert(int loc, int n) {
        // 如果长度 等于 当前所存数据大小，那么就进行扩容
        if (index == size) {
            // 扩容 size = 2 * size;
            grow();
        }
        // 如果当前已经存的数据大小比长度小
        if (index++ < size) {
            // 把数据往后移动一个
            for (int i = size - 1; i > loc; i--) {
                data[i] = data[i - 1];
            }
            // 指定坐标，放入指定值
            data[loc] = n;
        }
    }

    /**
     * 扩容
     */
    public void grow() {
        // 扩容
        this.size = this.size * 2;
        int[] newData = new int[this.size];
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        this.data = newData;
    }

    /**
     * 删除
     *
     * @param loc 下标
     */
    public void delete(int loc) {
        if (loc < size) {
            for (int i = loc; i < size; i++) {
                // 把数据往前移动一位
                if (i != size - 1) {
                    data[i] = data[i + 1];
                } else {
                    // 最后一位置为0
                    data[i] = 0;
                }
            }
            index--;
        }
    }

    /**
     * 更新
     *
     * @param loc 下标
     * @param n   值
     */
    public void update(int loc, int n) {
        data[loc] = n;
    }

    /**
     * 获取
     *
     * @param loc 下标
     * @return 值
     */
    public int get(int loc) {
        return data[loc];
    }


    public static void main(String[] args) {
        Arry arry = new Arry(3);
        arry.print();
        arry.insert(0, 3);
        arry.print();
        arry.insert(0, 2);
        arry.print();
        arry.insert(0, 1);
        arry.print();
        // 这个操作会进行扩容
        arry.insert(0, 0);
        arry.print();
        arry.delete(0);
        arry.print();
    }
}

时间复杂度分析

插入（不扩容）和删除操作，只有一个循环，所以时间复杂度为O(n)；更新和获取操作，是常量级别的，复杂度为O(1)。因此数组基于下标的操作，比如更新以及获取的效率一般很高（忽略空间复杂度）。