数据结构（1）-- 数组

目录

0.目录
1.线性表 – 数组
2.线性表 – 单向链表
3.栈

线性表 List

线性表作为最常用且最基本的数据结构，它是由n个数据元素有序排列而成。它的实现一般分成两种：

1. 数组：使用数组存储线性表的元素，即用一组连续的存储单元依次存储线性表的数据元素；
2. 链表：用一组任意的存储单元存储线性表的数据元素（存储单元可以物理连续、可以不连续）。

本节将主要探讨数组这种数据结构

数组

  数组是一种大小固定的物理上连续的数据结构，对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能继续存储线性表中的新元素时，我们可以创建一个新的更大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

// 数组扩容、缩容的实现代码
private void resize(int newCapacity) {
	E[] newElements = (E[]) new Object[newCapacity];
	System.arraycopy(elements, 0, newElements, 0, size);
	elements = newElements;
	capacity = newCapacity;
}

// 数组新增元素的实现代码
public void add(int index, E e) {
	if (index < 0 || index > size) {
		throw new IndexOutOfBoundsException("Wrong index: " + index);
	}
	if (size == capacity) {
		reSize(capacity << 1);
	}
	for (int i = size; i > index; i--) {
		elements[i] = elements[i - 1];
	}
	elements[index] = e;
	size++;
}

  上述代码简单写出了数组实现线性表的两个典型方法，具体可以参考ArrayList集合类的源码。
  数组实现的线性表，优点是可以通过下标来访问和修改元素，查询和修改比较高效（O(1)，根据索引查询和修改）；缺点是插入和删除开销较大（O(n)，比如在第一个位置插入一个元素，那么先要把后面所有元素往后移动一个位置）。

复杂度分析

1. 增：add – O(n)、addLast – O(1)
2. 删：remove – O(n)、removeLast – O(1)
3. 改：set – O(1)
4. 查：get – O(1)

  可以看出，基于数组实现的线性表结构，特点是：增删慢、改查快。

源码

public class Array<E> {

	private static final int DEFAULT_CAPACITY = 10;

	private E[] elements;
	private int capacity;
	private int size = 0;

	public Array(int capacity) {
		this.capacity = capacity;
		elements = (E[]) new Object[capacity];
	}

	public Array() {
		this(DEFAULT_CAPACITY);
	}

	/**
	 * 改变静态数组容量 O(n) -- 均摊复杂度 O(1)
	 * @param newCapacity
	 */
	private void resize(int newCapacity) {
		E[] newElements = (E[]) new Object[newCapacity];
		System.arraycopy(elements, 0, newElements, 0, size);
		elements = newElements;
		capacity = newCapacity;
	}

	/**
	 * 获得数组实际容量
	 * @return size
	 */
	public int getSize() {
		return size;
	}

	/**
	 * 在指定索引位置插入元素 O(n)
	 * 特例：addLast为O(1)
	 * @param index
	 * @param e
	 */
	public void add(int index, E e) {
		if (index < 0 || index > size) {
			throw new IndexOutOfBoundsException("Wrong index: " + index);
		}
		if (size == capacity) {
			resize(capacity << 1);
		}
		for (int i = size; i > index; i--) {
			elements[i] = elements[i - 1];
		}
		elements[index] = e;
		size++;
	}

	public void add(E e) {
		add(size, e);
	}

	public void addFirst(E e) {
		add(0, e);
	}

	public void addLast(E e) {
		add(e);
	}

	public Array<E> addElement(E e) {
		add(e);
		return this;
	}

	public Array<E> addElementFirst(E e) {
		addFirst(e);
		return this;
	}

	public Array<E> addElementLast(E e) {
		return addElement(e);
	}

	/**
	 * 删除指定索引位置的元素 O(n)
	 * 特例：removeLast O(1)
	 * @param index
	 */
	public void remove(int index) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException("Wrong index: " + index);
		}
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		size--;
		// 防止震荡，故达到1/4容量时，缩容1/2
		if (size == capacity / 4 && size / 2 > 0) {
			resize(capacity >> 1);
		}
	}

	public void removeFirst() {
		remove(0);
	}

	public void removeLast() {
		remove(size - 1);
	}

	/**
	 * 查询数组是否包含某个元素，如果包含返回索引，如果不包含返回-1 O(n)
	 * @param e
	 * @return
	 */
	public int contains(E e) {
		if (e == null) {
			return -1;
		}
		for (int i = 0; i < size; i++) {
			if (elements[i].equals(e)) {
				return i;
			}
		}
		return -1;
	}

	public Array<E> removeElement(int index) {
		remove(index);
		return this;
	}

	public Array<E> removeElementFirst() {
		return removeElement(0);
	}

	public Array<E> removeElementLast() {
		return removeElement(size - 1);
	}

	/**
	 * 修改指定索引位置的元素 O(1)
	 * @param index
	 * @param e
	 */
	public void set(int index, E e) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException("Wrong index: " + index);
		}
		elements[index] = e;
	}

	public void setFirst(E e) {
		set(0, e);
	}

	public void setLast(E e) {
		set(size - 1, e);
	}

	public Array<E> setElement(int index, E e) {
		set(index, e);
		return this;
	}

	public Array<E> setElementFirst(E e) {
		setFirst(e);
		return this;
	}

	public Array<E> setElementLast(E e) {
		setLast(e);
		return this;
	}

	/**
	 * 查询并返回指定索引位置的元素 O(1)
	 * @param index
	 * @return
	 */
	public E get(int index) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException("Wrong index: " + index);
		}
		return elements[index];
	}

	public E getFirst() {
		return get(0);
	}

	public E getLast() {
		return get(size - 1);
	}

	/**
	 * 返回数组是否为空
	 * @return
	 */
	public boolean isEmpty() {
		return size == 0;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("Array [");
		for (int i = 0; i < size; i++) {
			sb.append(elements[i]);
			if (i != size - 1) {
				sb.append(", ");
			}
		}
		sb.append("] capacity:").append(capacity);
		return sb.toString();
	}
}