（不要小瞧数组）玩转数据结构之数组，手写动态数组（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);