算法(Algorithms)第4版 练习 1.3.32

ADT:

    /**
     * see if Steque is empty
     * @return {@code true} Steque is empty
     * {@code false} Steque isn‘t empty
     */
    public boolean isEmpty()

    /**
     * return the size of the Steque
     * @return return the size of the Steque
     */
    public int size()

    /**
     * push one item at the beginning of the steque
     *
     * @param item the item to be pushed
     */
    public void push(Item item)

    /**
     * pop one item at the beginning of the steque
     *
     * @return return the item at the beginning of the steque
     * @throws NoSuchElementException if the steque is empty
     */
    public Item pop()

    /**
     * enqueue one item at the end of the steque
     * @param item the item to be enqueued
     */
    public void enqueue(Item item)

代码实现以及测试:

package com.qiusongde.creative;

import java.util.Iterator;
import java.util.NoSuchElementException;

import edu.princeton.cs.algs4.StdOut;

public class Steque<Item> implements Iterable<Item> {

    private Node<Item> first;
    private Node<Item> last;
    private int size;

    public Steque() {
        first = null;
        last = null;
        size = 0;
    }

    private class Node<E> {
        E item;
        Node<E> next;
    }

    /**
     * see if Steque is empty
     * @return {@code true} Steque is empty
     * {@code false} Steque isn‘t empty
     */
    public boolean isEmpty() {
        return first == null;
    }

    /**
     * return the size of the Steque
     * @return return the size of the Steque
     */
    public int size() {
        return size;
    }

    /**
     * push one item at the beginning of the steque
     *
     * @param item the item to be pushed
     */
    public void push(Item item) {
        Node<Item> oldfirst = first;

        first = new Node<Item>();
        first.item = item;
        first.next = oldfirst;

        if(oldfirst == null) {
            last = first;
        }

        size++;
    }

    /**
     * pop one item at the beginning of the steque
     *
     * @return return the item at the beginning of the steque
     * @throws NoSuchElementException if the steque is empty
     */
    public Item pop() {
        if(isEmpty())
            throw new NoSuchElementException("Steque is empty");

        Item item = first.item;
        first = first.next;

        if(isEmpty())
            last = null;

        size--;

        return item;
    }

    /**
     * enqueue one item at the end of the steque
     * @param item the item to be enqueued
     */
    public void enqueue(Item item) {
        Node<Item> oldlast = last;

        last = new Node<Item>();
        last.item = item;
        last.next = null;

        if(oldlast == null)
            first = last;
        else
            oldlast.next = last;

        size++;
    }

    @Override
    public String toString() {
        String s = "";

        Node<Item> current = first;
        while(current != null) {
            s += current.item + " ";
            current = current.next;
        }

        s += first == null ? "first:null " : "first:" + first.item + " ";
        s += last == null ? "last:null " : "last:" + last.item + " ";

        return s;
    }

    @Override
    public Iterator<Item> iterator() {
        return new StequeIterator();
    }

    private class StequeIterator implements Iterator<Item> {

        private Node<Item> current = first;
        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Item next() {

            if(!hasNext())
                throw new NoSuchElementException("Steque is empty");

            Item item = current.item;
            current = current.next;

            return item;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    public static void main(String[] args) {
        Steque<Integer> steque = new Steque<Integer>();
        StdOut.println("Initial steque:");
        StdOut.println(steque);
        StdOut.println();

        //test push function
        StdOut.println("Test push function");
        for(int i = 1; i <= 10; i++) {
            steque.push(i);
            StdOut.println("push success: " + i);
            StdOut.println(steque);
        }
        StdOut.println();

        //test pop function
        StdOut.println("Test pop function");
        for(int i = 1; i <= 10; i++) {
            int out = steque.pop();
            StdOut.println("pop success: " + out);
            StdOut.println(steque);
        }
        StdOut.println();

        //test enqueue function
        StdOut.println("Test enqueue function");
        for(int i = 1; i <= 10; i++) {
            steque.enqueue(i);
            StdOut.println("enqueue success: " + i);
            StdOut.println(steque);
        }
        StdOut.println();

        //end
        for(int i : steque) {
            StdOut.print(i + " ");
        }
        StdOut.println();

    }

}

输出结果:

Initial steque:
first:null last:null 

Test push function
push success: 1
1 first:1 last:1
push success: 2
2 1 first:2 last:1
push success: 3
3 2 1 first:3 last:1
push success: 4
4 3 2 1 first:4 last:1
push success: 5
5 4 3 2 1 first:5 last:1
push success: 6
6 5 4 3 2 1 first:6 last:1
push success: 7
7 6 5 4 3 2 1 first:7 last:1
push success: 8
8 7 6 5 4 3 2 1 first:8 last:1
push success: 9
9 8 7 6 5 4 3 2 1 first:9 last:1
push success: 10
10 9 8 7 6 5 4 3 2 1 first:10 last:1 

Test pop function
pop success: 10
9 8 7 6 5 4 3 2 1 first:9 last:1
pop success: 9
8 7 6 5 4 3 2 1 first:8 last:1
pop success: 8
7 6 5 4 3 2 1 first:7 last:1
pop success: 7
6 5 4 3 2 1 first:6 last:1
pop success: 6
5 4 3 2 1 first:5 last:1
pop success: 5
4 3 2 1 first:4 last:1
pop success: 4
3 2 1 first:3 last:1
pop success: 3
2 1 first:2 last:1
pop success: 2
1 first:1 last:1
pop success: 1
first:null last:null 

Test enqueue function
enqueue success: 1
1 first:1 last:1
enqueue success: 2
1 2 first:1 last:2
enqueue success: 3
1 2 3 first:1 last:3
enqueue success: 4
1 2 3 4 first:1 last:4
enqueue success: 5
1 2 3 4 5 first:1 last:5
enqueue success: 6
1 2 3 4 5 6 first:1 last:6
enqueue success: 7
1 2 3 4 5 6 7 first:1 last:7
enqueue success: 8
1 2 3 4 5 6 7 8 first:1 last:8
enqueue success: 9
1 2 3 4 5 6 7 8 9 first:1 last:9
enqueue success: 10
1 2 3 4 5 6 7 8 9 10 first:1 last:10 

1 2 3 4 5 6 7 8 9 10 
时间: 2024-10-10 06:51:12

算法(Algorithms)第4版 练习 1.3.32的相关文章

1.3 Bags, Queues, and Stacks(算法 Algorithms 第4版)(一)

1.3.1 package com.qiusongde; import java.util.Iterator; import java.util.NoSuchElementException; import edu.princeton.cs.algs4.StdIn; import edu.princeton.cs.algs4.StdOut; public class FixedCapacityStackOfStrings implements Iterable<String> { privat

ubuntu命令行下java工程编辑与算法(第四版)环境配置

ubuntu命令行下java工程编辑与算法(第四版)环境配置 java 命令行 javac java 在学习算法(第四版)中的实例时,因需要安装配套的java编译环境,可是在编译java文件的时候总是出各种错误,特在此总结一下. ubuntu下java环境配置 由于网上教程比较多,而且也较全面,特此摆放一个链接,跟着此教程总就可以配置好oracle的java jdk,如果想更加省事,直接在命令行下键入java,会提示安装各种开源java jdk,只需要一个命令即可: sudo apt-get i

算法(第4版)PDF下载

网盘下载地址:算法(第4版)PDF下载 – 易分享电子书PDF资源网 作者: 塞奇威克 (Robert Sedgewick) / 韦恩 (Kevin Wayne) 出版社: 人民邮电出版社 原作名: Algorithms 4th edition 译者: 谢路云 出版年: 2012-10-1 页数: 636 定价: 99.00元 装帧: 平装 内容简介 · · · · · · 本书全面讲述算法和数据结构的必备知识,具有以下几大特色. ? 算法领域的经典参考书 Sedgewick畅销著作的最新版,反

排序算法总结(C语言版)

1.    插入排序 1.1     直接插入排序 1.2     Shell排序 2.    交换排序 2.1     冒泡排序 2.2     快速排序 3.    选择排序 3.1     直接选择排序 3.2     堆排序 4.    归并排序 4.1     二路归并排序 4.2     自然合并排序 5.    分布排序 5.1     基数排序 1.插入排序 1.1      直接插入排序 将已排好序的部分num[0]~num[i]后的一个元素num[i+1]插入到之前已排好序的

算法(第四版)C#题解&mdash;&mdash;1.3.49 用 6 个栈实现一个 O(1) 队列

因为这个解法有点复杂,因此单独开一贴介绍. <算法(第四版)>中的题目是这样的: 1.3.49 栈与队列.用有限个栈实现一个队列,保证每个队列操作(在最坏情况下)都只需要常数次的栈操作. 那么这里就使用六个栈来解决这个问题. 这个算法来自于这篇论文. 原文里用的是 Pure Lisp,不过语法很简单,还是很容易看懂的. 先导知识--用两个栈模拟一个队列 如何使用两个栈来模拟一个队列操作? 这是一道很经典的题目,答案也有很多种,这里只介绍之后会用到的一种方法. 首先我们有两个栈,H 和 T,分别

算法(第4版)-1.4.9 内存

总结:本小节讲述了Java的内存分配机制以及各种数据结构所使用的内存量. 重点: 1. 计算机中的电路很大一部分的作用就是帮助程序保存一些值并在稍后取出它们. 2. 计算机上的Java对内存的使用经过了精心的设计(程序的每个值在每次运行时所需的内存量都是一样的),但实现了Java的设备非常多,而内存的使用是和实现相关的. 3. 原始数据类型的常见内存.需求见算法(第4版)-1.1.2 原始数据类型与表达式. 4. · 对象本身的开销:16字节 · 对象的引用(内存地址):8字节 · 一般内存的使

“《算法》第4版第2章‘排序’”:初级排序算法(选择、冒泡、插入、希尔)

<算法>第4版作者是Robert Sedgewick 和 Kevin Wayne. 1. 选择排序 选择排序可以说是最简单的排序方法.首先,找到数组中最小的那个元素:其次,将它与数组的第一个元素交换位置(如果第一个元素就是最小元素,那么它就和自己交换):再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置.如此往复,直到将整个数组排序. 该书中提出一个命题:对于长度为N的数组,选择排序需要大约N2/2次比较和N次交换.  程序如下: 1 void SelectionSort::s

“《算法》第四版第2章‘排序’”:初级排序算法

<算法>第4版作者是Robert Sedgewick 和 Kevin Wayne. 1. 选择排序 2. 冒泡排序 3. 插入排序 4. 希尔排序

《算法》第四版 IDEA 运行环境的搭建

<算法>第四版 IDEA 运行环境的搭建 新建 模板 小书匠 在搭建之初,我是想不到会出现如此之多的问题.我看了网上的大部分教程,都是基于Eclipse搭建的,还没有使用IDEA搭建的教程.我相信许多读者跟我一样,在学习Java的时候没有使用过命令行编译的形式去运行Java代码,直接使用Eclipse工具去进行开发的,因此,当看到书中 % java BinarySerach xxx.txt < xxx.txt 的时候,不免有点不知所措.笔者现在使用的IDE是IDEA,因此是想要在IDEA

算法导论 第三版 中文版

下载地址:网盘下载 算法导论 第三版 中文版 清晰 PDF,全书共8部分35章节,内容涵盖基础知识.排序和顺序统计量.数据结构.高级设计和分析技术.高级数据结构.图算法.算法问题选编.以及数学基础知识.非常实用的参考书和工程实践手册.此外,其他资源也已经上传,全部免费,欢迎大家下载! 第3版的主要变化 1.新增了van Emde Boas树和多线程算法,并且将矩阵基础移至附录. 2.修订了递归式(现在称为"分治策略")那一章的内容,更广泛地覆盖分治法. 3.移除两章很少讲授的内容:二项