队列的实现

实现Queue类

Java版本

使用链表结构作为实现的基础

          Queue就是队列，也就是说元素可以从队列的末尾加入队列中，但若需要删除元素，就需要在队列的开头将元素删除，删除元素也叫作出列。

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Arrays;

public class Queue<T> implements Iterable<T>
{
	private int count;
	private Node<T> first;
	private Node<T> last;

	private static class Node<T>
	{
		private T elem;
		private Node<T> next;
	}

	public Queue() {  }

	@SuppressWarnings("unchecked")
	public Queue( Queue<T> other )
	{
		Object[] array = new Object[other.size()];
		int i = 0;
		for( T elem : other )
			array[i++] = elem;
		T[] arrayCopy = ( T[] )Arrays.copyOf( array, array.length, Object[].class );

		for( T elem : arrayCopy )
			enqueue( elem );
	}

	public void enqueue( T elem )
	{
		Node<T> temp = new Node<>();
		temp.elem = elem;
		if( isEmpty() )
			first = temp;
		else
			last.next = temp;
		last = temp;

		count++;
	}

	public T dequeue()
	{
		if( isEmpty() )
			throw new NoSuchElementException( "Queue underflow" );
		T elem = first.elem;
		first = first.next;
		if( isEmpty() )
			last = null;
		count--;
		return elem;
	}

	public T peek()
	{
		if( isEmpty() )
			throw new NoSuchElementException( "Queue underflow" );
		return first.elem;
	}

	public String toString()
	{
		StringBuilder s = new StringBuilder();
		s.append( "[ " );
		for( T elem : this )
			s.append( elem + " " );
		s.append( "]" );
		return s.toString();
	}

	public boolean isEmpty()
	{
		return first == null;
	}

	public int size()
	{
		return count;
	}

	private class ListIterator implements Iterator<T>
	{
		private Node<T> current = first;
		@Override
		public boolean hasNext()
		{
			return current != null;
		}
		@Override 
		public T next()
		{
			if( !hasNext() )
				throw new NoSuchElementException();
			T elem = current.elem;
			current = current.next;
			return elem;
		}
		@Override
		public void remove()
		{
			throw new UnsupportedOperationException();
		}
	}

	@Override
	public Iterator<T> iterator()
	{
		return new ListIterator();
	}
}

使用环形数组作为实现的基础

           在使用数组实现队列时，通常有一个问题，就是在队列的头部删除元素时，由于数组中的元素是没有办法移动的，这就造成了在删除元素之后，数组头部出现了未填充的状态，造成了不必要的存储空间的浪费。所谓的环形数组，其实就是使用一般的数组，只不过若元素加在数组的末尾，这时要是数组末尾没有空余的位置，那么就可以将新的元素填充到数组开头的没有被利用的部分，要是整个数组都填满了元素，那么数组就会动态地增长。

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ResizingArrayQueue<T> implements Iterable<T>
{
	private T[] data;
	private int count;
	private int first;
	private int last;

	@SuppressWarnings("unchecked")
	public ResizingArrayQueue()
	{
		data = ( T[] )new Object[2];
	}

	public boolean isEmpty()
	{
		return count == 0;
	}

	public int size()
	{
		return count;
	}

	@SuppressWarnings("unchecked")
	private void resize( int newSize )
	{
		assert newSize >= count;
		T[] temp = ( T[] )new Object[newSize];
		for( int i = 0; i < count; i++ )
			temp[i] = data[ ( i + first ) % data.length];
		data = temp;
		first = 0;
		last = count;
	}

	public void enqueue( T elem )
	{
		if( count == data.length )
			resize( count * 2 );
		data[last] = elem;
		last = ( last + 1 ) % data.length;
		count++;
	}

	public T dequeue()
	{
		if( isEmpty() )
			throw new NoSuchElementException( "Queue underflow" );
		T elem = data[first];
		data[first] = null;
		first = ( first + 1 ) % data.length;
		count--;
		if( count > 0 && count == data.length / 4 )
			resize( data.length / 2 );

		return elem;
	}

	public T peek()
	{
		if( isEmpty() )
			throw new NoSuchElementException( "Queue underflow" );
		return data[first];
	}

	public Iterator<T> iterator()
	{
		return new ArrayIterator();
	}


	private class ArrayIterator implements Iterator<T>
	{
		private int current = first;

		@Override
		public boolean hasNext()
		{
			return current != last;
		}

		@Override
		public T next()
		{
			if( !hasNext() )
				throw new NoSuchElementException();
			T elem = data[current];
			current = ( current + 1 ) % data.length;
			return elem;
		}

		@Override
		public void remove()
		{
			throw new UnsupportedOperationException();
		}
	}

}

C++版本

待续...