基于案例的软件构造教程第三章答案

2.

ADT stack

/**
 * 栈
 * @param <T>
 */
public interface Stack<T> {
    /**
     * 压栈
     * @param t
     */
    void push(T t);
    /**
     * 出栈
     * @return
     */
    T pop();
    /**
     * 获得栈顶元素
     * @return
     */
    T top();
}



//实现
public class StackWithArray<T> implements Stack<T> {
    public StackWithArray() {
        this(1); // 默认大小为 1
    }

    public StackWithArray(int size) {
        this.top = -1;
        this.size = size;
        this.array = (T[]) new Object[size];
    }

    private T[] array;
    private int size;
    private int top;

    /**
     * 压栈
     *
     * @param t
     */
    public void push(T t) {
        if (top == size - 1) extend();
        array[++top] = t;
    }

    /**
     * 出栈
     *
     * @return
     */
    public T pop() {
        if (top < 0) return null;
        return array[top--];
    }

    /**
     * 获得栈顶元素
     *
     * @return
     */
    public T top() { 
        return array[top]; 
    }

    /**
     * 扩展数组大小，每次扩展为当前大小的两倍
     */
    private void extend() {
        T[] newArray = (T[]) new Object[size * 2];
        for (int i = 0; i < size; i++) newArray[i] = array[i];
        array = newArray;
        size *= 2;
    }
}



//测试
public class StackTest {
    @Test
    public void test_stack_with_array() {
        Stack<Integer> stack = new StackWithArray<Integer>();
        Integer[] nums = new Integer[]{0, 4, 1, 5, 2, 6, 3, 0, 4, 7};
        for(int i=0 ; i<10 ; i++) stack.push(nums[i]);
        // 检查是否符合 LIFO 的顺序
        for(int i=9 ; i>=4 ; i--) {
            assertEquals(nums[i], stack.pop());
        }
        // 检查栈顶
        assertEquals((Integer)5, stack.top());
    }
}

ADT queue

/**
 * 队列
 * @param <T>
 */
public interface Queue<T> {

    /**
     * 入队
     * @param t
     */
    void enqueue(T t);

    /**
     * 出队
     * @return
     */
    T dequeue();

    /**
     * 获取队首元素
     * @return
     */
    T getFirst();

    /**
     * 获取队尾元素
     * @return
     */
    T getLast();

    /**
     * 判断队列是否为空
     * @return
     */
    boolean empty();
}


//实现
QueueCircular.java
public class QueueCircular<T> implements Queue<T> {

    public QueueCircular() {
        this(10);
    }

    public QueueCircular(int size) {
        this.Q = (T[]) new Object[size];
        this.front = this.rear = 0;
        this.full = false;
    }

    private T[] Q;
    private int front;
    private int rear;
    private boolean full;

    /**
     * 入队
     *
     * @param t
     */
    public void enqueue(T t) {
        if (full) return;
        Q[rear] = t;
        rear = (rear + 1) % Q.length;
        if (rear == front) full = true;
    }

    /**
     * 出队
     *
     * @return
     */
    public T dequeue() {
        if (front == rear && !full) return null;
        if (full) full = false;
        T res = Q[front];
        front = (front + 1) % Q.length;
        return res;
    }

    /**
     * 获取队首元素
     *
     * @return
     */
    public T getFirst() {
        return empty() ? null : Q[front];
    }

    /**
     * 获取队尾元素
     *
     * @return
     */
    public T getLast() {
        return empty() ? null : Q[(rear - 1 + Q.length) % Q.length];
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean empty() {
        return front == rear && !full;
    }
}


//测试
QueueTest.java

public class QueueTest {
    @Test
    public void test_queue_circular() {
        Queue<Integer> queue = new QueueCircular<Integer>();
        // 入队 11 个数
        for (int i = 1; i < 22; i += 2) {
            queue.enqueue(i);
        }
        // 出队 11 个数，检查是否符合 FIFO 顺序
        for (int i = 1; i < 20; i += 2) {
            assertEquals((Integer) i, queue.dequeue());
        }
        // 查看指针问题
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            assertEquals((Integer) i, queue.dequeue());
        }
        for (int i = 1; i < 20; i += 2) queue.enqueue(i);
        // 查看临界条件下的出入栈
        for (int i = 1; i < 20; i += 2) {
            assertEquals((Integer) i, queue.dequeue());
            queue.enqueue(i);
        }
    }
}

ADT link

package adt.linkedlist;

/**
 * 链表
 *
 * @param <T>
 */
public interface LinkedList<T> {

    /**
     * 添加元素到尾部
     * @param t
     */
    default void add(T t) {
        add(size(), t);
    }

    /**
     * 添加元素到指定下标
     * @param index
     * @param t
     */
    void add(int index, T t);

    /**
     * 获取指定下标元素
     * @param index
     * @return
     */
    T get(int index);

    /**
     * 获取第一个元素
     * @return
     */
    default T getFirst() {
        return get(0);
    }

    /**
     * 获取最后一个元素
     * @return
     */
    default T getLast() {
        return get(size() - 1);
    }

    /**
     * 移除指定下标元素
     * @param index
     * @return
     */
    T remove(int index);

    /**
     * 移除第一个元素
     * @return
     */
    default T removeFirst() {
        return remove(0);
    }

    /**
     * 移除最后一个元素
     * @return
     */
    default T removeLast() {
        return remove(size() - 1);
    }

    /**
     * 获取链表大小
     * @return
     */
    int size();

    /**
     * 判断链表是否为空
     * @return
     */
    boolean empty();
}

//由于篇幅限制，以单向链表为例
LinkedListSingle.java
package adt.linkedlist;

public class LinkedListSingle<T> implements LinkedList<T> {

    private static class SingleNode<T> {
        T data;
        SingleNode<T> next;

        public SingleNode(T data) {
            this.data = data;
        }

        @Override
        public String toString() {
            return data + (next == null ? "" : " -> " + next);
        }
    }

    private SingleNode<T> head;

    /**
     * 添加元素到指定下标
     *
     * @param index
     * @param t
     */
    @Override
    public void add(int index, T t) {
        if (index < 0 || index > size()) return;
        SingleNode<T> cur = head, node = new SingleNode<>(t);
        if (index == 0) {
            node.next = cur;
            head = node;
            return;
        }
        while (--index > 0) cur = cur.next;
        node.next = cur.next;
        cur.next = node;
    }

    /**
     * 获取指定下标元素
     *
     * @param index
     * @return
     */
    @Override
    public T get(int index) {
        if (index < 0 || index >= size()) return null;
        SingleNode<T> cur = head;
        while (index-- > 0) cur = cur.next;
        return cur.data;
    }

    /**
     * 移除指定下标元素
     *
     * @param index
     * @return
     */
    @Override
    public T remove(int index) {
        if (index < 0 || index >= size()) return null;
        SingleNode<T> cur = head;
        if (index == 0) {
            head = head.next;
            return cur.data;
        }
        while (--index > 0) cur = cur.next;
        SingleNode<T> res = cur.next;
        cur.next = cur.next.next;
        return res.data;
    }

    /**
     * 获取链表大小
     *
     * @return
     */
    @Override
    public int size() {
        SingleNode<T> cur = head;
        int size = 0;
        while (cur != null) {
            cur = cur.next;
            size++;
        }
        return size;
    }

    /**
     * 判断链表是否为空
     *
     * @return
     */
    @Override
    public boolean empty() {
        return head == null;
    }
}

4.

软件设计是采用编程或脚本语言表达并解决现实需求的一门科学与艺术，即是一个解决用户需求的科学

任何工程领域，设计包含相关的科学知识，制造或建造是依据设计的模型来将其变为现实，软件开发中的设计首先需要数据结构，计算机组成原理，编程语言等基础科学知识通过对需求的理解和抽象创造模型，编程来实现这个模型，软件设计与工程设计最大的区别是软件设计设计出的软件仍然是一个抽象的实体，工程设计为现实的实体

6.

调试涵盖了分析、推理、演绎、归纳、和实验等高智力活动，在调试程序时，需要分析程序，理解用户需求在程序中是如何实现的，猜测错误可能的原因，在程序中可能位置，然后运行程序验证假设。

8.

注解也叫元数据，是一种代码级别的说明，与类接口，枚举在同一层次，可以用来对方法，类，参数进行说明

@BeforeClass – 表示在类中的任意public static void方法执行之前执行
@AfterClass – 表示在类中的任意public static void方法执行之后执行
@Before – 表示在任意使用@Test注解标注的public void方法执行之前执行
@After – 表示在任意使用@Test注解标注的public void方法执行之后执行
@Test – 使用该注解标注的public void方法会表示为一个测试方法