算法与数据结构-数组

数组

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同
类型的数据。
数组的特点
数组用一块连续的内存空间，来存储相同类型的一组数据，最大的特点就是支持随机访问，但插入、删除操作也
因此变得比较低效，平均情况时间复杂度为 O(n)。在平时的业务开发中，我们可以直接使
用编程语言提供的容器类，但是，如果是特别底层的开发，直接使用数组可能会更合适。
Demo，底层用数组实现一个增删该查的动态数组。

package com.wanda.array;

public class Array<E> {
	private E[] data;
	private int size;

	// 初始化数组容量
	public Array(int capacity) {
		data = (E[])new Object[capacity];
		size = 0;
	}
	public Array(E[] arr) {
		data= (E[])new Object[arr.length];
		for(int i=0;i<arr.length;i++) {
			data[i]=arr[i];
		}
		size=arr.length;
	}

	public Array() {
		this(10);
	}

	// 获取数组的元素个数
	public int getSize() {
		return size;
	}

	// 获取数组的容量
	public int getCapacity() {
		return data.length;
	}
	public E getLast() {
		return get(size-1);
	}
	public E getFirst() {
		return get(0);
	}

	public boolean isEmpty() {
		return size == 0;
	}
	//往数组的尾部添加元素
	public void addLast(E value) {
		/*if (size == data.length) {
			throw new IllegalArgumentException("addLast fail");
		}*/
		/*data[size] = value;
		size++;*/
		add(size,value);
	}
	public void addFirst(E value) {
		add(0,value);
		}
	//添加元素
	public void add(int index,E value) {
		if (size == data.length) {
			resize(2*data.length);
		}
		if(index<0||index>size) {
			throw new IllegalArgumentException("add fail");
		}
		for(int i=size-1;i>=index;i--) {
			data[i+1]=data[i];
		}
		data[index]=value;
		size++;
	}
	//数组的扩容操作
	private void resize(int newCapacity) {
		// TODO Auto-generated method stub
		E[] newData= (E[])new Object[newCapacity];
		for(int i=0;i<size;i++) {
			newData[i]=data[i];
		}
		data=newData;
		
	}
	//获取元素
	public E get(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("get fail");
		}
		return data[index];
	}
	//修改元素
	public void set(int index,E value) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("get fail");
		}
		data[index]=value;
		}
	public boolean contains(E value) {
		for(int i=0;i<size;i++) {
			if(value.equals(data[i])) {
				return true;
			}
		}
		return false;
	}
	//如果不存在，则返回索引-1
	public int find(E value) {
		for(int i=0;i<size;i++) {
			if(data[i].equals(value)) {
				return i;
			}
		}
		return -1;
	}
	//删除元素
	public E remove(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("remove fail");
		}
		E ret=data[index];
		for(int i=index+1;i<size;i++) {
			data[i-1]=data[i];
		}
		size--;
		data[size]=null;
		return ret;
	}
	public E removeFirst() {
		return remove(0);
	}
	public E removeLast() {
		return remove(size-1);
	}
	public void removeElement(E value) {
		int index=find(value);
		if(index!=-1) {
			remove(index);
		}
	}
	public void swap(int i,int j) {
		if(i<0||i>=size&&j<0||j>=size) {
			throw new IllegalArgumentException("index illegal");
		}
		E t=data[i];
		data[i]=data[j];
		data[j]=t;
	}
	@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();
	}

}