一、背包
(一)概念
背包是一种不支持从中删除元素的集合数据类型,目的是帮助用例收集元素并迭代所有收集到的元素,也可以检查背包是否为空,或者获取背包中元素的数量。背包里面的元素的顺序不确定。儿时的记忆:要理解背包的概念,可以想象一个喜欢收集弹珠球的人。他将所有的弹珠球都放在一个背包里,一次一个,并且会不时在所有的弹珠球中寻找某一颗;
(二)代码实现
package com.sgh.algorithm4.datainfrastructure;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* @author sugha
* @version 1.0
* @description
* @date 2021/2/21 0021 22:40
*/
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;
}
/**
* Initializes an empty bag.
*/
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<Item>();
first.item = item;
first.next = oldfirst;
n++;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator(first);
}
private class ListIterator implements Iterator<Item> {
private Node<Item> current;
public ListIterator(Node<Item> first) {
current = first;
}
@Override
public boolean hasNext() {
return current != null;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public Item next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
Item item = current.item;
current = current.next;
return item;
}
}
/**
测试
*/
public static void main(String[] args) {
Bag<String> bag = new Bag<>();
bag.add("sgh");
bag.add("sugh");
bag.add("wd");
bag.add("wwt");
Iterator<String> iterator = bag.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
一、队列
(一)概念
特点:先进先出
类比银行柜台排队取钱,先到的拿号,先来的先办理完成离开,后面还有一串“人”等着。
(二 )代码实现
package com.sgh.algorithm4.datainfrastructure;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Spliterator;
import java.util.function.Consumer;
/**
*
* @author sugha
* @version 1.0
* @description
* @date 2021/2/23 0023 22:21
*/
public class Queue<Item> implements Iterable<Item> {
//列头,用于出队
private Node first;
//队尾,用于入列
private Node last;
//长度
private int n;
/**
* 内部类,用于存储链表各节点数据
*/
private class Node {
private Item item;
private Node next;
public Item getItem() {
return item;
}
public void setItem(Item item) {
this.item = item;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
public boolean isEmpty() {
return first == null;
}
public int size() {
return n;
}
/**
* 向队列末尾添加数据
* @param item
*/
public void addItem(Item item) {
//将last赋给一个中间节点
Node oldlast=last;
//必须要new,防止栈为空时下一行出现NPE
last=new Node();
last.setItem(item);
last.next=null;
if (isEmpty()) {
first = last;
} else {
//将久的节点和last节点连接上
oldlast.next = last;
}
//放最后,方便前面判空
n++;
}
/**
* 删除队列头数据
* @return
*/
public Item delItem() {
if (isEmpty()) {
throw new NoSuchElementException();
}
n--;
Item item=first.item;
first=first.next;
//防止游离,否则last还指着已经出队的那个元素
if (isEmpty()) {
last = null;
}
return item;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
@Override
public void forEach(Consumer<? super Item> action) {
}
@Override
public Spliterator<Item> spliterator() {
return null;
}
private class ListIterator implements Iterator { //不能定义为MyIterator<T>,此T与外部类的T会被视为另一类
private Node currrent;
public ListIterator() {
this.currrent = first;
}
@Override
public boolean hasNext() {
return currrent != null;
}
@Override
public Item next() {
if (!hasNext()){
throw new NoSuchElementException();
}
Item item = currrent.item;
currrent = currrent.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
//测试
public static void main(String[] args) {
Queue<Integer> queue = new Queue<>();
queue.addItem(123);
queue.addItem(234);
queue.addItem(789);
Iterator<Integer> iterator = queue.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println(queue.delItem()+"********************");
Iterator<Integer> iterator1 = queue.iterator();
while (iterator1.hasNext()) {
System.out.println(iterator1.next());
}
}
}
三、栈
(一)概念
特点:先进后出
相信很多人玩过玩具枪,它的弹夹就是这个特点,我们可以用这种方式来装我们想装的数据。
(二)代码实现
package com.sgh.algorithm4.datainfrastructure;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* @author sugha
* @version 1.0
* @description
* @date 2021/3/2 0002 15:34
*/
public class Stack<Item> implements Iterable<Item> {
private Node<Item> first;
private int n;
private static class Node<Item> {
private Item item;
private Node<Item> next;
}
public Stack() {
first = null;
n = 0;
}
public boolean isEmpty() {
return first == null;
}
public int size() {
return n;
}
public void push(Item item) {
Node<Item> oldfirst = first;
first = new Node<Item>();
first.item = item;
first.next = oldfirst;
n++;
}
public Item pop() {
if (isEmpty()) throw new NoSuchElementException("Stack underflow");
Item item = first.item; // save item to return
first = first.next; // delete first node
n--;
return item; // return the saved item
}
//返回栈顶部数据,但不移除
public Item peek() {
if (isEmpty()) {
throw new NoSuchElementException("Stack underflow");
}
return first.item;
}
@Override
public String toString() {
StringBuilder s = new StringBuilder();
for (Item item : this) {
s.append(item);
s.append(' ');
}
return s.toString();
}
@Override
public Iterator<Item> iterator() {
return new ListIterator(first);
}
private class ListIterator implements Iterator<Item> {
private Node<Item> current;
public ListIterator(Node<Item> first) {
current = first;
}
@Override
public boolean hasNext() {
return current != null;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public Item next() {
if (!hasNext()) throw new NoSuchElementException();
Item item = current.item;
current = current.next;
return item;
}
}
}