数据结构2-一维数组封装和操作-复杂度分析_动态开辟的数组重新赋值,空间复杂度增加吗-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45735154/article/details/120228650

本文探讨了一维数组的封装和操作，包括数据结构的设计、动态扩容及泛型化。在分析中，指出空间复杂度的关键在于数组长度，对于一维数组，其空间复杂度为O(n)；而在涉及二维数组或递归时，空间复杂度会提升到O(n^2)或递归深度。文章强调了理解并控制这些因素对于优化算法的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述 data:存放的元素
size：指向下一个元素的下标
capacity：容量

在这里插入图片描述 Array的构建

import java.util.Arrays;

public class Array {
    private int[] data;
    private int size;


    public Array(){
        this(10);
    }
    public Array(int capacity){
        data = new int[capacity];
    }
    public int getCapacity(){
        return data.length;
    }

    public int getSize() {
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public void add(int index,int e){
        if (size ==data.length){
            throw new RuntimeException("array is full,add failed");
        }
        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        //移位
        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index] = e;
        size++;

    }
    public void addFirst(int e){
        add(0,e);
    }
    public void addLast(int e){
        add(size,e);
    }

    public int get(int index){
        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        return data[index];
    }
    public void set(int index,int a){
         data[index]=e;
    }
    public int find(int e){
        for(int i=0;i<size;i++){
            if (data[i]==e) return i;
        }
        return -1;
    }
    public boolean contain(int e){
        for (int i=0;i<size;i++){
            if (data[i]==e)return true;
        }
        return false;
    }
    public int remove(int index) {
        if (index < 0 || index > size) {
            throw new RuntimeException("remove failed ,require index>=0,and index<=size");

        }
        int ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];}
            size--;
            return ret;


    }
    //从数据中删除第一个元素，返回删除的元素
    public int removeFirst(){
        return remove(0);
    }
    //删除最后一个元素，返回删除的元素
    public int removeLast(){
        return remove(size-1);
    }

    //从数据中删除某个元素e
    public void removeElement(int e){
        int index = find(e);
        if (index !=-1){
            remove(index);
        }

    }

    @Override
    public String toString() {
    StringBuilder res = new StringBuilder();
    res.append(String.format("Array: size =%d , capacity = %d\n" , size ,data.length));
    res.append('[');
    for (int i=0 ;i<size;i++){
        res.append(data[i]);
        if (i!=size-1){
            res.append(',');
        }

    } res.append(']');
        return res.toString();
    }

}

泛型化

import java.util.Arrays;

public class Array<E> {
    private E[] data;
    private int size;


    public Array(){
        this(10);
    }
    public Array(int capacity){
        data = (E[]) new Object[capacity];
    }

    public int getCapacity(){
        return data.length;
    }

    public int getSize() {
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public void add(int index,E e){
        if (size ==data.length){
            throw new RuntimeException("array is full,add failed");
        }
        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        //移位
        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index] = e;
        size++;

    }
    public void addFirst(E e){
        add(0,e);
    }
    public void addLast(E e){
        add(size,e);
    }

    public E get(int index){
        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        return data[index];
    }
    public void set(int index,E e){
         data[index]=e;
    }
    public int find(E e){
        for(int i=0;i<size;i++){
            if (data[i]==e) return i;
        }
        return -1;
    }
    public boolean contain(E e){
        for (int i=0;i<size;i++){
            if (data[i]==e)return true;
        }
        return false;
    }
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new RuntimeException("remove failed ,require index>=0,and index<=size");

        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];}
            size--;
            return ret;


    }
    //从数据中删除第一个元素，返回删除的元素
    public E removeFirst(){
        return remove(0);
    }
    //删除最后一个元素，返回删除的元素
    public E removeLast(){
        return remove(size-1);
    }

    //从数据中删除某个元素e
    public void removeElement(E e){
        int index = find(e);
        if (index !=-1){
            remove(index);
        }

    }

    @Override
    public String toString() {
    StringBuilder res = new StringBuilder();
    res.append(String.format("Array: size =%d , capacity = %d\n" , size ,data.length));
    res.append('[');
    for (int i=0 ;i<size;i++){
        res.append(data[i]);
        if (i!=size-1){
            res.append(',');
        }

    } res.append(']');
        return res.toString();
    }

}

动态数组在这里插入图片描述动态扩容后的数组

import java.util.Arrays;
import java.util.Objects;

public class Array<E> {
    private E[] data;
    private int size;


    public Array(){
        this(10);
    }
    public Array(int capacity){
        data = (E[]) new Object[capacity];
    }

    public int getCapacity(){
        return data.length;
    }

    public int getSize() {
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public void add(int index,E e){

        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        if (size ==data.length){
            resize(data.length*2);
        }
        //移位
        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index] = e;
        size++;

    }
    private void resize(int newCapacity){
        E[] newData =(E[]) new Object[newCapacity];
        for (int i=0;i<size;i++){
            newData[i]=data[i];
        }
        data = newData;
    }

    public void addFirst(E e){
        add(0,e);
    }
    public void addLast(E e){
        add(size,e);
    }

    public E get(int index){
        if (index<0||index>size){
            throw new RuntimeException("add failed ,require index>=0,and index<=size");
        }
        return data[index];
    }
    public void set(int index,E e){
         data[index]=e;
    }
    public int find(E e){
        for(int i=0;i<size;i++){
            if (data[i]==e) return i;
        }
        return -1;
    }
    public boolean contain(E e){
        for (int i=0;i<size;i++){
            if (data[i]==e)return true;
        }
        return false;
    }
    //删除index位置元素
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new RuntimeException("remove failed ,require index>=0,and index<=size");

        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];}
            size--;
        if (size ==data.length/2){
            resize(data.length/2);
        }
            return ret;


    }
    //从数据中删除第一个元素，返回删除的元素
    public E removeFirst(){
        return remove(0);
    }
    //删除最后一个元素，返回删除的元素
    public E removeLast(){
        return remove(size-1);
    }

    //从数据中删除元素e
    public void removeElement(E e){
        int index = find(e);
        if (index !=-1){
            remove(index);
        }

    }

    @Override
    public String toString() {
    StringBuilder res = new StringBuilder();
    res.append(String.format("Array: size = %d , capacity = %d\n" , size ,data.length));
    res.append('[');
    for (int i=0 ;i<size;i++){
        res.append(data[i]);
        if (i!=size-1){
            res.append(',');
        }

    } res.append(']');
        return res.toString();
    }

}

运行封装的array
在这里插入图片描述

在这里插入图片描述
空间复杂度
两条原则：
1、数组的长度
如果你的代码里开了数组，那么数组的长度基本上就是你的空间复杂度
如果是一维数组，那么长度就是元素的个数，空间复杂度就是O(n)
如果是二维数组，数组的长度为n平方，那么空间复杂度就是n平方，O(n^2)
如果有递归，那递归的深度就是空间复杂度的最大值
如果又有递归又有数组，那两者之间的最大值就是你的空间复杂度
递归的深度