(不要小瞧数组)玩转数据结构之数组,手写动态数组(Java)
Posted 一切随缘~~~
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了(不要小瞧数组)玩转数据结构之数组,手写动态数组(Java)相关的知识,希望对你有一定的参考价值。
带有泛型类的数组
import java.util.Arrays;
public class Array<E>
private E[] data;
private int size;
// 传入capacity初始化数组的容量
public Array(int capacity)
// 不能直接实例化泛型类,通过Object强制类型转换
data = (E[])new Object[capacity];
size = 0;
// 无参构造,默认数组初始容量为10
public Array()
this(10);
// 返回数组中的元素个数
public int getSize()
return size;
// 获取数组的容量
public int getCapacity()
return data.length;
// 判断数组是否为空
public boolean isEmpty()
return size == 0;
// 向所有元素后添加一个元素
public void addLast(E e)
/**
* if (size == data.length)
* throw new IllegalArgumentException("Array is full.");
*
* data[size] = e;
* size ++ ;
*/
add(size, e);
// 在所有元素前添加一个元素
public void addFirst(E e)
add(0, e);
// 在第index个位置插入一个新的元素
public void add(int index, E e)
if (size == data.length)
throw new IllegalArgumentException("Array is full.");
if (index < 0 || index > size)
throw new IllegalArgumentException("Require index >= 0 and index <= size");
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;
// 删除指定索引的元素,返回删除的元素
public E remove(int index)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
E res = data[index];
for (int i = index + 1; i < size; i ++ )
data[i - 1] = data[i];
size -- ;
data[size] = null;
return res;
// 删除首元素,返回删除的元素
public E removeFirst()
return remove(0);
// 删除尾元素,返回删除的元素
public E removeLast()
return remove(size - 1);
// 删除元素e,若不存在,则饭返回-1
public void removeElement(E e)
int index = find(e);
if (index != -1)
remove(index);
// 获取索引位置为index的元素
public E get(int index)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
return data[index];
// 修改索引位置为index的元素
public void set(int index, E e)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
data[index] = e;
@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();
检验效果
public class Student
private String name;
private double score;
public Student(String name, double score)
this.name = name;
this.score = score;
public Student()
@Override
public String toString()
return "Student" +
"name='" + name + '\\'' +
", score=" + score +
'';
public static void main(String[] args)
Array<Student> arr = new Array<>();
arr.addLast(new Student("张三", 33));
arr.addLast(new Student("李四", 66));
arr.addLast(new Student("王五", 88));
System.out.println(arr);
自动扩容的动态数组
扩容的原理:当数组元素的个数大于数组的容载量时,创建一个更大的数组,讲原数组复制到新创建的数组中,将数组的引用指向新的数组,旧的数组会被垃圾回收器回收。
import java.util.Arrays;
public class Array<E>
private E[] data;
private int size;
// 传入capacity初始化数组的容量
public Array(int capacity)
// 不能直接实例化泛型类,通过Object强制类型转换
data = (E[])new Object[capacity];
size = 0;
// 无参构造,默认数组初始容量为10
public Array()
this(10);
// 返回数组中的元素个数
public int getSize()
return size;
// 获取数组的容量
public int getCapacity()
return data.length;
// 判断数组是否为空
public boolean isEmpty()
return size == 0;
// 向所有元素后添加一个元素
public void addLast(E e)
/**
* if (size == data.length)
* throw new IllegalArgumentException("Array is full.");
*
* data[size] = e;
* size ++ ;
*/
add(size, e);
// 在所有元素前添加一个元素
public void addFirst(E e)
add(0, e);
// 在第index个位置插入一个新的元素
public void add(int index, E e)
if (index < 0 || index > size)
throw new IllegalArgumentException("Require index >= 0 and index <= size");
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 ++ ;
// 扩容函数
private void resize(int newCapacity)
E[] newData = (E[])new Object[newCapacity];
for (int i = 0; i < size; i ++ )
newData[i] = data[i];
data = newData;
// 查询数组中是否包含元素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;
// 删除指定索引的元素,返回删除的元素
public E remove(int index)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
E res = data[index];
for (int i = index + 1; i < size; i ++ )
data[i - 1] = data[i];
size -- ;
data[size] = null;
// 当数组中浪费的空间太多时,减小容载量
if (size == data.length / 2)
resize(data.length / 2);
return res;
// 删除首元素,返回删除的元素
public E removeFirst()
return remove(0);
// 删除尾元素,返回删除的元素
public E removeLast()
return remove(size - 1);
// 删除元素e,若不存在,则饭返回-1
public void removeElement(E e)
int index = find(e);
if (index != -1)
remove(index);
// 获取索引位置为index的元素
public E get(int index)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
return data[index];
// 修改索引位置为index的元素
public void set(int index, E e)
if (index < 0 || index >= size)
throw new IllegalArgumentException("Index is illegal");
data[index] = e;
@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();
检验自动扩容
检验自动减容
简单的时间复杂度分析**(按照最坏的情况分析)**
均摊时间复杂度和防止复杂度震荡
均摊复杂度
复杂度震荡
有时候"懒",但是效率却更好!
改良后的代码
if (size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
以上是关于(不要小瞧数组)玩转数据结构之数组,手写动态数组(Java)的主要内容,如果未能解决你的问题,请参考以下文章