《算法》第一章部分程序 part 2

▶ 书中第一章部分程序，加上自己补充的代码，包括简单的计时器，链表背包迭代器，表达式计算相关

 ● 简单的计时器，分别记录墙上时间和 CPU 时间。

package package01;

import java.lang.management.ThreadMXBean;
import java.lang.management.ManagementFactory;

public class class01
{
    private final ThreadMXBean threadTimer; // CPU 计时器
    private final long startWall;           // 墙上时间
    private final long startCPU;            // CPU 时间

    public class01()                        // 构造函数即开始计时
    {
        startWall = System.currentTimeMillis();
        threadTimer = ManagementFactory.getThreadMXBean();
        startCPU = threadTimer.getCurrentThreadCpuTime();
    }

    public void elapsedTime()               // 停止计时并输出结果
    {
        long finishWall = System.currentTimeMillis();
        long finishCPU = threadTimer.getCurrentThreadCpuTime();
        System.out.printf("Wall time: %d ms, CPU time:%d ns
", finishWall - startWall, finishCPU - startCPU);
    }

    public static void main(String[] args)
    {
        class01 clock = new class01();

        double sum = 0.0;
        for (int i = 1; i <= 100000000; i++)
            sum += Math.pow(i, 0.5);

        clock.elapsedTime();
    }
}

● 在链表背包数据结构的基础上实现迭代器

package package01;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class class01<Item> implements Iterable<Item>
{
    private Node<Item> first;       // 头节点
    private int n;                  // 物品数

    private static class Node<Item> // 链表结构
    {
        private Item item;
        private Node<Item> next;
    }

    public class01()
    {
        first = null;
        n = 0;
    }

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

    public int size()
    {
        return n;
    }

    public void add(Item item)
    {
        Node<Item> oldfirst = first;
        first = new Node<Item>();
        first.item = item;
        first.next = oldfirst;
        n++;
    }

    public Iterator<Item> iterator()                            // 实现迭代器
    {
        return new ListIterator<Item>(first);
    }

    private class ListIterator<Item> implements Iterator<Item>  // 迭代器的基本结构
    {
        private Node<Item> current;
        public ListIterator(Node<Item> first)
        {
            current = first;
        }

        public boolean hasNext()
        {
            return current != null;
        }
        public void remove()        // 不含 remove() 方法
        {
            throw new UnsupportedOperationException();
        }

        public Item next()
        {
            if (!hasNext())
                throw new NoSuchElementException();
            Item item = current.item;
            current = current.next;
            return item;
        }
    }

    public static void main(String[] args)
    {
        class01<String> bag = new class01<String>();
        while (!StdIn.isEmpty())
        {
            String item = StdIn.readString();
            bag.add(item);
        }

        StdOut.println("size of bag = " + bag.size());
        for (String s : bag) {
            StdOut.println(s);
        }
    }
}

■ 输入输出要点，在这里使用了 algs4 的 StdIn，需要给出多行的程序输入（用 "<" 重定向的不用考虑这部分）。在命令行中执行 java XXX 后逐行输入，用回车键隔开，全部输入完后回车到新的一行，按 Ctrl + z 结束输入程序自动向下运行；而在 IntelliJ中，点击执行后逐行输入，用回车键隔开，全部输入完后回车到新的一行，按 Ctrl + d 结束输入程序自动向下运行

● 表达式计算相关

package package01;

import edu.princeton.cs.algs4.Stack;
import edu.princeton.cs.algs4.StdIn;

public class class01
{
    public static double evaluate(String args)      // Dijkstra 双栈中缀表达式计算
    {
        Stack<String> ops = new Stack<String>();    // 算符栈
        Stack<Double> vals = new Stack<Double>();   // 操作数栈

        for (int i = 0; i<args.length(); i++)
        {
            String s = args.charAt(i) + "";

            if (s.equals("(") || s.equals(" "))     // 跳过左括号和空格
                ;
            else if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/") || s.equals("sqrt"))  // 运算符，压栈
                ops.push(s);
            else if (s.equals(")"))                 // 右括号，吐栈并计算
            {
                String op = ops.pop();
                double v = vals.pop();

                if (op.equals("+"))
                    v = vals.pop() + v;
                else if (op.equals("-"))
                    v = vals.pop() - v;
                else if (op.equals("*"))
                    v = vals.pop()*v;
                else if (op.equals("/"))
                    v = vals.pop() / v;
                else if (op.equals("sqrt"))
                    v = Math.sqrt(v);

                vals.push(v);                       // 数字压栈，缺点是只能读取一位数字
            }
            else vals.push(Double.parseDouble(s));  // 计算结果压栈
        }
        return vals.pop();
    }

    public static String correctBracket(String[] args)  // P102, Ex1.3.9，将中缀表达式缺失的左括号补全
    {
        Stack<String> ops = new Stack<String>();
        Stack<String> vals = new Stack<String>();

        for (; !StdIn.isEmpty();)
        {
            String s = StdIn.readString();

            if (s.equals("(") || s.equals(" "))                                                         // 左括号，不作任何操作
                ;
            if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/") || s.equals("sqrt"))   // 运算符，压栈
                ops.push(s);
            else if (s.equals(")"))                                                                     // 右括号，吐栈
            {
                String op = ops.pop();
                String v = vals.pop();
                if (op.equals("+") || op.equals("-") || op.equals("*") || op.equals("/"))
                    v = String.format("( %s %s %s )", vals.pop(), op, v);
                else if (op.equals("sqrt"))
                    v = String.format("( %s ( %s ) )", op, v);

                vals.push(v);
            }
            else vals.push(s);
            //else vals.push(((Double)Double.parseDouble(s)).toString());   // 输出浮点数的情况
        }
        return vals.pop();
    }

    public static void main(String[] args)// 测试输入：1 + 2 ) * 3 - 4 ) * 5 - 6 ) ) )
    {
        String output1 = correctBracket(args);
        double output2 = evaluate(output1);
        System.out.printf("%s
%f
", output1, output2);
    }
}