线性表02_动态数组

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

1.动态数组底层存储结构

private E[] elements;
//默认的数组容量大小
private static final int DEFAULT_CAPACITY = 10;

2.动态数组接口设计

int size(); // 元素的数量
boolean isEmpty(); // 是否为空
boolean contains (E element); // 是否包含某个元素
void add (E element); // 添加元素到最后面
E get (int index); // 返回index位置对应的元素
E set (int index, E element); // 设置index位置的元素
void add (int index, E element); // 往index位置添加元素
E remove (int index); // 删除index位置对应的元素
int indexOf (E element); // 查看元素的位置
void clear (); // 清除所有元素

3.添加元素

add(E element) 默认往数组最后添加元素；
在这里插入图片描述
add(int index, E element) 在index位置插入一个元素；
在这里插入图片描述
插入的时候，需要移动>=index 的所有元素；
移动方式：先挪动最后一个元素，最后挪index

size -1 ->  size
size - 2 -> size -1
...
index -> index + 1

接口实现

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacity(size);

        for(int i = size;i>index;i--){
            elements[i] = elements[i-1];
        }
        elements[index] = element;
        size++;
    }
    
    public void add(E element){
		add(size, element);
	}

4.删除元素

删除元素涉及2个接口：
E remove (int index);
void clear ();
扩展接口i：E remove(E element) 涉及元素查询

删除元素的内存释放

1.数组存放基本数据类型
当index之后的元素向前挪动后，只进行size–，最后一个元素已经无法访问了，由于存放的是直接数据，因此清理最后一个元素的数据没有意义；数组占用内存不会改变。

2.如果使用泛型数组
需要将元素置 null，因为数组中存储的是对象地址，当该元素被删除，应该将该元素的引用置为null，这样堆内存中的对象失去引用后，会被JVM回收，从而节省内存。

remove(int index)

在这里插入图片描述
从前往后开始移动，用后面的元素覆盖前面的元素

接口实现

public E remove(int index) {
        rangeCheck(index);
        E oldElement = get(index);
        for(int i =index;i < size-1;i++){
            elements[i] = elements[i+1];
        }
        elements[size-1] = null;
        size --;
        return oldElement;
    }

    public void clear() {

        for(int i = 0;i<size;i++){
            elements[i] = null;
        }
        size=0;
    }

5.查询元素

查询元素涉及的4个接口
boolean contains (E element); // 是否包含某个元素
E get (int index);// 返回index位置对应的元素
E set (int index, E element);// 设置index位置的元素
int indexOf (E element);// 查看元素的位置
两种查询方式

1.根据索引index查询
2.直接查询某个元素

接口实现
（1）根据index查询

    @Override
    public E get(int index) {
        rangeCheck(index);
        return elements[index];
    }

    @Override
    public E set(int index, E element) {
        rangeCheck(index);
        E old = elements[index];
        elements[index] = element;
        return old;
    }

（2）根据元素值查询
关于 null 的处理主要看你的业务需求：是否可以存储 null 数据？

    public int indexOf(E element) {
        if(element == null){
            for(int i=0;i < size;i++){
                if(elements[i] == null){
                    return i;
                }
            }
        }else{
                for (int i = 0; i < size; i++) {
                    if(elements[i].equals(element)) return i;
                }
        }
        return ELEMENT_NOT_FOUND;
    }


    public boolean contains (E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

到此，除了两个基本接口，动态数组的接口都实现了;

6.动态扩容

原理：
在这里插入图片描述
代码实现：

private void ensureCapacity(int size){
        if(size == 0){
            elements = (E[])new Object[DEFAULT_CAPACITY];
        }
        if(size == elements.length){
            int oldCapacity = size;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            E[] newElements = (E[]) new Object[newCapacity];

            for(int i = 0;i<size;i++){
                newElements[i] = elements[i];
            }
            elements = newElements;
        }
    }

一旦扩容，涉及整个数组的copy过程，其时间复杂度为O(n)

复杂度震荡问题

在动态数组中有扩容和缩容机制的话，如果扩容 n 倍，缩容 也是n倍，就会出现复杂度震荡问题。
比如：扩容2倍，缩容2倍
size=10的时候，再添加一个元素，就会进行扩容到20
size=11的时候，再删除一个元素，就会进行缩容到10
也就是说在size=10这个地方会发生复杂度震荡
所以一般设计的时候，缩容和扩容倍数不要一致

7. int型数组源码

public class ArrayList {
	private int size;		// 元素数量	
	private int[] elements; // 所有的元素

	private static final int DEFAULT_CAPACITY = 10; // 初始容量
	private static final int ELEMENT_NOT_FOUND = -1;
	
	public ArrayList(int capacity) { // 容量小于10一律扩充为10
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		elements = new int[capacity];
	}
	public ArrayList(){
		this(DEFAULT_CAPACITY);
	}
	/**
	 * 元素的数量
	 * @return
	 */
	public int size(){
		return size;
	}
	/**
	 * 是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	public boolean contains(int element){
		return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True
	}
	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	public void add(int index, int element){
		rangeCheckForAdd(index); // 检查下标越界
		ensureCapacity(size + 1); // 确保容量够大
		
		// 0 1 2 3 4 5 6 7 8 9	(index)
		// 1 2 3 4 5 6 x x x x	(原数组)
		// 在index=2处，插入9，元素全部后移
		// 1 2 9 3 4 5 6 x x x	(add后数组)
		// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
		for (int i = size - 1; i > index; i--) {
			elements[i + 1] = elements[i];
		}
		elements[index] = element; // 赋值
		size++;
	}
	/**
	 * 添加元素到最后面
	 */
	public void add(int element){
		add(size, element);
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public int get(int index){
		rangeCheck(index);
		return elements[index];
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public int set(int index, int element){
		rangeCheck(index);
		int old = elements[index];
		elements[index] = element;
		return old;
	}
	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	public int remove(int index){
		rangeCheck(index);
		
		// 0 1 2 3 4 5 	(index)
		// 1 2 3 4 5 6 	(原数组)
		// 删除index为2的元素，元素前移
		// 1 2 4 5 6	(remove后的数组)
		int old = elements[index];
		// 从前往后开始移, 用后面的元素覆盖前面的元素
		for (int i = index; i < size-1; i++) {
			elements[i] = elements[i + 1];
		}
		size--;
		return old;
	}
	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	public int indexOf(int element){
		for (int i = 0; i < size; i++) {
			if(elements[i] == element) return i;
		}
		return ELEMENT_NOT_FOUND;
	}
	/**
	 * 清除所有元素
	 */
	public void clear(){
		size = 0;
	}
	/*
	 * 扩容操作
	 */
	private void ensureCapacity(int capacity){
		int oldCapacity = elements.length;
		if(oldCapacity >= capacity) return;
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5
		int[] newElements = new int[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i];
		}
		elements = newElements;
		System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
	}
	/****************封装好的功能函数*******************************/
	// 下标越界抛出的异常
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	private void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加)
	private void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	
	@Override
	public String toString() {
		// 打印形式为: size=5, [99, 88, 77, 66, 55]
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(0 != i) string.append(", ");
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
}

8. 泛型数组源码

@SuppressWarnings("unchecked")
public class ArrayList<E> {
	private int size;		// 元素的数量	
	private E[] elements; 	// 所有的元素

	private static final int DEFAULT_CAPACITY = 10; // 初始容量
	private static final int ELEMENT_NOT_FOUND = -1;
	
	public ArrayList(int capacity) { // 容量小于10一律扩充为10
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		elements = (E[])new Object[capacity];
	}
	public ArrayList(){
		this(DEFAULT_CAPACITY);
	}
	/**
	 * 元素的数量
	 * @return
	 */
	public int size(){
		return size;
	}
	/**
	 * 是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	public boolean contains(E element){
		return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True
	}
	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	public void add(int index, E element){ 
		rangeCheckForAdd(index); // 检查下标越界
		ensureCapacity(size + 1); // 确保容量够大
		
		// 0 1 2 3 4 5 6 7 8 9	(index)
		// 1 2 3 4 5 6 x x x x	(原数组)
		// 在index=2处，插入9，元素全部后移
		// 1 2 9 3 4 5 6 x x x	(add后数组)
		// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
		for (int i = size - 1; i > index; i--) {
			elements[i + 1] = elements[i];
		}
		elements[index] = element; // 复制
		size++;
	}
	/**
	 * 添加元素到最后面
	 */
	public void add(E element){
		add(size, element);
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public E get(int index){
		rangeCheck(index);
		return elements[index];
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public E set(int index, E element){
		rangeCheck(index);
		E old = elements[index];
		elements[index] = element;
		return old;
	}
	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	public E remove(int index){
		rangeCheck(index);
		// 0 1 2 3 4 5 	(index)
		// 1 2 3 4 5 6 	(原数组)
		// 删除index为2的元素，元素前移
		// 1 2 4 5 6	(remove后的数组)
		// 从前往后开始移, 用后面的元素覆盖前面的元素
		E old = elements[index];
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		elements[--size] = null; // 删除元素后, 将最后一位设置为null
		return old;
	}
	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	public int indexOf(E element){
		/*
		// 不对 null 进行处理也可以，但是健壮性不够
		for (int i = 0; i < size; i++) {
			if(elements[i].equals(element)) return i;
		}
		 */
		if(element == null){ // 对 null 进行处理
			for (int i = 0; i < size; i++) {
				if(elements[i] == null) return i;
			}
		}else{
			for (int i = 0; i < size; i++) {
				if(elements[i].equals(element)) return i;
			}
		}
		return ELEMENT_NOT_FOUND;
	}
	/**
	 * 清除所有元素
	 */
	public void clear(){
		// 使用泛型数组后要注意内存管理(将元素置null)
		for (int i = 0; i < size; i++) {
			elements[i] = null;
		}
		size = 0;
	}
	/**
	 * 扩容操作
	 */
	private void ensureCapacity(int capacity){
		int oldCapacity = elements.length;
		if(oldCapacity >= capacity) return;
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E[] newElements = (E[])new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i]; // 拷贝原数组元素到新数组
		}
		elements = newElements;
		System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
	}
	/****************封装好的功能函数**************************/
	// 下标越界抛出的异常
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	private void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	private void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	/****************封装好的功能函数***************************/
	@Override
	public String toString() {
		// 打印形式为: size=5, [99, 88, 77, 66, 55]
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(0 != i) string.append(", ");
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
}
败给你的黑色幽默丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表_线性表_
10-03
1. **数组实现**：在C语言中，线性表通常用一维数组来实现。数组的下标从0开始，便于表示元素之间的前后关系。 2. **插入操作**：在线性表的末尾插入元素相对简单，只需要将新元素放到数组末尾即可；在中间插入则...
ch2-线性表_线性表_
10-03
1. 顺序存储：在线性表的顺序存储结构中，元素在内存中是连续存放的，通常用数组来实现。这种方式查询速度快，但插入和删除操作可能涉及大量元素的移动。 2. 链式存储：链式存储则通过链表实现，每个元素（节点）...
动态数组----线性表的实现
NancyLCL的博客
01-10 233
Java数组的特点： 1>. 数组的长度一旦确定则不可更改 2>. 数组只能存储同一类型的数据 3>. 数组中每个存储空间地址是连续且相等的 4>. 数组提供角标的方式访问元素 Java数组的缺点： 1>. 长度不可变，如果容量不够只能扩容，而扩容实质是创建新的数组 ...
PTA 6-4 查找元素(*)
wcd278212784的博客
03-31 2050
6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下： typedef struct { int size, length; int *element; } ALIST; 说明：element 为存储数据元素的动态数组的起始地址，size 为动态数组的尺寸，length 为顺序表的长度。 请编写函数，在顺序表中查找数据元素。 函数原型 int AListFind(const ALIST *list, int element); 说明：参数 list 为指示线性表(顺序表)的指针，element 为待
动态数组实现顺序表
m0_61925333的博客
04-19 742
Java数据结构入门，使用动态数组实现顺序表
c++ 构造函数数组_“动态数组”的设计与实现
weixin_39765697的博客
11-24 1496
引言数据结构是计算机存储、组织数据的方式。常见的数据结构有：(1)线性结构如：线性表(包括：数组、链表、栈、队列、哈希表)。(2)树形结构如：二叉树、AVL树、红黑树、B树、堆、Trie、哈夫曼树、并查集。(3)图形结构如：邻接矩阵、邻接表。注：在实际应用中，要根据使用场景选择最合适的数据结构。线性表(1)线性表是具有n(n>=0)个相同类型元素的有限序列。 如下图所示：每个元素都...
书面作业： 第三章 栈与队列
Self-den1al的博客
11-18 6268
判断 1-1 n个元素通过一个栈产生n个元素的出栈序列，其中进栈和出栈操作的次数总是相等的。 1-2 通过对堆栈S操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为：123。 1-3 若采用“队首指针和队尾指针的值相等”作为环形队列为空的标志，则在设置一个空队时只需将队首指针和队尾指针赋同一个值，不管什么值都可以。 1-4 顺序栈中元素值的大小是有序的。 1-5 环形队列中有多少个元素可以根据队首指针和队尾指针的值来计算 1-6
数据结构 (二) 线性表_动态数组
Fioman_GYM的博客
04-21 267
文章目录一. 线性表的基本概念二. 线性表的顺序存储① 线性表顺序存储基本概念② 线性表顺序存储的设计和实现 一. 线性表的基本概念 线性表是零个或者多个数据元素的有限序列 特性: 数据元素之间是有顺序的 数据元素个数是有限的 数据元素的类型必须相同 数学定义: 线性表是具有相同类型的n(>=0)个数据元素的有限序列(a0,a1,a2,…,an). ai是表项,n是表长度 性质: a0 为线性表的第一个元素,只有一个后继 an 为线性表的最后一个元素,只有一个前驱 除了a0和an外
线性表与数组的根本区别_线性表和数组的区别
weixin_39631467的博客
12-19 778
数组数组就是相同数据类型的元素按一定顺序排列的集合。本质：物理上存储在一组联系的地址上，也就是数据结构中的顺序存储物理结构。数组分为静态数组和动态数组，在定义数组时，首先要确定数组的大小。静态数组在编译时就需要确定数组的大小，所以，为了防止内存溢出，我们尽量将数组定义的大一些，但是这样太过浪费内存。动态数组则不同，它不需要在编译时就确定大小，它的大小在程序运行过程中确定，所以可以根据程序需要而灵活...
12.zip_清除线性表_清除线性表L_顺序表
07-14
线性表可以是顺序表或链表等形式，而在这个例子中，由于提到了“顺序表”，我们可以推断出L是一个基于数组实现的线性表，即顺序存储结构。 顺序表是一种物理存储单元上连续的数据结构，它的特点是可以通过下标直接...
《数据结构与算法》课程上机实验一（线性表）_C++_数据结构与算法_线性表_
10-03
线性表是由n（n>=0）个相同类型元素构成的有限序列，其顺序存储结构通常使用一维数组来实现。 线性表的顺序存储结构是指在内存中连续分配一块空间，用于存放线性表的所有元素。这种存储方式的优点在于访问效率高，...
实验课.zip_C++_createvvc_多维数组_数据结构
07-15
"实验课.zip"中的内容专注于C++编程语言，特别是涉及到创建虚拟机（createvvc）以及处理多维数组的数据结构。这些文件可能包含了一系列的实验，旨在帮助学习者深入理解和实践这些概念。 首先，我们要讨论的是C++。...
PTA-队列练习题
ZYQ_37210462的博客
10-31 4709
选择题 2-1在少用一个元素空间的循环队列(m为最大队列长度)是满队列的条件（ ）。 A.rear== front B.(rear+1)%m==front C.(rear+1) == front D.front ==(front+1)%m 2-2循环队列存储在数组A[0…n-1]中，其头尾指针分别为f和r，头指针f总是指向队头元素，尾指针r总是指向队尾元素的下一个位置，假设队列不空，元素出队时头尾指针的操作为（ ）。 A.f=(f+1)%n B.f=f+1 C.r=(r+1)%n D.f=(f+1)%(n
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1209
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 800
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 275
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2166
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1354
Java实现拼图小游戏
数组与线性表的推广——数组与广义表存储结构解析
然而，这也导致了数组在动态调整大小方面的局限性。当需要处理稀疏矩阵（大部分元素为零的矩阵）或广义表（可以包含子表的数据结构）时，通常会采用特殊的压缩存储方法来节省空间，例如链式存储或使用三元组表示法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值