数据结构之数组

最新推荐文章于 2024-10-12 13:59:20 发布
最新推荐文章于 2024-10-12 13:59:20 发布
阅读量91 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ggbondd/article/details/114648142
版权

image-20210310162612441

1.只能存放int的自定义数组类

public class Array {
    private int[] data;
    private int size;//data[size]指向数组中第一个没有数据的位置
    //传入数组的容量capacity构造Array
    public Array(int capacity){
        data=new int[capacity];
        size=0;
    }
    //无参构造，默认数组capacity为10
    public Array(){
        data=new int[10];
        size=0;
    }
    //获取数组已有长度
    public int getSize(){
        return size;
    }
    //获取数组容量
    public int getCapacity(){
        return data.length;
    }
    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //向数组尾部添加数据
    public void addLast(int e){
        add(size,e);
    }
    //向数组头添加数据
    public void addFirst(int e){
        add(0,e);
    }
    //向数组中任意一个位置添加数据
    public void add(int index,int e){
        if(data.length==size)
            throw new IllegalArgumentException("array is full");
        if(index<0||index>size)
            throw new IllegalArgumentException("array is full");
        for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }
    //获取某个索引元素
    public int get(int index,int e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        return data[index];
    }
    //设置某个索引位置元素
    public void set(int index,int e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        data[index]=e;
    }
    //判断数组是否包含某个元素
    public boolean contains(int e){
        for(int i=0;i<size;i++){
            if(data[i]==e)
                return true;
        }
        return false;
    }
    //查找某个元素并返回索引，不存在则返回-1
    public int find(int e){
        for(int i=0;i<size;i++){
            if(data[i]==e)
                return i;
        }
        return -1;
    }
    //删除索引位置元素并返回被删元素值
    public int remove(int index){
        int tem=data[index];
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        for(int i=index+1;i<size;i++)
            data[i-1]=data[i];
        size--;
        return tem;
    }
    //删除指定数值的元素
    public void removeElement(int e){
        int index = find(e);
        if(index!=-1)
            remove(index);
    }

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

2.泛型化数组

public class Array<E> {
    private E[] data;
    private int size;//data[size]指向数组中第一个没有数据的位置
    //传入数组的容量capacity构造Array
    public Array(int capacity){
        //data=new E[capacity];这样子new不对
        data=(E[]) new Object[capacity];
        size=0;
    }
    //无参构造，默认数组capacity为10
    public Array(){
        //data=new E[10];
        data= (E[]) new Object[10];
        size=0;
    }
    //获取数组已有长度
    public int getSize(){
        return size;
    }
    //获取数组容量
    public int getCapacity(){
        return data.length;
    }
    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //向数组尾部添加数据
    public void addLast(E e){
        add(size,e);
    }
    //向数组头添加数据
    public void addFirst(E e){
        add(0,e);
    }
    //向数组中任意一个位置添加数据
    public void add(int index,E e){
        if(data.length==size)
            throw new IllegalArgumentException("array is full");
        if(index<0||index>size)
            throw new IllegalArgumentException("array is full");
        for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }
    //获取某个索引元素
    public E get(int index,E e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        return data[index];
    }
    //设置某个索引位置元素
    public void set(int index,E e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        data[index]=e;
    }
    //判断数组是否包含某个元素
    public boolean contains(E e){
        for(int i=0;i<size;i++){
            //if(data[i]==e)
            //==为引用比较
            //equals为值比较，对于对象来说，进行值比较
            if (data[i].equals(e))
                return true;
        }
        return false;
    }
    //查找某个元素并返回索引，不存在则返回-1
    public int find(E e){
        for(int i=0;i<size;i++){
            //if(data[i]==e)
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }
    //删除索引位置元素并返回被删元素值
    public E remove(int index){
        E tem=data[index];
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        for(int i=index+1;i<size;i++)
            data[i-1]=data[i];
        size--;
        return tem;
    }
    //删除指定数值的元素
    public void removeElement(E e){
        int index = find(e);
        if(index!=-1)
            remove(index);
    }

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

3.动态数组

   //当数组满时进行扩容
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];
        for (int i=0;i<size;i++)
            newData[i]=data[i];
        data=newData;
    }

		//当元素减少到一半时，进行缩容
        if (size== data.length/2)
            resize(data.length/2);
		//当数组满了，进行扩容
        if(data.length==size)
            resize(2*data.length);
		

public class Array<E> {
    private E[] data;
    private int size;//data[size]指向数组中第一个没有数据的位置
    //传入数组的容量capacity构造Array
    public Array(int capacity){
        //data=new E[capacity];这样子new不对
        data=(E[]) new Object[capacity];
        size=0;
    }
    //无参构造，默认数组capacity为10
    public Array(){
        //data=new E[10];
        data= (E[]) new Object[10];
        size=0;
    }
    //获取数组已有长度
    public int getSize(){
        return size;
    }
    //获取数组容量
    public int getCapacity(){
        return data.length;
    }
    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //向数组尾部添加数据
    public void addLast(E e){
        add(size,e);
    }
    //向数组头添加数据
    public void addFirst(E e){
        add(0,e);
    }
    //向数组中任意一个位置添加数据
    public void add(int index,E e){
        if(index<0||index>size)
            throw new IllegalArgumentException("error");
        //当数组满了，进行扩容
        if(data.length==size)
            resize(2*data.length);
        for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }
    //获取某个索引元素
    public E get(int index,E e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        return data[index];
    }
    //设置某个索引位置元素
    public void set(int index,E e){
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        data[index]=e;
    }
    //判断数组是否包含某个元素
    public boolean contains(E e){
        for(int i=0;i<size;i++){
            //if(data[i]==e)
            //==为引用比较
            //equals为值比较，对于对象来说，进行值比较
            if (data[i].equals(e))
                return true;
        }
        return false;
    }
    //查找某个元素并返回索引，不存在则返回-1
    public int find(E e){
        for(int i=0;i<size;i++){
            //if(data[i]==e)
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }
    //删除索引位置元素并返回被删元素值
    public E remove(int index){
        E tem=data[index];
        if(index<0||index>=size)
            throw new IllegalArgumentException("index error");
        for(int i=index+1;i<size;i++)
            data[i-1]=data[i];
        size--;

        //当元素减少到一半时，进行缩容
        if (size== data.length/2)
            resize(data.length/2);
        return tem;
    }
    //删除指定数值的元素
    public void removeElement(E e){
        int index = find(e);
        if(index!=-1)
            remove(index);
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size=%d capacity=%d\n", size,data.length));
        sb.append("[");
        for(int i=0;i<size;i++){
            sb.append(data[i]);
            if(i!=size-1)
                sb.append(", ");
        }
        sb.append("]");
        return sb.toString();
    }
   //当数组满时进行扩容
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];
        for (int i=0;i<size;i++)
            newData[i]=data[i];
        data=newData;
    }
}

image-20210310215156149

均摊复杂度

resize()并不是每次add都会触发，可以将其均摊到add步骤上

复杂度震荡
		//当元素减少到一半时，进行缩容
        if (size== data.length/2)
            resize(data.length/2);
		//当数组满了，进行扩容
        if(data.length==size)
            resize(2*data.length);

当数组中的数据一直在data.length/2附近波动，会产生复杂度震荡，操作过于激进，可以使用相对lazy的策略

		//当元素减少到1/4时，进行缩容
        if (size== data.length/4 && data.length/2!=0)
            resize(data.length/2);
DominusNoob
关注
专栏目录
数组--王争数据结构与算法学习笔记
wxl
01-17 557
数组看起来简单基础，但是很多人没有理解这个数据结构的精髓。数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。数组在逻辑上是一种线性表数据结构. 数组在物理上是一种顺序的存储结构。 数组定义的关键词: 1.连续的内存空间 2.相同类型的数据. 线性表: 数据排成像一条线一样的结构.每个线性表上的数据最多只有前和后两个方向. 非线性表: 数据之间并不是简单的前后关系. 线性表数据结构包括: 数组,链表,队列,栈. 非线性表数据结构包括: 二叉树,堆,图 。 1.数.
java array 用法_关于JAVA 数组的使用介绍
weixin_29088655的博客
02-16 545
本篇文章小编将为大家介绍，关于JAVA 数组的使用介绍，有需要的朋友可以参考一下JAVA数组与容器类主要有三方面的区别：效率、类型和保存基本类型的能力。在JAVA中，数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性数列，这使得元素访问非常快速。但是为此付出的代价却是数组的大小被固定，并且在其生命周期中不可改变。由于范型和自动包装机制的出现，容器已经可以与数组几乎一样方便...
数据结构之数组和列表
swadian2008的博客
04-08 1816
数组是用于储存多个数据的集合，可以通过来访问数组中具体的元素。但是因为数组在连续的，所以数组在程序中使用起来就具有局限性。数组最大的优势就是可以，在数组中，每个数据(仅表示位置，没有业务逻辑语义，比如不适合表示学号，身份证号等)，因此，往往在实际开发中，不直接使用数组，而是，比如 Java 中的 ArrayList。
数据结构 数组
weixin_65951505的博客
01-16 2434
数据结构 数组
数据结构之数组与广义表
L*YUE的博客
01-27 5402
目录联系数组广义表 联系 数组和广义表可看作一种扩展的线性数据结构，其特殊性在于数据元素的构成上。从组成线性表的元素角度看，数组是由具有某种结构的数据元素构成，广义表则是由单个元素或子表构成的。数组和广义表是线性表的推广。 数组 1.数组的定义 从逻辑结构上，数组可以看成是对一般线性表的扩充。一维数组即为线性表，而二维数组可以定义为其数据元素为一维数组（线性表）的线性表。以此类推，N维数组是数据元...
数据结构--数组（详细分析）
考研小钻风
06-02 1584
数组作为一种固定大小且内存连续的线性数据结构，提供了高效的随机访问能力。
数据结构之数组——每日一练
weixin_42368982的博客
04-15 2536
数组专项训练 数组元素的地址计算与数组的存储方式无关。请问这句话的说法是正确的吗？ 错误。 以下叙述正确的是？（B） A. 线性表的顺序存储结构优于链表存储结构。 B. 二维数组是其数据元素为线性表的线性表。 C. 栈的操作方式是先进先出。 D. 队列的操作方式是先进后出。 解析： A. 顺序存储优点：存储密度大（=1），存储空间利用率高。 顺序存储缺点：插入或删除元素不方便。 链式存储优点：插入或删除元素效率高，方便、灵活。 链式存储缺点：存储密度小（<1），存储空间利用率低。 B. 二维数组
数据结构-数组存储结构
有朋自远方来，不亦乐乎。
08-14 1992
2、数组和其他线性存储结构不同，顺序表、链表、栈和队列存储的都是不可再分的数据元素（如数字 5、字符 'a' 等），而数组既可以用来存储不可再分的数据元素，也可以用来存储像顺序表、链表这样的数据结构。我们知道，顺序表的底层实现还是数组，因此等价于数组中继续存储数组。由此，我们可以得出这样一个结论，一维数组结构是线性表的基本表现形式，而 n 维数组可理解为是对线性存储结构的一种扩展。以此类推，n 维数组，指的是存储 n-1 维数组的一维数组。注意，无论数组的维数是多少，数组中的数据类型都必须一致。...
Tcl数据结构之数组
荣耀之路
05-12 3777
数组、多维数组
数据结构之数组翻转的实现方法
08-29
"数据结构之数组翻转的实现方法" 数据结构之数组翻转是一种常见的数据结构操作，指的是将数组中的元素翻转顺序，以便实现某些特定的算法或数据处理需求。以下我们将通过多种编程语言的实现方式来展示数组翻转的实现...
数据结构之数组和广义表教程2.zip
01-02
在这个"数据结构之数组和广义表教程2.zip"中，我们将深入探讨这两个主题。 首先，数组是最基础的数据结构之一，它是由相同类型元素的集合组成，这些元素通过一个唯一的索引来访问。数组的特点是随机访问高效，因为...
JavaScript数据结构之数组的表示方法示例
10-20
在JavaScript中，数组是一种重要的数据结构，它允许我们存储一组有序的数据。数组的表示方法是基于数据结构理论的线性表概念，线性表是一种基本的一维数据结构，其中元素按照特定顺序排列。在JavaScript中，数组具有...
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 284
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
Java：数据结构-ArrayList和顺序表（2）
blamep的博客
10-09 704
创建一个空的ArrayList，指定容量为initialCapacity。
数据结构编程实践20讲(Python版)—09B树
最新发布
AnFany
10-12 706
数据结构编程实践20讲(Python版)—09B树
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 539
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
【关系模型】关系数据结构、基本关系代数运算
lin_miao_2023的博客
10-07 751
昨天补充了DBMS概况的存储管理层面，今天来详细介绍数据库管理系统中常见且应用广泛的关系型数据库（简称关系数据库），比如postgreSQL、MySQL、Oracle Database。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值