学号 2018-2019-20172309 《程序设计与数据结构(下)》第三周学习总结

Posted dky-wzw

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了学号 2018-2019-20172309 《程序设计与数据结构(下)》第三周学习总结相关的知识,希望对你有一定的参考价值。

教材学习内容总结

教材学习内容总结

5.1 队列概述

  • 队列的元素是按照FIFO方式处理的:第一个进入的元素,也就是第一个退出的元素。
  • 队列的处理方式与栈相反,栈的处理方式是LIFO。
  • 队列中的方法有enqueue,dequeue,first等同于栈中的push,pop,peek

5.2 java API中的队列

  • java集合API提供了java.util.Stack类,他实现了栈集合。但他并没有提供队列类,而是提供了一个Queue接口。
  • java.util.Stack类提供了push,pop和peek等操作,queue接口提供了两个方法add和offer。
  • queue中的方法:
    技术分享图片

5.3 使用队列:代码秘钥和售票口模拟。

  • 队列是一种可储存重复编码秘钥的遍历集合。
  • 通常用表示排队的队列来实现模拟。

5.4 队列ADT

  • 就像栈一样,我们也定义一个泛型QueueADT接口,表示队列的操作,把操作的一般目标与各种实现方式分开。

5.5 实现队列

5.5.1 用链表实现对列

  • 两个分别指向链表首元素、链表末元素的引用方便队列的链表实现。
  • 对于单向链表,可选择从末端入列,从前段出列。双向链表可以解决需要遍历链表的问题,因此在双向链表实现中,无所谓从哪端入列和出列。
  • 代码:
public class CircularArrayQueue<T> implements QueueADT<T>
{
    private final static int DEFAULT_CAPACITY = 100;
    private int front, rear, count;
    private T[] queue; 
  
    /**
     * Creates an empty queue using the specified capacity.
     * @param initialCapacity the initial size of the circular array queue
     */
    public CircularArrayQueue (int initialCapacity)
    {
        front = rear = count = 0;
        queue = (T[]) (new Object[initialCapacity]);
    }
  
    /**
     * Creates an empty queue using the default capacity.
     */
    public CircularArrayQueue()
    {
        this(DEFAULT_CAPACITY);
    }    
    
    /**
     * Adds the specified element to the rear of this queue, expanding
     * the capacity of the queue array if necessary.
     * @param element the element to add to the rear of the queue
     */
    public void enqueue(T element)
    {
        if (size() == queue.length) 
            expandCapacity();
    
        queue[rear] = element;
        rear = (rear+1) % queue.length;
    
        count++;
    }
    
    /**
     * Creates a new array to store the contents of this queue with
     * twice the capacity of the old one.
     */
    private void expandCapacity()
    {
        T[] larger = (T[]) (new Object[queue.length *2]);
    
        for (int scan = 0; scan < count; scan++)
        {
            larger[scan] = queue[front];
            front = (front + 1) % queue.length;
        }
    
        front = 0;
        rear = count;
        queue = larger;
    }
    
    /**
     * Removes the element at the front of this queue and returns a
     * reference to it. 
     * @return the element removed from the front of the queue
     * @throws EmptyCollectionException  if the queue is empty
     */
    public T dequeue() throws EmptyCollectionException
    {
        if (isEmpty())
            throw new EmptyCollectionException("queue");
    
        T result = queue[front];
        queue[front] = null;
        front = (front+1) % queue.length;
    
        count--;
    
        return result;
    }
  
    /** 
     * Returns a reference to the element at the front of this queue.
     * The element is not removed from the queue.  
     * @return the first element in the queue
     * @throws EmptyCollectionException if the queue is empty
     */
    public T first() throws EmptyCollectionException
    {
        if (isEmpty()){
            throw  new EmptyCollectionException("queue");
        }
        else
            return queue[front];
        // To be completed as a Programming Project
    }
  
    /**
     * Returns true if this queue is empty and false otherwise.
     * @return true if this queue is empty 
     */
    public boolean isEmpty()
    {
       return count==0;
        // To be completed as a Programming Project
    }
  
    /**
     * Returns the number of elements currently in this queue.
     * @return the size of the queue
     */
    public int size()
    {
        return  count;
        // To be completed as a Programming Project
    }
  
    /**
     * Returns a string representation of this queue. 
     * @return the string representation of the queue
     */
    public String toString()
    {
       String result = "";
       int a =front;
       for (int i = 0 ;i< count;i++){
           result += queue[a]+" ";
           a++;
       }
       return  result;
        // To be completed as a Programming Project
    }
}

5.5.2 用数组实现队列

  • 代码:
public class LinkedQueue<T> implements QueueADT<T>
{
    private int count;
    private LinearNode<T> head, tail;

    /**
     * Creates an empty queue.
     */
    public LinkedQueue()
    {
        count = 0;
        head = tail = null;
    }

    /**
     * Adds the specified element to the tail of this queue.
     * @param element the element to be added to the tail of the queue
     */
    public void enqueue(T element)
    {
        LinearNode<T> node = new LinearNode<T>(element);

        if (isEmpty())
            head = node;
        else
            tail.setNext(node);

        tail = node;
        count++;
    }

    /**
     * Removes the element at the head of this queue and returns a
     * reference to it. 
     * @return the element at the head of this queue
     * @throws EmptyCollectionException if the queue is empty
     */
    public T dequeue() throws EmptyCollectionException
    {
        if (isEmpty())
            throw new EmptyCollectionException("queue");

        T result = head.getElement();
        head = head.getNext();
        count--;

        if (isEmpty())
            tail = null;

        return result;
    }
   
    /**
     * Returns a reference to the element at the head of this queue.
     * The element is not removed from the queue.  
     * @return a reference to the first element in this queue
     * @throws EmptyCollectionException if the queue is empty
     */
    public T first() throws EmptyCollectionException
    {
        if (isEmpty()){
            throw  new EmptyCollectionException("queue");
        }
        else
            return head.getElement() ;
        // To be completed as a Programming Project
    }

    /**
     * Returns true if this queue is empty and false otherwise. 
     * @return true if this queue is empty 
     */
    public boolean isEmpty()
    {
        return  count == 0;
        // To be completed as a Programming Project
    }
 
    /**
     * Returns the number of elements currently in this queue.
     * @return the number of elements in the queue
     */
    public int size()
    {
        return count;
        // To be completed as a Programming Project
    }

    /**
     * Returns a string representation of this queue. 
     * @return the string representation of the queue
     */
    public String toString()
    {
        String result = "" ;
        while(head!=null){
            result+=head.getElement()+" ";
            head = head.getNext();
        }
        return  result;
        // To be completed as a Programming Project
    }
}

以上是关于学号 2018-2019-20172309 《程序设计与数据结构(下)》第三周学习总结的主要内容,如果未能解决你的问题,请参考以下文章

编写一个c语言程序,实现录入学生学号和姓名信息的功能

C语言用定义结构类型的方法,编写程序建立一个具有学生学号姓名总分和联系电话的记录文件。编写程序从键盘上输入学号可以查到此人的其他信息。

学号 2017-2018-20172309 《程序设计与数据结构》实验四报告

学号 2018-2019-1 《程序设计与数据结构》实验二报告

# 学号 2017-2018-20172309 《程序设计与数据结构》实验三报告

学号 2017-2018-2 《程序设计与数据结构》实验五报告