算法导论-栈和队列的简单实现

栈：

接口：

public interface Stack<T> {
boolean isEmpty();
void clear();
T pop();
boolean push(T t);
int length();
// 查看站顶元素，不执行移除
T peek();
// 返回对象位置
int search(T t);
}

数组实现

public class SimpleStack<T> implements Stack<T>{

int size=0;
private T[] t = (T[])new Object[12];

@Override
public boolean isEmpty() {
return false;
}


@Override
public void clear() {
for (int i = 0; i < t.length; i++) {
t[i]=null;
}
size=0;
}


@Override
public int length() {
return size;
}
@Override
public T pop() {
if(size==0){
return null;
}else{
T tmp=t[size-1];
t[size-1]=null;
size--;
return tmp;
}
}


@Override
public boolean push(T o) {
if(size>=t.length){
resize();
}
t[size++]=o;
return true;
}



private void resize() {
T[] tmp = (T[]) new Object[t.length*2];
for (int i = 0; i < t.length; i++) {
tmp[i]=t[i];
t[i]=null;
}
t = tmp;
tmp= null;
}


@Override
public T peek() {
if(size==0){
return null;
}else{
return t[size-1];
}
}


@Override
public int search(Object o) {

for (int i = 0; i < t.length; i++) {
if(o.equals(t[i])){
return i;
}
}
return -1;
}


@Override
public String toString() {
StringBuffer s = new StringBuffer();
s.append("statck:[\n");
for (int i = size-1; i >= 0; i--) {
s.append(" "+t[i].toString());
}
s.append("\n]");
return s.toString();
}
}

链表实现：

public class SimpleLinkedStack<T> implements Stack<T>{

public class Node<T>{
Node<T> pre;
T data;
}
int size;
Node<T> top;


@Override
public boolean isEmpty() {
return size==0;
}


@Override
public void clear() {
top=null;
size=0;
}


@Override
public T pop() {
if(top != null){
Node<T> result = top;
top=top.pre;
size--;
return result.data;
}
return null;
}


@Override
public boolean push(T o) {
Node<T> node= new Node<T>();
node.data=o;
node.pre=top;
top=node;
size++;
return true;
}


@Override
public int length() {
return size;
}


@Override
public T peek() {
return top.data;
}


@Override
public int search(T t) {
int count=0;
Node node=top;
while(node.pre!=null){
count++;
if(t.equals(node.data)){
return size-count;
}
}
return -1;
}




@Override
public String toString() {
StringBuffer s = new StringBuffer();
s.append("statck:[\n");
for (Node node=top;node!=null;node=node.pre) {
s.append(" "+node.data.toString());
}
s.append("\n]");
return s.toString();
}
}

测试：

public class SimpleStatckTest {
public static void main(String[] args) {
Stack<String> s= new SimpleLinkedStack<String>();
s.push("a");
s.push("b");
s.push("c");
s.push("d");
System.out.println(s.toString());
s.peek();
s.peek();
System.out.println(s.toString());
s.pop();
s.pop();
System.out.println(s.toString());
}
}

队列：

接口：

public interface Queue<E> {
// enqueue  
boolean add(E e);
// dequeue
E remove();

E element();

int length();

boolean empty();

void clear();
}

数组：

public class SimpleQueue<T> implements Queue<T>{


int size;
T[] t = (T[])new Object[12];
int front=0;
int back=0;


@Override
public boolean add(T e) {
if(back>t.length-1){
new Exception("队列已满");
}
t[back++]=e;
return true;
}


@Override
public T remove() {
if(empty()){
new Exception("队列已空");
}
T result=t[front];
t[front++]=null;
return result;
}


@Override
public T element() {
if(empty()){
return null;
}
return t[front];
}


@Override
public int length() {
return back-front;
}


@Override
public boolean empty() {
return back==front;
}


@Override
public void clear() {
for (int i = 0; i < t.length; i++) {
t[i]=null;
}
front=0;
back=0;
}

@Override
public String toString() {
if(empty()){
return "queue:[]";
}else{
StringBuffer s= new StringBuffer();
s.append("queue:[\n");
for (int i = front; i < back; i++) {
s.append(" "+t[i]);
}
s.append("\n]");
return s.toString();
}
}
}

链表：

public class SimpleLinkedQueue<T> implements Queue<T> {
public class Node<T> {
T data;
Node<T> next;
}


Node<T> front;


Node<T> back;


int size;


@Override
public boolean add(T e) {
if(front==null){
front = new Node<T>();
front.data=e;
back=front;
}else{
Node<T> node = new Node<T>();
node.data=e;
back.next=node;
back=node;
}
size++;
return true;
}


@Override
public T remove() {
if(empty()){
new Exception("队列已空");
}
T result = front.data;
front = front.next;
size--;
return result;
}


@Override
public T element() {
if (empty()) {
return null;
}
return back.data;
}


@Override
public int length() {
return size;
}


@Override
public boolean empty() {
return size == 0;
}


@Override
public void clear() {
front = null;
back = null;
size = 0;
}

@Override
public String toString() {
if(empty()){
return "queue:[]";
}else{
StringBuffer s= new StringBuffer();
s.append("queue:[\n");
for (Node node = front; node != null; node=node.next) {
s.append(" "+node.data);
}
s.append("\n]");
return s.toString();
}
}
}

测试：

public class SimpleQueueTest {


public static void main(String[] args) {
Queue<String> queue=new SimpleLinkedQueue<String>();
queue.add("a");
queue.add("b");
queue.add("c");
System.out.println(queue.toString());
queue.add("d");
System.out.println(queue.toString());
queue.remove();
System.out.println(queue.toString());
queue.element();
System.out.println(queue.toString());
}


}