数据结构与算法第二天总结

数据结构与算法第二天总结：
1.栈的顺序存储结构
栈是指仅限定在表尾进行插入和删除操作的线性表
站的特点是先进后出，后进先出
允许插入和删除的一端成为栈顶，另一端称为栈底
线性表的的表尾即为栈顶，表头即为栈底
不含任何元素的栈为空栈

接口Stack：

public interface Stack<E> {
	
	public int getSize();
	
	public boolean isEmpty();
	/**
	 * 进栈一个元素e
	 */
	public void push(E e);
	/**
	 * 出栈一个元素e
	 * @return 当前出栈的元素
	 */
	public E pop();
	/**
	 * 获取当前栈顶元素
	 * @return
	 */
	public E peek();
	/**
	 * 清空栈
	 */
	public void clear();
}

ArrayStack（需导入ArrayList包）：

public class ArrayStack<E> implements Stack<E> {

	private ArrayList<E> list;
	
	public ArrayStack(){
		list = new ArrayList<E>();    //创建一个默认大小的顺序表
	}
	
	public ArrayStack(int capacity) {
		list = new ArrayList<E>(capacity);//创建一个指定大小capacity的顺序表
	}
	
	public int getSize() {
		return list.getsize();
	}

	public boolean isEmpty() {
		return list.isEmpty();
	}

	public void push(E e) {
		list.addLast(e);
	}

	public E pop() {
		return list.removeLast();
	}

	public E peek() {
		return list.getLast();
	}

	public void clear() {
		list.clear();
	}
	
	public boolean equals(Object obj){
		if(obj == null){
			return  false;
		}
		if(cbj == this){
			return true;
		}
		if(obj instanceof ArrayStack){
			ArrayAtack stack = (ArrayStack) obj;
			return list.equals(stack.list);
		}
		return false;
	}
	
	public String  toString(){
		StringBuilder sb = new StringBuilder();
		sb.append("ArrayStack: size="+getSize()+",capacity="+list.getCapacity+"\n");
		if(isEmpty()) {
			sb.append("[]");
		}else {
			sb.append('[');
			for(int i = 0;i<getSize;i++) {
				sb.append(list.get[i]);
				if(i==getSize-1) {
					sb.append(']');
				}else {
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
}

双端栈：指在线性表两端当做栈底分别进行插入和删除操作

队列的顺序存储结构：
队列：是在一端进行插入而在另一端进行删除操作的线性表
队列的基本操作是enqueue（入队），即在表的末端（rear）插入一个元素，和出队（dequeue），即在表头删除一个元素并返回。
当需要入队多个元素时，入队的元素将会在一个不存在的位置，而队列或许并没有满，因为若干元素可能已经出队了，为了解决这种问题，我们可以将队列首尾相接，当最后一个元素进入到数组的尾端之后，又绕到开头继续插入，这种情况叫做循环数组。
接口：

public interface Queue<E>{
	public int getSize();
	public boolean isEmpty();
	public void clear();
	public void enqueue();
	public E dequeue();
	public E getFront();
	public E getRear();
}

ArrayQueueLoop:

public  class ArrayQueue<E> implements Queue<E> {
	
	private E[] data;
	private int front;
	private int rear;
	private int size;
	private static int DEFAULT_SIZE=10;

	public ArrayQueueLoop(){
		this(DEFAULT_SIZE);
	}
	
	public ArrayQueueLoop(int capacity){
		data = (E[])new Objecy[capacity+1];
		front = 0;
		rear = 0;
		size = 0;
	}
	
	public int getSize() {
		return size;
	}

	public boolean isEmpty() {
		return front == rear;
	}

	public void clear() {
		front = 0;
		rear = 0;
		size = 0;
	}

	public void enqueue(E e) {
		data[rear] = e;
		rear = (rear + 1)%data.length;
		size++;	`
	}

	public E dequeue() {
		if(isEmpty()){
			throw new NullPuinterException("队列为 空");
		}
		E e = data[front];
		front = (front+1)%data.length;
		size--;
		return e;
	}

	public E getFront() {
		return data[Front];
	}

	public E getRear() {
		return data[(data.length + rear - 1)%data.length];
	}
	
	public String toString(){
		StringBudilder sb = new StringBuilder();
		sb.append("ArrayQueueLoop:size="+getSize()+",capacity = "+(data.length-1));
		if(isEmpty()){
			sb.append("[]");
		}else{
			for(int i = front;i!=rear;i=(i+1)&data.length){
				sb.append(data[i]);
				if((i+1)%data.length == rear){
					sb.appeng(']');
				}else{
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
}