重生之我要学数据结构---动态数组

最新推荐文章于 2024-06-03 07:00:00 发布
最新推荐文章于 2024-06-03 07:00:00 发布
阅读量118 收藏
点赞数
文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/orange_ocean_/article/details/131969342
版权

动态数组

动态数组三姐妹：大小、容量、静态数组。

public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];
}

接下来就是熟悉的增删改查环节了。

添加

添加在哪加呢，尾部啦！

public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }
}

但是我现在不想在尾部添加，我想在哪加就在哪加。OK，满足！

public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }

        array[index] = addNum;
        size++;
    }
}

这里也可以用循环移位来实现。

查找

就直接上代码了。

public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }

        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }
}

遍历

接下来就是我们要封装遍历操作了。

方式1：普通方式

普通方式就是通过普通的循环遍历。

public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }

        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }
}
方式2：函数式接口—Consumer
public class DynamicArray {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }
        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

	// 遍历---函数式接口
    public void froeach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }
}

测试代码：

@Test
public void test2() {
    DynamicArray dynamicArray = new DynamicArray();

    dynamicArray.addLast(1);
    dynamicArray.addLast(2);
    dynamicArray.addLast(3);
    dynamicArray.addLast(4);
    dynamicArray.addLast(5);

    dynamicArray.froeach(element -> System.out.println(element));
}

这里的lambda表达式也可以用方法引用来替代哈~

方式3：迭代器

实现迭代器之前要先实现接口Iterable。
实现迭代器要重写两个方法：hasNext()、Next()。

public class DynamicArray implements Iterable<Integer> {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }
        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

	// 遍历---函数式接口
    public void froeach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

	// 遍历---迭代器
    public Iterator<Integer> iterator() {
        // 匿名实现类的匿名对象
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Integer next() {
                return array[i++];
            }
        };
    }
}
方式4：流
public class DynamicArray implements Iterable<Integer> {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }
        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

	// 遍历---函数式接口
    public void froeach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

	// 遍历---迭代器
    public Iterator<Integer> iterator() {
        // 匿名实现类的匿名对象
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Integer next() {
                return array[i++];
            }
        };
    }

	// 遍历---流实现
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));// [0,size)
    }
}

遍历方式大概是这几种方式。
接下来就是删除操作。

删除

public class DynamicArray implements Iterable<Integer> {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = new int[capacity];

	// 添加
	public void addLast(int addNum) {
        array[size++] = addNum;
    }

	    public void add(int addNum, int index) {// index---索引
        // 边界安全
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array,
                    index + 1, size - index);
        }
        array[index] = addNum;
        size++;
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

	// 遍历---函数式接口
    public void froeach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

	// 遍历---迭代器
    public Iterator<Integer> iterator() {
        // 匿名实现类的匿名对象
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Integer next() {
                return array[i++];
            }
        };
    }

	// 遍历---流实现
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));// [0,size)
    }

	// 删除
    public int remove(int index) {// 返回被删除的元素
        int removedNun = array[index];
        System.arraycopy(array, index + 1,
                array, index, size - index - 1);
        size--;
        return removedNun;
    }
}

基本操作已经结束了，现在我们再思考之前的添加操作。
既然是动态数组，扩容是必然的，所以我们的添加操作要考虑扩容。
并且可以对addLast方法进行发代码层面的优化，它可以调用add方法。
对于一开始我们就给我们的静态数组分配了空间，如果长时间不用，在内存中会长时间占据空间，因此可以参考设计模式中的懒汉式单例。

public class DynamicArray implements Iterable<Integer> {
    // 属性：大小、容量、静态数组
    private int size = 0;
    private int capacity = 8;
    private int[] array = {};// 类似懒汉式

	// 添加
	public void addLast(int addNum) {
        add(addNum, size);
    }

   	public void add(int addNum, int index) {
       	checkAndGrow();

       	// 添加逻辑
       	if (index >= 0 && index < size) {
           	// 向后挪动, 空出待插入位置
           	System.arraycopy(array, index,
                   	array, index + 1, size - index);
       	}
       	array[index] = addNum;
       	size++;
   	}

    private void checkAndGrow() {
        // 容量检查
        if (size == 0) {
            array = new int[capacity];
        } else if (size == capacity) {
            // 进行扩容, 扩为原来的1.5倍
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0,
                    newArray, 0, size);
            array = newArray;
        }
    }

	// 查找
    public int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        throw new RuntimeException("角标越界");
    }

	// 遍历---普通实现
    public void froeach() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

	// 遍历---函数式接口
    public void froeach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

	// 遍历---迭代器
    public Iterator<Integer> iterator() {
        // 匿名实现类的匿名对象
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Integer next() {
                return array[i++];
            }
        };
    }

	// 遍历---流实现
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));// [0,size)
    }

	// 删除
    public int remove(int index) {// 返回被删除的元素
        int removedNun = array[index];
        System.arraycopy(array, index + 1,
                array, index, size - index - 1);
        size--;
        return removedNun;
    }
}
Orange_Ocean_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构--串
m0_49767338的博客
04-14 194
1.串的定义 串（string）：由零个或多个字符组成的有限序列，又名叫字符串。 一般记为 s=“a1a2…an"，s是串的名称，用双引号括起来的是串的值，引号不属于串的内容。 空串：零个字符的串。 空格串：只包含空格的串。有长度，而且可以包含不止一个空格。 子串与主串：串中任意个数的连续字符组成的子序列称为该串的子串，相应地，包含该字串的串称为主串。 2.串的比较 给定两个串：s=“a1a2…an"，t=“b1b2…bn",当满足以下条件时，s<t。 1.n<m,且ai=bi（i，2，…,n)
tinyfugue:TinyFugue-重生
05-07
TinyFugue-重生 该项目旨在使TinyFugue MUD客户重生。 由于Ken Keys从6年开始就没有积极地开发它，所以在那段时间里我收集了很多方法，所以我决定将它们结合在一起。新的功能Lua支持新的远程登录选项- ATCP- GMCP- ...
重生之我要速成C++算法--stl库
weixin_72967725的博客
01-17 1139
C++算法速成基础之stl库
数据结构算法-动态规划算法
xiaov_sen的博客
10-25 115
space 空间定义啥数据结构？想一想他需要的是顺序并且方便于操作 链表：我？不，顺序表 ：我才对链表： 不好意思啊 抱歉 居然是用的是 顺序表 那么没啥好 焦虑的 直接一个循环就办到的事情所以没啥可焦虑的了首先记录 当然数组下标 space【0】=0；space【1】=1；space【2】=2；3 -制定一些策略 和方式达到求解问题的目的n=3也就是循环处理space的数据直到 循环变量i结束 这个怎么知道结束？或者说i=3 i
重生之我要精通JAVA--第一周笔记
2301_79977698的博客
04-21 1056
数据类型 变量名 = 数据值;String为字符串类型Java帮我们写好了一个类叫Scanner，这个类可以接收键盘输入的数字。​ project（项目）​ module（模块）​ package（包）​ class（类）格式一：数据类型 [ ] 数组名格式二：数据类型 数组名[ ]
重生之我是孔乙己——查找数组缺失元素的几种方法
陈大大陈的博客
04-10 1907
鬼才才能想出来的方法，果然是大道至简！时间复杂度是惊人的o(n),芜湖，最好使竟是最单纯的，感动了！
【2023年度总结】重生之我在CSDN写博客
wkd_007的博客
01-02 2470
总结了嵌入式的一些文章，包括嵌入式基础知识、C语言、音视频基础知识、数据结构、网络基础等
重生之我是一名程序员 17 ——数组与函数的结合使用例子
Stars的博客
10-31 107
各位公主少爷晚上好呀！今天给大家带来的知识分享是——数组与函数的配合使用
数据结构与算法-ADT-Array
weixin_30299709的博客
09-15 705
Array ADT 一维数组是连续元素的集合，其中的每个元素都可以通过唯一的整数下标来存取。数组的大小在创建后不能修改。 ADT 定义： Array(size): 创建一个长度为 size 的一维数组，并且将每个元素初始化成 None length(): 返回数组中的元素个数 getitem(index): 返回指定下标的元素 setitem(index, val...
重生之我是一名程序员 31 ——指针数组
Stars的博客
11-15 199
这里parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数 组中的元素。但需要注意上述的代码模拟出⼆维数组的效果，实际上并⾮完全是⼆维数组，因为每⼀⾏并⾮是连续的。在这我们可以类⽐⼀下其他类型的数组，比如整型数组是存放整型的数组，字符数组是存放字符的数组。通过对指针数组的操作，可以更方便地访问这些指针所指向的数据或对象，从而简化代码和提高程序的可读性和可维护性。前面给大家分享了指针与数组的知识，所以今天要给大家分享的知识是——指针数组。
dxx-rebirth：血统-重生和血统II-重生
02-04
重生团队花了很多时间通过修复旧错误和添加一些改进来改进源代码，同时始终忠实于我们的理念：保持不断下降！ DXX-Rebirth的目标是让Descent 1和2保持良好状态，为现代PC更新它们，同时又使它们保持您记得1995年玩...
rebirth-nativescript：重生nativescript版本
02-04
重生本语 链接 ##屏幕截图 主页 关于我 文章详细信息 联系我们 路线动画
重生Windows数据恢复技术极限剖析---马林.pdf
02-22
重生Windows数据恢复技术极限剖析---马林.pdf
行业分类-设备装置-半潜式起重生活平台的支撑结构.zip
08-22
行业分类-设备装置-半潜式起重生活平台的支撑结构.zip
【数据结构】链式二叉树详解
最新发布
s_little_monster的博客
06-03 2655
链式二叉树的实现
线性数据结构-数组
passworddddddd的博客
05-31 226
因为数组定长，当想往长度为8的数组中添加第九个元素时，操作系统会开辟一段长度为16的新的空间（操作系统会开辟一些提前量，多划一些空间），然后将旧数组的八个元素复制到新的数组中，并将新添加的元素，添加到新数组的第九个位置上，并且销毁就数组。1、因为空间必须是连续的，如果数组比较大，当系统的空间碎片较多时，容易存不下。在长度8的数组中删除第5个元素，不改变数组长度，从第六个元素开始向左移动一个单元，即数组删除。2、因为数组长度是固定，所以数组的内容难以被添加和删除。3、数组的变量指向了数组第一个元素的位置。
C语言.数据结构.单链表
Joseit的博客
05-31 778
C语言数据结构单链表技术博客文章摘要 本文深入探讨了C语言中的数据结构——单链表。首先，文章介绍了链表的概念及结构，强调了链表作为一种物理存储结构上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。通过将链表与火车车厢的类比，形象地展示了链表节点之间的独立性和链接关系。 接着，文章详细阐述了单链表的实现方法，包括定义链表节点结构体、实现基本的链表操作（如头部插入、删除、尾部插入、删除、查找、在指定位置插入/删除节点等），以及链表的销毁等功能。
软设之希尔排序
2301_81968528的博客
05-30 285
假设有n个元素，先取一个小于n的整数d1作为一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组中进行直接插入排序;然后，取第二个增量d2
c语言如何动态创建数组
09-24
在C语言中，我们可以使用动态内存分配函数malloc来创建动态数组。动态数组的大小可以在运行时确定，而不是在编译时确定。下面是创建动态数组的一般步骤： 1. 使用malloc函数分配内存空间。malloc函数的声明如下： `void* malloc(size_t size);` 这里的size是需要分配的内存大小，以字节为单位。 2. 强制类型转换为所需的数组类型。例如，如果我们想要创建一个整数类型的动态数组，可以使用如下语法： `int* array = (int*)malloc(size * sizeof(int));` 这里的size是数组的大小。 3. 使用动态数组进行操作。 4. 使用free函数释放内存空间。释放内存空间可以防止内存泄漏。free函数的声明如下： `void free(void* ptr);` 这里的ptr是指向先前分配的内存区域的指针。 下面是一个示例代码，展示了如何动态创建一个整数类型的数组： ```c #include <stdio.h> #include <stdlib.h> int main() { int size; printf("Enter the size of the array: "); scanf("%d", &size); int* array = (int*)malloc(size * sizeof(int)); if (array == NULL) { printf("Memory allocation failed.\n"); return -1; } printf("Enter elements of the array:\n"); for (int i = 0; i < size; i++) { scanf("%d", &array[i]); } printf("Elements of the array are: "); for (int i = 0; i < size; i++) { printf("%d ", array[i]); } printf("\n"); free(array); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值