java顺序结构顺序队列---顺序存储（源代码）

柔情只为你懂 2023-10-13 16:12 11阅读 0赞

1.public class SequenceQueue<T>  
    2.{  
    3.    private int DEFAULT_SIZE = 10;  
    4.    //保存数组的长度。  
    5.    private int capacity;  
    6.    //定义一个数组用于保存顺序队列的元素  
    7.    private Object[] elementData;  
    8.    //保存顺序队列中元素的当前个数  
    9.    private int front = 0;  
    10.    private int rear = 0;  
    11.    //以默认数组长度创建空顺序队列  
    12.    public SequenceQueue()  
    13.    {  
    14.        capacity = DEFAULT_SIZE;  
    15.        elementData = new Object[capacity];  
    16.    }  
    17.    //以一个初始化元素来创建顺序队列  
    18.    public SequenceQueue(T element)  
    19.    {  
    20.        this();  
    21.        elementData[0] = element;  
    22.        rear++;  
    23.    }  
    24.    /** 
    25.     * 以指定长度的数组来创建顺序队列 
    26.     * @param element 指定顺序队列中第一个元素 
    27.     * @param initSize 指定顺序队列底层数组的长度 
    28.     */  
    29.    public SequenceQueue(T element , int initSize)  
    30.    {  
    31.        this.capacity = initSize;  
    32.        elementData = new Object[capacity];  
    33.        elementData[0] = element;  
    34.        rear++;  
    35.    }  
    36.    //获取顺序队列的大小  
    37.    public int length()  
    38.    {  
    39.        return rear - front;  
    40.    }  
    41.    //插入队列  
    42.    public void add(T element)  
    43.    {  
    44.        if (rear > capacity - 1)  
    45.        {  
    46.            throw new IndexOutOfBoundsException("队列已满的异常");  
    47.        }  
    48.        elementData[rear++] = element;  
    49.    }  
    50.    //移除队列  
    51.    public T remove()  
    52.    {  
    53.        if (empty())  
    54.        {  
    55.            throw new IndexOutOfBoundsException("空队列异常");  
    56.        }  
    57.        //保留队列的rear端的元素的值  
    58.        T oldValue = (T)elementData[front];  
    59.        //释放队列的rear端的元素  
    60.        elementData[front++] = null;   
    61.        return oldValue;  
    62.    }  
    63.    //返回队列顶元素，但不删除队列顶元素  
    64.    public T element()  
    65.    {  
    66.        if (empty())  
    67.        {  
    68.            throw new IndexOutOfBoundsException("空队列异常");  
    69.        }  
    70.        return (T)elementData[front];  
    71.    }  
    72.    //判断顺序队列是否为空队列  
    73.    public boolean empty()  
    74.    {  
    75.        return rear == front;  
    76.    }  
    77.    //清空顺序队列  
    78.    public void clear()  
    79.    {  
    80.        //将底层数组所有元素赋为null  
    81.        Arrays.fill(elementData , null);  
    82.        front = 0;  
    83.        rear = 0;  
    84.    }  
    85.    public String toString()  
    86.    {  
    87.        if (empty())  
    88.        {  
    89.            return "[]";  
    90.        }  
    91.        else  
    92.        {  
    93.            StringBuilder sb = new StringBuilder("[");  
    94.            for (int i = front  ; i < rear ; i++ )  
    95.            {  
    96.                sb.append(elementData[i].toString() + ", ");  
    97.            }  
    98.            int len = sb.length();  
    99.            return sb.delete(len - 2 , len).append("]").toString();  
    100.        }  
    101.    }  
    102.}

队列是一种特殊的线性表，它只允许在表的前端(front)进行删除操作，只允许在表的后端（rear）进行插入操作。