1、栈是一种后进先出策略的集合类型
/**
* 通用节点
*/
public class Node<T> {
private T item;
private Node<T> next;
public Node(T item) {
this.item = item;
}
public T getItem() {
return item;
}
public void setItem(T item) {
this.item = item;
}
public Node<T> getNext() {
return next;
}
public void setNext(Node<T> next) {
this.next = next;
}
}
public class Stack<T> {
private Node<T> first;
private int size;
public boolean isEmpty() {
return size == 0;
}
public int getSize() {
return size;
}
public void push(T item) {
// 向栈顶添加元素
Node<T> oldFirst = first;
first = new Node<>(item);
first.setNext(oldFirst);
size++;
}
public T pop() {
// 从栈顶删除元素
Node<T> oldFirst = first;
first = oldFirst.getNext();
size--;
return oldFirst.getItem();
}
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.push("node1");
stack.push("node2");
stack.push("node3");
System.out.println(" size: " + stack.size);
System.out.println(stack.pop() + " size: " + stack.getSize() + " : " + stack.isEmpty());
System.out.println(stack.pop() + " size: " + stack.getSize() + " : " + stack.isEmpty());
System.out.println(stack.pop() + " size: " + stack.getSize() + " : " + stack.isEmpty());
}
}
2、队列是一种基于先进先出策略的集合
public class Queue<T> {
private Node<T> first;
private Node<T> last;
private int size;
public boolean isEmpty() {
return size == 0;
}
public int getSize() {
return size;
}
public void enqueue(T item) {
if (this.size == 0) {
last = new Node<>(item);
first = last;
} else {
Node<T> oldLast = last;
last = new Node<>(item);
oldLast.setNext(last);
}
size++;
}
public T dequeue() {
Node<T> oldFirst = first;
first = first.getNext();
size--;
return oldFirst.getItem();
}
public static void main(String[] args) {
Queue<String> queue = new Queue<>();
queue.enqueue("node1");
queue.enqueue("node2");
queue.enqueue("node3");
System.out.println(" size: " + queue.size);
System.out.println(queue.dequeue() + " size: " + queue.getSize() + " : " + queue.isEmpty());
System.out.println(queue.dequeue() + " size: " + queue.getSize() + " : " + queue.isEmpty());
System.out.println(queue.dequeue() + " size: " + queue.getSize() + " : " + queue.isEmpty());
}
}
3.揹包是一种不支持从中删除元素的结合数据类型,目的就是帮助用例收集元素并迭代遍历所有收集到的元素。
public class Bag<T> implements Iterable<T> {
private Node<T> first;
private void add(T item) {
Node<T> oldFirst = first;
first = new Node<>(item);
first.setNext(oldFirst);
}
@Override
public Iterator<T> iterator() {
return new ListIterator();
}
private class ListIterator implements Iterator {
private Node<T> current = first;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Object next() {
T item = current.getItem();
current = current.getNext();
return item;
}
@Override
public void remove() {
}
}
public static void main(String[] args) {
Bag<String> bag = new Bag<>();
bag.add("node1");
bag.add("node2");
bag.add("node3");
Iterator<String> iterator = bag.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}