数据结构复习整理-01动态数组

1. 数组（Array）

数组是一种顺序存储的线性表，所有元素的内存地址是连续的；

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(int index, E element)

/**
 * 在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=4处，插入9，元素全部后移
	// 1 2 3 4 9  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);
}

4. 添加元素 remove(int index)

/**
 * 删除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为4的元素，元素前移
	// 1 2 3 4  6	(remove后的数组)
	// 从前往后开始移, 用后面的元素覆盖前面的元素
	E old = elements[index];
	for (int i = index; i < size - 1; i++) {
		elements[i] = elements[i + 1];
	}
	// 下面是使用泛型后需要写的(如果存储的是int型数据, 则不需要)
	elements[--size] = null; // 删除元素后, 将最后一位设置为null
	return old;
}
/**
 * 删除所有元素
 */
public void clear(){
	// 使用泛型数组后要注意内存管理(将元素置null)
	for (int i = 0; i < size; i++) {
		elements[i] = null;
	}
	size = 0;
}

5. 判断存在元素contains(E element)

/**
 * 是否包含某个元素
 * @param element
 * @return
 */
public boolean contains(E element){
	return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True
}
/**
* 查看元素的索引
 * @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;
}

6. 扩容ensureCapacity(int capacity)

/**
 * 扩容操作
 */
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);
}

7. 数组打印（toString）

@Override
public String toString() {

	//字符串拼接建议使用 StringBuilder
	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();
}