具有一个指针的 FIFO 队列

Question

大家好，我用 java 编写了一个带有 2 个指针（头、尾）的 fifo 队列实现。我想知道是否有任何方法可以创建一个仅使用头指针的先进先出循环队列。任何建议表示赞赏。

我的代码如下：

import java.io.PrintStream;
import java.util.*

public class StringQueueImpl<T> implements StringQueue {

private int total;         // number of elements on queue
private Node head;    // beginning of queue
private Node tail;     // end of queue

private class Node {
    T ele;
    Node next;
    Node(T ele) {
    this.ele = ele;
    next = null; } 
} 
 /**
 * Creates an empty queue.
 */
public StringQueueImpl() {
    first = null;
    last  = null;
    total = 0;
}

boolean isEmpty() {
    return (head == null); 
}

public <T> void put(T ele) {
    Node t = tail;
    tail = new Node(ele);
    if (isEmpty()) head = tail;
    else t.next = tail; 
    total++;
} 

public T get() {
    if (isEmpty()) throw new NoSuchElementException();
    T v = head.ele;
    Node t = head.next;
    head = t;
    return v; 
    total--;
} 


public T peek() {
    if (isEmpty()) throw new NoSuchElementException();
    return head.ele;
}

Node node = head; 
public void printQueue(PrintStream stream){
    while(node != null){
        stream.println(node.ele);
        stream.flush();
        node = node.next;
    }
}

public int size(){
    return total;
}

}

Answer 1

我没有测试所有东西，但有些功能可以正常工作。

import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;


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

    private Node head = null;
    private Integer size = 0;

    private class Node{
        private Node next;
        private T data;

        public Node() {
        }

        public Node(T data,Node next) {
            this.data = data;
            this.next = next;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }


    @Override
    public int size() {
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        if(null == head)
            return true;
        else
            return false;
    }

    @Override
    public boolean contains(Object o) {
        Node temp = head;
        int counter = 0 ;
        while(counter < size){
            if(temp.data.equals(o)){
                return true;
            }
            temp = temp.next;
            counter++;
        }
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Object[] toArray() {
        if(isEmpty())
            return null;
        Object[] arr = new Object[size];
        Node temp = head;
        int counter = 0 ;
        while(counter < size){
            arr[counter] = temp.data;
            counter++;
            temp = temp.next;
        }
        return arr;
    }

    @Override
    public <T> T[] toArray(T[] a) {
        Node temp = head;
        int counter = 0 ;
        while(counter < size){
            a[counter] = (T) temp.data;
            counter++;
            temp = temp.next;
        }
        return a;
    }

    @Override
    public boolean remove(Object o) {
        if(isEmpty())
            return false;

        if(size() == 1){
            size--;
            if(head.data.equals(o))
                head = head.next;
            return true;
        }


        Node temp = head;
        int counter = 1;
        while(counter < size){
            if(o.equals(temp.next.data)){
                temp = temp.next.next;
                size--;
                return true;
            }
            temp = temp.next;
            counter ++;
        }

        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        if(isEmpty())
            return false;
        Iterator<?> it = c.iterator();
        while(it.hasNext()){
            if(!contains(it.next())){
                return false;
            }
        }
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        Iterator<? extends T> it = c.iterator();
        while(it.hasNext()){            
            add(it.next());
        }
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        Iterator<?> it = c.iterator();
        while(it.hasNext()){            
            remove(it.next());
        }
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear() {
        head = null;
    }

    @Override
    public boolean add(T e) {

        if(isEmpty()){
            head = new Node();
            head.next = head;
            head.data = e;
            size++;
            return true;
        }

        if(size() == 1){
            Node temp = new Node();
            temp.data = e;
            temp.next = head;
            head.next = temp;
            size++;
            return true;
        }

        Node temp = head;
        int counter = 0;
        while(counter < size - 1){
            counter++;
            temp = temp.next;
        }

        temp.next = new Node(e,head);
        size++;
        return true;
    }

    @Override
    public boolean offer(T e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public T remove() {
        if(isEmpty())
            return null;

        Node temp = head;
        int counter = 0;
        while(counter < size){
            temp = temp.next;
            counter++;
        }
        head = head.next;
        temp.next = head;

        return null;
    }

    @Override
    public T poll() {
        if(isEmpty())
            return null;

        if(size() == 1){
            T data = head.data;
            head = null;
            size--;
            return data;
        }
        T data = head.data;

        Node temp = head;
        int counter = 0;
        while(counter < size - 1){
            counter++;
            temp = temp.next;
        }
        head = head.next;
        temp.next = head;
        size--;
        return data;
    }

    @Override
    public T element() {
        if(isEmpty())
            throw new NoSuchElementException("Queue is Empty!!!");
        T data = head.data;
        head = head.next;
        return data;
    }

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

    public void print(){
        Node temp = head;
        int counter = 0;
        while(counter < size){
            counter++;
            System.out.println(temp.data);
            temp = temp.next;
        }

    }

    public static void main(String[] args) {
        CircularQueue<String> circularQueue = new CircularQueue<>();

        if(circularQueue.isEmpty()){
            circularQueue.add("Gurkan");
            circularQueue.print();
            circularQueue.add("Illeez");
            circularQueue.print();
            circularQueue.add("Test1");
            circularQueue.print();
            circularQueue.add("Test2");
            circularQueue.print();
            while(!circularQueue.isEmpty())
            {
                System.out.println(circularQueue.poll());
            }
        }

    }

}