package com.structure.linked;
import com.structure.Queue.Queue;
/**
* 基于时间复杂度的分析,
* 1. 添加/修改/删除. 头 -> O(1)
* 2. 添加/修改/删除. 其他 -> 0(n)
* 改进:
* 1. 将尾部node增加为其成员变量tail. 则有效降低时间复杂度.
* 2. 以此为基础 , 构建以链表为基础的队列结构 ,
* 分析:
* 1. tail端增加元素比较容易,删除比较困难
* 1. 所以, tail端作为queue的对尾,添加数据
* 2. head端作为queue的对首,移除数据
* 3. 因为队列不操作其中间数据,所以不需要使用虚拟头节点来解决问题了
*/
public class LinkedListQueue<E> implements Queue<E>{
private int size;
private Node head;
private Node tail;
@Override
public int size() {
return size;
}
@Override
public boolean empty() {
return size == 0;
}
@Override
public void enqueue(E e) {
if (tail == null) {
tail = new Node(e);
head = tail;
} else {
tail.next = new Node(e);
tail = tail.next;
}
size++;
}
@Override
public E dequeue() {
if (empty()) {
return null;
}
Node ret = head;
head = head.next;
ret.next = null;
if (head == null) {
tail = null;
}
size--;
return ret.e;
}
@Override
public E getFront() {
if (empty()){
return null;
}
return head.e;
}
private class Node{
private E e;
private Node next;
public Node(E e, Node next) {
this.e = e;
this.next = next;
}
public Node() {
this(null,null);
}
public Node(E e) {
this(e,null);
}
@Override
public String toString() {
return e.toString();
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("queue front:");
Node cur = head;
while (cur != null) {
sb.append(cur.e+" -> ");
cur = cur.next;
}
return sb.toString();
}
public static void main(String[] args) {
LinkedListQueue<Integer> queue = new LinkedListQueue();
for (int i = 0; i < 10; i++) {
queue.enqueue(i);
System.out.println(queue);
if (i % 3 == 2) {
queue.dequeue();
System.out.println(queue);
}
}
}
}
怎么说呢 , 不舒服