动态数组
动态数组简介
数组定义后,其容量大小就已经固定。而动态数组,也就是数组的容量大小可以变化,也可以删除某一数组下标值,也可以在某一个下标处添加一个数据。
具体实现方式
为了实现动态数组的相关功能,我们需要将数组封装一层Array类。在Array类创建有参和无参构造,用于用户定义起始数组的大小。接下来就要实现其具体的增删改查四种功能:
- 增
add(int index, E e)向指定位置添加元素e。在执行添加操作前,需判断当前数组是否已经放满。如果放满,则需要扩容数组。(数组的扩容,采用哪种扩容机制?一次扩容太大浪费空间,一次扩容太小,会造成频繁扩容,影响性能。)而扩容数组也就是新建一个新的大容量数组,将旧数组中的数据放在新数组中,而旧的数组在后面没有使用(或者置空)就会被垃圾回收站回收。这样也就实现了数组的扩容。数组的空间够了后,需要向指定位置添加元素e。首先一点,肯定不能直接赋值,这样会覆盖之前数据。所以,我们需要先将index位置以及之后的元素都往后移,然后再将元素e赋值到index位置 - 删
remove(int index)从index位置删除元素,就是将index位置之后的元素都向前移动一位,这样就将index+1的位置元素赋值给index位置处,而index处原本的值被覆盖 - 改
set(int index,E e)直接将元素e赋值到index位置处 - 查
直接按照下标查询即可
代码的具体实现
package Array;
public class Array<E> {
private static int capacity = 10;
private E[] data;
private int size;
/**
* 传入数组容量,创建数组
*
* @param capacity
*/
public Array(int capacity) {
data = (E[])new Object[capacity];
size = 0;
}
/**
* 无参数构造函数,默认数组容量capacity=10
*/
public Array() {
this(capacity);
}
/**
* 获取数组中元素个数
*/
public int getSize() {
return size;
}
/**
* 获取数组的容量
*/
public int getCapacity() {
return data.length;
}
/**
* 判断数组是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 向所有元素后添加一个新元素
*
* @param e
*/
public void addLast(E e) {
add(size, e);
}
/**
* 在所有元素前添加一个新元素
*/
public void addFirst(E e) {
add(0, e);
}
/**
* 向指定位置添加元素
*
* @param index
* @param e
*/
public void add(int index, E e) {
if (size == data.length) {
resize(2*data.length);
}
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddList failed. Array is full");
}
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;
}
/**
*获取索引index位置的元素
*/
E get(int index){
if(index<0 || index >= size){
throw new IllegalArgumentException("Get failed. Index is illegal.");
}
return data[index];
}
/**
* 修改index索引位置的元素
*/
void set(int index,E e){
if(index<0 || index >= size){
throw new IllegalArgumentException("Get failed. Index is illegal.");
}
data[index]=e;
}
/**
* 查找数组中是否包含数字e
* @param e
* @return
*/
public boolean contains(E e){
for (int i = 0; i < size; i++) {
if(data[i]==e){
return true;
}
}
return false;
}
/**
* 查找数组中元素e所在的索引,如果不存在,返回-1
* @param e
* @return
*/
public int find(E e){
for (int i = 0; i < size; i++) {
if(data[i].equals(e)){
return i;
}
}
return -1;
}
/**
* 从index位置删除元素,并将删除的元素返回
* @param index
* @return
*/
public E remove(int index){
if(index<0 || index >= size){
throw new IllegalArgumentException("Remove failed. Index is illegal.");
}
E ret = data[index];
for (int i = index+1; i < size; i++) {
data[i-1] = data[i];
}
size--;
return ret;
}
/**
* 删除数组中第一个元素
* @return
*/
public E removeFirst(){
return remove(0);
}
/**
* 删除数组中最后一个元素
* @return
*/
public E removeLast(){
return remove(size-1);
}
/**
* 从数组中删除元素e
*/
public void removeElement(E e){
int index = find(e);
if(index != -1){
remove(index);
}
}
@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();
}
}
代码中丰富了一些方法,重写了个toString
验证
结论
简单的时间复杂度分析
O(1),O(n),O(lgn),O(nlogn),O(n^2)一般分为这几种复杂度
大O描述的是算法的运行时间和输入数据之间的关系,举个栗子说明如下:
public static int sun(int[] nums){
int sun = 0;
for(int num:nums){
sun+=num;
}
return sun;
}
上面一串简单的代码,就是求数组中数字之和。而这段程序运行的时间是与入参的数组中数据个数有关。100个数之和与10万个数之和,所花费的时间肯定不一样!这个程序的时间复杂度就是O(n)级别。其中n可以理解为入参数组的个数,程序所运行的时间是随着n值的增加而增加,算法与n呈线性关系。
分析动态数组的时间复杂度
动态数组中,查询、修改,直接通过下标即可实现,与数组中size大小没有关系,所以时间复杂度为O(1)
动态数组中,新增、删除,需要遍历数组,当数组size大时,遍历时间也就越长,所以时间复杂度为O(n)