20172302 《Java软件结构与数据结构》第三周学习总结

---

2018年学习总结博客总目录：[第一周](https://www.cnblogs.com/hzy0628/p/9606767.html) [第二周](https://www.cnblogs.com/hzy0628/p/9655903.html) [第三周](https://www.cnblogs.com/hzy0628/p/9700082.html)

---

教材学习内容总结

第五章 队列

1.队列是一种线性集合，其元素从一端加入，从另一端删除；队列元素是按先进先出（FIFO（First in First out））方式进行处理的。

2.队列ADT所定义的一些基本操作，见下表

操作	描述
enqueue	向列表末端添加一个元素
dequeue	从队列前端删除一个元素
first	考察队列前端的那个元素
isEmpty	判定队列是否为空
size	判定队列中的元素数目
toString	返回队列的字符串表示

3.Java API中的队列

java.util包中有接口 Queue，它提供了以下一些方法：

4.队列的两个应用：代码密钥，售票口模拟。

5.队列ADT

我们定义一个泛型QueueADT接口，表示队列的操作，把操作的一般目标与各种实现方式分开。下面是其UML描述：



下面为其代码：

public interface QueueADT<T>
{
    public void enqueue(T elem);
    public T dequeue();
    public T first();

    public boolean isEmpty();

    public int size();
    public String toString();
}

6.用链表实现队列

• 队列链表表头：

import jsjf.*;

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

    public LinkedQueue()
    {
        count = 0 ;
        head = tail = null;
    }

• enqueue操作
  
  要求将新元素放置与链表末端，即将当前末元素的next引用设置指向新元素，并重新将tail引用指向这个新添加的末元素，代码实现如下：

public void enqueue(T element) {

            LinearNode<T> node = new LinearNode<T>(element);

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

            tail = node;
            count++;

    }

• dequeue操作
  
  首先确保队列中存在至少一个可返回元素，返回该链表的首元素，然后更新head引用，代码实现如下：

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

7.用数组实现队列

这里我们首先考虑一个一般数组，由于队列操作会修改集合的两端，因此要将一端固定于索引为0处移动元素，这样便有两种可能：（1）首元素永远固定在数组索引为0处，这时添加元素时复杂度为O(1)，而删除元素时，复杂度将会变为O(n)；（2）队列的末元素始终固定在数组索引为0处，这时删除一个元素时复杂度为O（1），而添加一个新元素时则会使复杂度变为O(n)。无论以上哪种情况，都不是最好的解决办法。这时，我们可以去采用环形数组（circular array）来实现队列，即一种环形的数组结构。

• 队列的环形数组表头

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

rear的值代表数组的下一个可用单元。

• enqueue操作
  
  一个元素入列后，rear的值递增，但当enqueue操作填充了数组的最后一个单元时，rear的值需要重新设定为0。故rear的值需要这样进行更新：rear = (rear+1) % queue.length;，同时，当数组中的所有单元已经填充，这时就需要扩容这一操作，不然新元素会覆盖掉之前的首元素。
  
  具体代码实现：

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

• dequeue操作
  
  一个元素出列后，front值需要递减，进行足够的dequeue操作后，front值将达到数组的最后一个索引处。
  
  具体代码实现：

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

8.双端队列

双端队列(deque)是队列的拓展，它允许从队列的两端添加、删除和查看元素。

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

• 问题1：关于书上售票口模拟的代码的理解，即对TicketCounter类的不太明白。

Customer customer;
        Queue<Customer> customerQueue = new LinkedList<Customer>();

        int[] cashierTime = new int[MAX_CASHIERS];
        //收银员的时间标记
        int totalTime, averageTime, departs,start;

        /** process the simulation for various number of cashiers */
        for (int cashiers = 0; cashiers < MAX_CASHIERS; cashiers++)
        {
            /** set each cashiers time to zero initially */
            for (int count = 0; count < cashiers; count++)
                cashierTime[count] = 0;

            /** load customer queue */
            for (int count = 1; count <= NUM_CUSTOMERS; count++)
                customerQueue.offer(new Customer(count * 15));

            totalTime = 0;//使用的总体时间

            /** process all customers in the queue */
            while (!(customerQueue.isEmpty()))
            {
                for (int count = 0; count <= cashiers; count++)
                {
                    if (!(customerQueue.isEmpty()))
                    {
                        customer = customerQueue.poll();
                        if (customer.getArrivalTime() > cashierTime[count])
                            start = customer.getArrivalTime() ;
                        else
                            start = cashierTime[count];

                        // 离开时间的设置
                        departs = start + PROCESS;
                        customer.setDepartureTime(departs);
                        cashierTime[count] = departs;
                        //每个顾客使用的最总时间
                        totalTime += customer.totalTime();

                    }
                }
            }

            averageTime = totalTime / NUM_CUSTOMERS;
            System.out.println("Number of cashiers: " + (cashiers + 1));
            System.out.println("Average time: " + averageTime + "\n");
        }

• 问题1解决方案：这个类看了有将近20分钟才能理解其中各个循环以及各行代码其中含义。
  
  我们首先确定好每个循环，for (int cashiers = 0; cashiers < MAX_CASHIERS; cashiers++) {}，这是最外层的一个循环，这个循环要完成的是模拟售票口数量，从1开始到10结束，那么我们现在可以先把它固定下来，假定现在cashiers=4，然后继续；

for (int count = 0; count < cashiers; count++)
                cashierTime[count] = 0;

            /** load customer queue */
            for (int count = 1; count <= NUM_CUSTOMERS; count++)
                customerQueue.offer(new Customer(count * 15));

            totalTime = 0;//使用的总体时间

这几行代码是将每个cashier time初始化为0，同时再导入每位顾客来的时间，总体时间设为0，然后继续；

到了这里while (!(customerQueue.isEmpty())){}，又是一个较大的循环，当队列不为空时，售票口就需要处理，继续；

再内层的 for (int count = 0; count <= cashiers; count++) {}这个循环模拟的是各个售票口进行处理，我们刚才固定cashiers为4，那么这个循环就会进行5次，此时各个售票口进行处理；

然后，

customer = customerQueue.poll();
 if (customer.getArrivalTime() > cashierTime[count])
                            start = customer.getArrivalTime() ;
                        else
                            start = cashierTime[count];
                       departs = start + PROCESS;
                        customer.setDepartureTime(departs);
                        cashierTime[count] = departs;
                        //每个顾客使用的最总时间
                        totalTime += customer.totalTime();

这里是我理解起来最费力气的一个地方，首先是一位顾客出队进行办理，我们要计算他在这里的等待时间，比如说第第150秒来的顾客，他恰好走到了第3个售票口，那么如果他来的时间是在前一位顾客已经离开之后，那么他将不用等待，之间记开始start为他来的时间，然后加上他处理的时间，就是他离开的时间；那么，如果他来的时候，前面还有顾客没有处理完，那么这时就有等待时间了，等待的时间就是这个售票口处所记的counterTime，再加上他的处理时间，就是他离开的时间。后面的就比较容易理解了，不再叙述。

这样就完成了整个的售票口的一个模拟流程，得到了书上的结果。

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

• 问题：关于书上习题PP5.7，其中要求的双端队列可以用单链表实现，不会用双向链表进行实现。

• 问题解决方案：暂时还不会。双向链表不知道previous这个节点该怎么去使用，还不会解决。学会后补这里解决方案。

————————————————-————————————————————-

• 补上面问题解决办法：
  
  问题主要在于双端链表如何解决，如何用双端列表去实现队列？

class Link
{
	public long dData;
	public Link next;
	public Link(long dData)
	{
		this.dData = dData;
	}
	public void displayLink()
	{
		System.out.print("{" + this.dData + "}");
	}
}

首先是创建一个节点类，然后建立一个链表；

class FirstLastList
{
	Link first;
	Link last;

	public FirstLastList()
	{
		this.first = null;  //when create an object of LinkList,make sure it is empty!
		this.last = null;
	}

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

	public void insertLast(long key)	//this method will be used when I create insert() method
	{									//in Queue(not the class Queue,I just mean a Queue)
		Link newLink = new Link(key);
		if(this.isEmpty())				//if list is empty
		{
			first = newLink;			//draw a picture can help me understand it !
			last = newLink;
			newLink.next = null;
		}
		else
		{
			last.next = newLink;
			last = newLink;
			newLink.next = null;
		}
	}

	public long deleteFirst()		//this method will be used when I create remove() method in Queue(not the class Queue,I just mean a Queue)
	{
		Link current = null;
		if(this.isEmpty())
		{
			System.out.println("Your stack is empty");
			return -1;
		}
		else if(first==last)
			{
				current = first;
			    first = null;
			    last = null;
			    return current.dData;
			}
			else
			{
				current = first;
				first = first.next;
				return current.dData;
			}

	}

	public void displayList()
	{
		Link current = first;
		System.out.print("Queue (front-->rear): ");
		if(this.isEmpty())
		{
			System.out.println("Your list is empty, nothing to show!");
		}
		else
		{
			while(current!=null)
			{
				current.displayLink();
				current = current.next;
			}
			System.out.println("");
		}
	}
}

class LinkQueue
{
	FirstLastList list = new FirstLastList();	//two-ended list
	public void insert(long key)
	{
		list.insertLast(key);
	}
	public long remove()
	{
		return list.deleteFirst();
	}
	public void showQueue()
	{
		list.displayList();
	}
}

class LinkQueueApp
{
	public static void main(String[] args)
	{
		LinkQueue theQueue = new LinkQueue();
		theQueue.insert(12);	//insert four elements
		theQueue.insert(13);
		theQueue.insert(14);
		theQueue.insert(15);

		theQueue.showQueue();	//look at what is in the queue

		theQueue.remove();		//remove two elements ,from right side
		theQueue.remove();
		theQueue.showQueue();	//look at what is in the queue now!
	}
}

双端链表实际上是比单链表多了一个指向最后一个节点的引用，其他的实现与单链表相同。

代码托管

上周代码行数为8255行，现在为8867行，本周共612行

上周考试错题总结

• 1.By using the interface name as a return type, the interface doesn’t commit the method to the use of any particular class that implements a stack.（正确）

• 解析：通过使用接口名作为return类型，接口不会将该方法提交给任何实现堆栈的特定类。

• 2.The implementation of the collection operations should affect the way users interact with the collection.（错误）

• 解析：集合的操作方式不能够影响用户与集合元素的交互方式。

• 3.Inherited variables and methods can be used in the derived class as if they had been declared locally.（正确）

• 解析：继承的变量和方法可以在派生类中使用，就如它们是本地声明的一样。

结对及互评

• 本周结对学习情况

  • 20172308

  • 博客中值得学习的或问题： 博客中代码问题解决过程记录较详细，可适当添加教材内容总结。

  • 结对学习内容：学习第5章内容——队列

其他（感悟、思考等）

感悟

• 本周学习时间不长，中秋三天假期没有看到布置的作业，也没有提前进行预习，作业完成的比较匆忙，希望国庆假期结束后能投入多些时间进行学习，同时复习前面所学。

补充作业

• 我认为，现在的专业知识还差很多，同时目前所了解的大部分知识应该是属于基础知识，涉及到的专业很少，理解程度也还不够；技能方面欠缺的主要是熟练度，如果不可以参考任何资料书籍，就让我开始编写一个程序，我觉得有很大的可能是无法完成的，这也正是熟练度还不够的一个体现；能力方面我觉得差一些的是一个整体的把握，拿到一个复杂编程题目，整体的方向怎么做，从哪下手更容易，UML图如何去画，这里仍存在很多不足。
• Skill 技能

技能	课前评估	课后希望值
对编程的整体理解	2	6
程序理解	4	8
单元测试、代码覆盖率	1	6
效能分析和改进	3	7
需求分析	0	5
计划任务	2	7

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	0/0	1/1	15/15
第二周	572/572	1/2	16/31
第三周	612/1184	1/3	13/44

参考资料

• Java 实例 - 队列（Queue）用法
• Java队列
• 软件工程师自我评价表
• 双端列表