定义背包,队列以及栈基本数据结构,
其中背包支持数据的添加以及查询操作,数据添加的顺序无关重要;
队列支持数据的先进先出FIFO
栈支持数据的后进先出LIFO
其基本的API如下所示:
最基本的数据结构有数组以及链表,可以使用基本结构来实现上述数据结构,这里采用链表形式来实现。
链表数据结构
可以使用链表来链式存储数据,每个节点含有数据属性以及指向下一个节点的指针
在链表的头部添加一个元素
在链表的尾部添加一个元素
在链表的头部删除一个元素
使用链表来实现背包Bag
//背包数据结构 支持数据存储添加遍历操作
//不支持删除以及查找操作
//元素添加顺序不重要
public class Bag<Item> implements Iterable<Item> {
private Node<Item> first;
private int n;
private static class Node<Item>{
private Item item;
private Node<Item> next;
}
public Bag(){
first = null;
n = 0;
}
public boolean isEmpty(){
return first == null;
}
public int size(){
return n;
}
public void add(Item item){
Node<Item> oldfirst = first;
first = new Node<>();
first.item = item;
first.next = oldfirst;
n++;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator<Item>(first);
}
private class ListIterator<Item> implements Iterator<Item> {
private Node<Item> current;
public ListIterator(Node<Item> first) {
current = first;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
if(!hasNext()) throw new NoSuchElementException();
Item item = current.item;
current = current.next;
return item;
}
}
}
使用链表来实现队列Queue
//队列的链表实现
public class Queue<Item> implements Iterable<Item>{
private Node first;
private Node last;
private int N;
private class Node{
Item item;
Node next;
}
public boolean isEmpty() {
return first == null;
}
public int size() {
return N;
}
//在链表尾部插入一个元素
public void enqueue(Item item){
Node oldlast = last;
last = new Node();
last.item = item;
last.next = null;
if(isEmpty()){
first = last;
}else{
oldlast.next = last;
}
N++;
}
public Item dequeue(){
if(isEmpty()) return null;
Item item = first.item;
first = first.next;
if(first == null)
last = null;
N--;
return item;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator<Item>(first);
}
private class ListIterator<Item> implements Iterator<Item> {
private Node current;
public ListIterator(Node first) {
current = first;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
if (!hasNext())
throw new NoSuchElementException();
Item item = (Item) current.item;
current = current.next;
return item;
}
}
}
使用链表来实现栈Stack
//链表方式实现栈
public class Stack<Item> implements Iterable<Item> {
private Node first;
private int N;
private class Node {
Item item;
Node next;
}
public boolean isEmpty() {
return first == null;
}
public int size() {
return N;
}
public void push(Item item) {
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
N++;
}
public Item pop() {
if (isEmpty())
return null;
Item item = first.item;
first = first.next;
N--;
return item;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator<Item>(first);
}
private class ListIterator<Item> implements Iterator<Item> {
private Node current;
public ListIterator(Node first) {
current = first;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
if (!hasNext())
throw new NoSuchElementException();
Item item = (Item) current.item;
current = current.next;
return item;
}
}
}