数据结构 -- 线性表、栈(双端栈)、队列(循环队列)的实现

在实现之前需要对顺序存储结构线性表、栈、队列进行了解可以参照我上一篇博客通俗易懂保证能听懂，付上链接:
数据结构与算法笔记一

线性表

线性表首要的一个接口就是List,我们首先来看一下它的接口的定义：

public interface List<E> {	//用泛型存储类型不确定
	//获取线性表元素的个数（线性表的长度）
	//@return 线性表中的有效元素的个数
	public int getSize();
	/** 判断线性表是否为空
	 * @return 是否为空的布尔类型值
	 */
	public boolean isEmpty();
	/**
	 * 在线性表指定的index角标处添加元素e
	 * @param index 指定的角标 0<=index<=size 线性表的有效长度
	 * @param e 
	 */
	public void add(int index,E e);
	/**
	 * 在线性表表头处添加元素e
	 * @param index 指定的角标 0<=index<= 线性表的有效长度
	 */
	public void addFirst(E e);
	
	public void addLast(E e);
	/*
	 * 在线性表中获取指定index角标处的元素
	 */
	public E get(int index);
	/**
	 * 在线性表的表头位置插入一个元素
	 * @param e 要插入的元素 指定在角标0处
	 * */
	public E getFirst();
	/**
	 * 在线性表的表尾位置插入一个元素
	 * @param e 要插入的元素 指定在角标size处
	 * */
	public E getLast();
	/**
	 * 修改线性表中指定index处的元素为新元素e
	 * @param index 指定的角标
	 * @param e 新元素
	 * */
	public void set(int index,E e);
	/**
	 * 判断线性表中是否包含指定元素e 默认从前往后找
	 * @param e 要判断是否存在的元素
	 * @return 元素的存在性布尔类型值
	 * */
	public boolean contains(E e);
	/**
	 * 在线性表中获取指定元素e的角标默认从前往后找
	 * @param e 要查询的数据
	 * @return 数据在线性表中的角标
	 */
	public int find(E e);
	/**
	 * 在线性表中删除指定角标处的元素并返回
	 * @param index指定的角标 0<=index<size
	 * @return 删除掉的老元素
	 */
	public E remove(int index);
	/**
	 * 删除线性表中表头元素
	 * @return 表头元素
	 */
	public E removeFirst();
	/**
	 * 删除线性表中表尾元素
	 * @return 表尾元素
	 */
	public E removeLast();
	/**
	 * 线性表中删除指定元素e
	 * @param e 
	 */
	public void removeElement(E e);
	/**
	 * 清空线性表
	 */
	public void chear();
}

线性表的顺序存储结构：指的是用一段地址连续的存储单元，依次存储线性表的数据元素。
List接口下有一个用数组实现的子类叫ArrayList，它实现了List接口中的所有方法，并且根据自己的性质和属性有自己特有的方法。下面是它与List接口之间的关系

定义ArrayList2类实现List接口并且重写tostring和equals方法，代码如下：

//使用泛型进行规划
public class ArrayList<E> implements List<E>{
 
	private static int DEFAULT_SIZE=10;  //默认容量大小10
	private E[] data;  //存储数据元素的容器
	private int size;  //线性表的有效元素的个数 data.length表示线性表的最大容量
	
	/**
	 * 创建一个容量默认为10的一个线性表
	 */
	public ArrayList() {
		this(DEFAULT_SIZE);
	}
	
	/**
	 * 创建一个容量为指定capacity的一个线性表
	 */
	public ArrayList(int capacity) {
		this.data=(E[]) new Object[capacity];
		this.size=0;
	}
	
	/**
	 * 将一个数组封装成一个线性表
	 * @param arr
	 */
	public ArrayList(E[] arr) {  //为了保证数据的稳定性
		data=(E[]) new Object[arr.length];  //在内部创建一个新的数组
		for(int i=0;i<arr.length;i++) {  //将外部传入的数组对内部的数组一一赋值
			data[i]=arr[i];
		}
		size=arr.length; //这样在外部再去修改传入的数组中的值，对内部的线性表的值是无影响的
	}
	
	@Override
	public int getSize() {  //获取线性表中有效元素的长度
		return size;
	}
 
	@Override
	public boolean isEmputy() {  //判断该线性表是否为空表
		return size==0;
	}
 
	private void resize(int newLen){  //扩容/缩容
           //创建一个新的数组，新数组的长度由传入的参数控制，再将原来的数组里面的元素逐个赋值到新的数组里面
		E[] newData = (E[]) new  Object[newLen]; 
		for(int i=0;i<size;i++) {
			newData[i]=data[i];
		}
		data = newData; //最后将这个新的数组的地址给内部原来数组对象的引用，达到扩容/缩容的目的
	}
	
	@Override
	public void add(int index, E e) { //在指定下标添加一个元素
		if(index<0 || index>size) { //如果指定的角标不在该数组的合理范围内 
                          //抛出异常，角标越界
			throw new ArrayIndexOutOfBoundsException("角标越界");
		} 
		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++;
	}
 
	@Override
	public void addFirst(E e) {  //在线性表表头添加一个元素
		add(0,e); //也就是指定位置添加元素，只不过这个指定位置一直是表头
	}
 
	@Override
	public void addLast(E e) {  //在尾部添加
		add(size,e);
	}
 
	@Override
	public E get(int index) {  //获取指定角标的元素
		if(index<0 || index>size-1) { //首先判断该角标是否越过有效元素的个数，或是数组最小下标位置
			throw new ArrayIndexOutOfBoundsException("get函数角标越界");
		}
		return data[index]; //没有出错，则直接返回指定下标的元素
	}
 
	@Override
	public E getFirst() {  //获取头元素
		return get(0); //就是获取指定头位置的下标的元素
	}
 
	@Override
	public E getLast() {  //获取尾元素
		return get(size-1);//这里的尾元素不是数组最后一个元素，而是有效元素的最后一个位置的元素
	}
 
	@Override
	public void set(int index, E e) {  //更改某处的元素
          //角标没有越界则直接替换即可
		if(index<0 || index>size-1) {
			throw new ArrayIndexOutOfBoundsException("get函数角标越界");
		}
		data[index]=e;
	}
 
	@Override
	public boolean contains(E e) { //是否包含某元素
		if(isEmputy()) {  //首先判空，如果数组为空，肯定不包含
			return false;
		}
		for(int i=0;i<size;i++) {//不为空，则遍历查找
			if(data[i]==e) {  //如果存在，则直接返回true，不再向下查找
				return true;
			}
		}
		return false;
	}
 
	@Override
	public int find(E e) { //查找某元素，与是否包含某元素类似做法
		if(isEmputy()) {
			return -1;
		}
		for(int i=0;i<size;i++) {
			if(data[i]==e) {
				return i;
			}
		}
		return -1;
	}
 
	@Override
	public E remove(int index) {  //删除某一位置的元素
		if(index<0 || index>size-1) {  //首先角标不能越界
			throw new ArrayIndexOutOfBoundsException("删除的角标越界");
		}
		E e=get(index); //其次要将要删除的元素先提取出来
		for(int i=index;i<size-1;i++) {//然后将该元素位置后面的元素向前移动
			data[i]=data[i+1];