数据结构与算法第二天总结:
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();
}
}