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

时间 2019-11-17

标签程序设计与数据结构（下）第三学习总结栏目软件设计繁體版

原文原文链接

教材学习内容总结

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 用数组实现队列

因为队列操做会修改集合的两端，所以将一段固定于索引0处要求移动元素。
非环形数组实现元素的移位，将产生O(n)的复杂度。
将数组看做是环形的，能够去除在队列的数组实现中把元素移位的须要
代码：

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
    }
}

5.6 双向链表

课后做业：

代码总览：

测试结果

pp5.1 pp5.2:前端
pp5.7:java

教材学习中的问题和解决过程

问题1：课本81页说：在链表的前端实现dequeue操做，需将一个临时变量指向链表前端的元素，而后把front变量设置为第一个节点的next指针的值。我想问为何不能够直接front.next = front.next.next
问题1解决方案：我的以为两种方法均可以。
问题2：如何理解front = (front + 1 ) % queue,length?
问题2解决方案：书上说是非环形的数组实现元素移位，将产生O(n)的复杂度，因此把数组看做是环形的，能够除去在队列的数组实现中把原始与移位的须要。

代码调试中的问题和解决过程

问题1：用数组实现链表时，使用两次enqueue方法，在使用一次dequeue方法，发现第一次实现的没有用为null。
node
问题1解决方案：toString方法出现错误：
修改前：
修改后：
出现这个问题的缘由是：当使用dequeue方法后不知道front已经发生变化。git

代码托管

上周考试错题总结

错题暂未公布

点评模板：

队友值得学习的地方：
- 课本内容记录详细，课本中的有些错误也能发现并及时纠正。
- 不懂得地方选择本身尝试，选择去敲代码验证。

点评过的同窗博客和代码

本周结对学习状况
- 20172310
- 结对学习内容
  - 第五章内容
  - 如何用数组、链表实现对列
  - 双向对列的编程

其余（感悟、思考等，可选）

虽然这一章使用的是之前的知识，好比相关的数组、栈、多态、继承什么的，可是发现本身仍是不能很熟练的运用。不少基础概念仍是很模糊，说明本身仍是得加油。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	075/200	1/1	05/20
第二周	560/500	1/2	13/38
第三周	983/1000	1/3	21/60

补充做业

（写以前说一下，以前没有看到这个补充做业，如今补充）

参考文献

用链表实现队列