数据结构动态数组

最新推荐文章于 2023-02-26 16:14:10 发布
最新推荐文章于 2023-02-26 16:14:10 发布
阅读量265 收藏
点赞数
分类专栏： Java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40354578/article/details/90473564
版权

我们对数组进行改造的原理如下：重新建立一个capacity更大的数组，通过for循环让原来数组的数据复制到新的数组里，再让我们原来的数组指向newdate

这样我们的date和newdate指向的同一个空间，我们会把这样一个过程封装在函数里，newdate会在执行完后被回收

package www.zxx;

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

	//带参构造函数
	public Array(int capacity) {
		//不支持new一个泛型数组
		//先建立一个object类再进行强转
		data = (E[])new Object[capacity];
		size = 0;
	}

	//无参构造函数输入的数据实际上是capacity的值
	public Array() {
		this(10);
	}

	//获得数组的size
	public int getSize() {
		return size;
	}

	//获得数组的容量
	public int getCapacity() {
		return data.length;
	}

	//通过已经写好的add函数写一个在开头添加e值的函数
    //好处是add函数已经处理过index数值的溢出问题
	public void addFirst(E e) {
		add(0, e);
	}

	//通过已经写好的add函数写一个在末尾添加e值的函数
	//好处是add函数已经处理过index数值的溢出问题
	public void addLast(E e) {
		add(size, e);
	}

	//在index位置加入e数值的数
	//要进行index数值的输入控制
	public void add(int index, E e) {
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("Add failed,Index beyond brode");
		}
		if (size == data.length) {
			resize(2*data.length);
		}
		for (int i = size - 1; i >= index; i--) {
			data[i + 1] = data[i];
		}
		data[index] = e;
		size++;
	}

	//判断e数值在不在数组内
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i].equals(e))
				return true;
		}
		return false;
	}

	//找数组中为e数值的位置，如果没有输出-1
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			//值比较
			if (data[i].equals(e))
				return i;
		}
		return -1;
	}

	@Override
	//重写tostring方法让System.out.println（）能直接输出我们指定的类型
	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(',');
			} else {
				res.append(']');
			}
		}
		return res.toString();

	}

	// 获得index位置的数
	E get(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		return data[index];
	}

	// 设置index位置的数为e
	void set(int index, E e) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		data[index] = e;
	}

	//删除index位置的元素
	//返回删除的元素
	E remove(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		E rec = data[index];
		for(int i = index ; i < size ;i++) {
			data[i] = data[i+1];
		}
		//我们的int类型的数组size指向的值不需要被删除，因为我们在后面插入的时候能覆盖
		//在泛型中我们使用的是类对象，我们应该删除它
		size--;
		//loitering objects!=memory leak(内存泄漏)
		data[size]=null;
		return rec;
	}
	
	//删除第一个元素
	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);
		}
	}
	
	//扩容
	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 static void main(String[] args) {
		Array<Integer> arr = new Array<Integer>();
		
		for (int i = 0; i < 10; i++) {
			arr.addLast(i);
		}
		System.out.println(arr);

		arr.add(1, 100);
		System.out.println(arr);

		arr.addFirst(-1);
		System.out.println(arr);
		
		arr.remove(0);
		System.out.println(arr);
		
		arr.removeElement(0);
		System.out.println(arr);
	}
}

 

在这里我们选择扩容的时候选择的是2*capacity

从结果中我们可以看到在我们add的时候超出了原来的capacity我们在add函数里进入到条件size==data.length进行了两倍扩容操作

上面的是扩容，相应的我们应该有减少容量

package www.zxx;

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

	//带参构造函数
	public Array(int capacity) {
		//不支持new一个泛型数组
		//先建立一个object类再进行强转
		data = (E[])new Object[capacity];
		size = 0;
	}

	//无参构造函数输入的数据实际上是capacity的值
	public Array() {
		this(10);
	}

	//获得数组的size
	public int getSize() {
		return size;
	}

	//获得数组的容量
	public int getCapacity() {
		return data.length;
	}

	//通过已经写好的add函数写一个在开头添加e值的函数
    //好处是add函数已经处理过index数值的溢出问题
	public void addFirst(E e) {
		add(0, e);
	}

	//通过已经写好的add函数写一个在末尾添加e值的函数
	//好处是add函数已经处理过index数值的溢出问题
	public void addLast(E e) {
		add(size, e);
	}

	//在index位置加入e数值的数
	//要进行index数值的输入控制
	public void add(int index, E e) {
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("Add failed,Index beyond brode");
		}
		if (size == data.length) {
			resize(2*data.length);
		}
		for (int i = size - 1; i >= index; i--) {
			data[i + 1] = data[i];
		}
		data[index] = e;
		size++;
	}

	//判断e数值在不在数组内
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i].equals(e))
				return true;
		}
		return false;
	}

	//找数组中为e数值的位置，如果没有输出-1
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			//值比较
			if (data[i].equals(e))
				return i;
		}
		return -1;
	}

	@Override
	//重写tostring方法让System.out.println（）能直接输出我们指定的类型
	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(',');
			} else {
				res.append(']');
			}
		}
		return res.toString();

	}

	// 获得index位置的数
	E get(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		return data[index];
	}

	// 设置index位置的数为e
	void set(int index, E e) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		data[index] = e;
	}

	//删除index位置的元素
	//返回删除的元素
	E remove(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		E rec = data[index];
		for(int i = index+1 ; i < size ;i++) {
			data[i-1] = data[i];
		}
		//我们的int类型的数组size指向的值不需要被删除，因为我们在后面插入的时候能覆盖
		//在泛型中我们使用的是类对象，我们应该删除它
		size--;
		//loitering objects!=memory leak(内存泄漏)
		data[size]=null;
		
		if(size == data.length / 2)
			resize(data.length/2);
		return rec;
	}
	
	//删除第一个元素
	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);
		}
	}
	
	//扩容
	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 static void main(String[] args) {
		Array<Integer> arr = new Array<Integer>();
		
		for (int i = 0; i < 10; i++) {
			arr.addLast(i);
		}
		System.out.println(arr);

		arr.add(1, 100);
		System.out.println(arr);

		arr.addFirst(-1);
		System.out.println(arr);
		
		arr.remove(0);
		System.out.println(arr);
		
		arr.removeElement(0);
		System.out.println(arr);
		
		arr.remove(0);
		System.out.println(arr);
		
		arr.removeFirst();
		System.out.println(arr);
		
		arr.removeFirst();
		System.out.println(arr);
		
		arr.removeFirst();
		System.out.println(arr);
		
		arr.removeFirst();
		System.out.println(arr);
		
		arr.removeFirst();
		System.out.println(arr);
		
		
		
	}
}

 

在把容量见效的时候还发现了一个隐形bug- -就是remove函数中的移动元素

之前的循环：

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

 

 

修改后的循环：

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

 

我看了一下测试的数据- -因为之前在做remove操作的时候都没有超过容量，但其实i+1从index开始的话会到size

错误发生在第二次remove，这时我们的循环到了size出现了数组越界

要体会两种循环的差异

 

 

韵然CP
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】动态数组
m0_50987960的博客
11-15 2832
动态数组主要方法的创建以及JVM中ArrayList的使用
数据结构动态数组实现链表
最新发布
05-12
动态数组和链表虽然都是数据结构，但它们各自具有不同的特性和用途，理解它们之间的交互可以增强我们对数据结构设计的理解。 链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的引用。...
数据结构-动态数组
qq_35426012的博客
09-13 360
思路：用一个结构体作控制器，里面放数组的大小，容量，和首地址，这个数组空间可以存放任意类型的数据（void*） DArray.h #pragma once #include #include typedef struct DYNAMICARRAY//定义一个动态数组控制器 { void** address;//指向数组，这个数组可以存放任意类型 int containe
数据结构之动态数组
weixin_45050132的博客
05-10 309
main.c(测试用)
数据结构：动态数组
soulmate______的博客
04-08 360
数组 数组的定义：数组是具有一定顺序关系的若干对象组成的集合，组成数组的对象称为数组元素 int[,] a = new int[2, 3]; //定义一个两行散列的数组 //静态数组 int[][] b = new int[2][]; //定义行数，列数可变 数组名表示群体的共性，即具有同一种数据类型 下标表示个体的个性，即各自占有独立的单元 数组的存储 n维数组的定义 ...
数据结构——动态数组
m0_54235152的博客
05-14 384
数据结构 一、数组 简单的时间复杂度分析 O：运行时间和输入数据之间的关系（渐进时间复杂度） O(1)：线性关系 O(n^2)：T=knn+b
JAVA数据结构之数组详细教程
01-21
本文整理了java数据结构的数组操作。希望对刚入门数据结构的同志们有帮助。 java数组非常简单。只要有JAVA语言基础就可以看这篇博文。大家不要害怕。。。非常简单。。 整理博客真的很花费时间，如果对大家有帮助，...
数据结构中的动态数组模版类
04-26
动态数组是一种在编程中常用的线性数据结构，它与普通数组相比，具有自动调整大小的能力。在C++中，我们可以创建一个模板类来实现动态数组的功能，以支持各种类型的数据。下面将详细介绍动态数组模版类及其核心功能...
动态数组链表数据结构.docx
05-30
动态数组链表数据结构 动态数组链表数据结构是一种特殊的数据结构，它将动态数组和链表的优点结合起来，形成了一种高效、灵活的数据存储方式。下面我们将详细介绍动态数组链表数据结构的组成、特点、优缺点和应用...
数据结构数组.ppt
03-18
数据结构的数组相关知识，让你掌握数组的知识，会数据结构的数组，可以完成数据结构的数组大题。让你对数据结构的数组有基础的了解。
数据结构之动态数组(集合)
又是重名了
10-21 475
我看了看慕课网上的视频，对于视频的东西进行一个整理，最开始我们先从最基础的数组开始. 我们知道Java中的数组是只能存储基本类型,我们在这里可以制作一个可以存储对象的数组,其实也就是集合，我们就是自己去写一个集合。 首先，我们要定义我们的集合的底层，我们这个集合的底层就是数组，为了规范我们将底层和数组的大小里面存储的书=数的数量设置为private形式，用户不需要去能够使用到底层的知识，他们也不需...
数据结构-动态数组(ArrayList)
持续输入，尽力输出
12-14 1161
动态数组详细讲解(Java实现)
数据结构基础之动态数组
乔布奇的博客
02-26 652
兄嘚，你了解动态数组吗？
C语言实现动态数组数据结构
"C语言与数据结构相关，特别是关于线性结构中的数组，包括其优缺点、功能定义以及C语言中的实现原理，涉及到动态数组的管理函数如初始化、销毁、调整大小、插入、删除等操作。" 在编程领域，数据结构是理解和设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值