『算法』读书笔记 1.2 Java语法 - 练习代码总结

Chapter 1

本章结构

1.1Java语法

1.2数据抽象 练习部分

1.3集合类抽象数据类型：背包 (Bags) 、队列 (Queues) 、栈 (Stacks)

1.4面向操作的抽象数据类型

1.5连通性问题－Case Study: Union - Find ADT

 

1.2.1 编写一个Point2D的用例，从命令行接受一个整数N。在单位正方形内生成N个随机点，然后计算两点之间的最近距离

问题：用例中所采用的双层循环计算两点之间距离的方法有无更好的实现？

public class ShortDistance {
    public static void main(String[] args)
    {
        int N = Integer.parseInt(args[0]);
        Point2D[] p = new Point2D[N];
        double min = 1.00;

        //Generation of N points
        for (int i = 0; i < N; i++)
        {
            double x = Math.random();
            double y = Math.random();
            p[i] = new Point2D(x, y);
            p[i].draw();
        }

        //Calculation of minimum distance between two points
        for (int i =0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (i != j)
                {
                if (p[i].distanceTo(p[j]) < min )
                    {
                        min = p[i].distanceTo(p[j]);
                    }
                }
            }

        }
        StdOut.print("the minimum distance is " + min);
    }

}

ex1.2.3 编写一个Interval1D的用例，从命令行接受一个整数N。从标准输入中读取N个间隔（每个间隔由一对double值定义）并打印出所有相交的间隔对

总结：

1.从标准输入中读取数据可以直接利用double[] d = StdIn.readDoubles()实现

2.双层遍历循环中，外层范围限制为[0,N/2)，内层范围限制为[N/2,N)，这样可以避免循环后再处理重复比较的问题

public class Interval1DClient
{
    public static void main(String[] args)
    {
        int N = Integer.parseInt(args[0]);
        Interval1D[] interval = new Interval1D[N];
        double[] d = StdIn.readDoubles();

        for (int i = 0; i < N; i++)
        {
            interval[i] = new Interval1D(d[2*i], d[2*i+1]);
           // StdDraw.line(interval[i].left(), .5, interval[i].right(), 5);
        }

        /*
         * The following codes are for test only
        for (int i = 0; i < N; i++)
        {
            //interval[i] = new Interval1D(d[2*i], d[2*i+1]);
            StdDraw.line(interval[i].left(), .5, interval[i].right(), .5);
        }
        */

        for (int i = 0; i < N / 2; i++)
        {
            for (int j = N / 2; j < N; j++)
            {
                if (i != j)
                    if (interval[i].intersects(interval[j]))
                    {
                        StdDraw.line(interval[i].left(), .5, interval[i].right(), .5);
                        StdOut.println("Interval[" + i + "] intersects with interval[" + j + "].");
                    }

            }
        }

    }
}

  

ex1.2.9 修改BinarySearch，使用COunter统计在键数被查找的次数并在查找全部结束后打印该值

import java.util.Arrays;

public class BinarySearchCount {

    // precondition: array a[] is sorted
    public static int rank(int key, int[] a, Counter keys) {
        int lo = 0;
        int hi = a.length - 1;
        keys.increment();
        while (lo <= hi) {
            // Key is in a[lo..hi] or not present.
            int mid = lo + (hi - lo) / 2;
            if      (key < a[mid]) hi = mid - 1;
            else if (key > a[mid]) lo = mid + 1;
            else return mid;
        }
        return -1;
    }

    public static void main(String[] args) {
        Counter keys = new Counter("keys");
        int[] whitelist = In.readInts(args[0]);

        Arrays.sort(whitelist);

        // read key; print if not in whitelist
        while (!StdIn.isEmpty()) {
            int key = StdIn.readInt();
            if (rank(key, whitelist, keys) == -1)
                StdOut.println(key);
        }
        StdOut.println("Summary: " + keys + " examined");
    }
}

 

 

ex1.2.10 编写一个VisualCounter类，支持加一和减一操作。它的构造函数接受两个参数N和max，其中N指定了操作的最大次数，max指定了计数器的最大绝对值。作为副作用，用图像显示每次计数器变化后的值。

总结：

1.构造函数中应该把绘图相关的参数给初始化，例如X和Y轴的取值范围以及笔触的大小

2.Y轴的取值范围特别注意，为正负max，因为要考虑绝对值空间

public class VisualCounter {
    private int count;//Record the times
    private int val;//Record value of the Counter
    private int x = 0;
    int maxOperation;
    int maxVal;

    public VisualCounter(int N, int max)
    {
        maxOperation = N;
        maxVal = max;
        StdDraw.setXscale(0, N);
        StdDraw.setYscale(-max, max);
        StdDraw.setPenRadius(.05);
    }

    public int tally()
    {    return count;    }

    public void increment()
    {
        if (count < maxOperation && val < maxVal)
        {
            count++;
            val++;
            x++;
            StdDraw.point(x, val);
        }
    }

    public void decrement()
    {
        if (count < maxOperation && val > -maxVal)
        {
            count++;
            val--;
            x++;
            StdDraw.point(x, val);
        }
    }

    //Test Client
    public static void main(String[] args)
    {
        VisualCounter VC = new VisualCounter(10, 20);


        VC.increment();
        VC.increment();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();
        VC.decrement();



        StdOut.println(VC.tally());


    }

}

 

 

 

ex1.2.11 根据Date的API实现一个SmartDate类型，在日期非法时抛出一个异常

ex1.2.12 为SmartDate添加一个方法dayOfTheWeek()，为日期中每周的日返回Monday、Tuesday、Wednesday、Thursday……假定是21世纪

总结：

1.学习Switch Case语句中多个值匹配同一个代码块的写法

2.Zeller公式可以用来计算dayOfTheWeek

问题：日期合法性判断有无更好的实现？

public class SmartDate {
    private final int month;
    private final int day;
    private final int year;
    public int dayOfTheWeek;

    public SmartDate(int m, int d, int y)
    {
        month = m;
        day = d;
        year = y;
        if (month < 13 && month >0 )
        {
            switch(month)
            {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if (day > 31 || day < 1)
                    throw new RuntimeException("Error: illegal Date");
            break;

            case 4:
            case 6:
            case 9:
            case 11:
                if (day > 30 || day < 1)
                    throw new RuntimeException("Error: illegal Date");
            break;

            case 2:
                if (year % 4 == 0)
                {
                    if (day > 29 || day < 1)
                        throw new RuntimeException("Error: illegal Date");
                }
                else if (day > 28 || day < 1)
                    throw new RuntimeException("Error: illegal Date");
            }
        }
        else throw new RuntimeException("Error: illegal Date");
    }

    public int month()
    {    return month;    }
    public int day()
    {    return day;        }
    public int year()
    {    return year;    }
    public void dayOfTheWeek()
    {
        dayOfTheWeek = (year+(year/4)-15+(26*(month+1)/10)+day-1)%7;//using Zeller formula to obtain the value
        switch(dayOfTheWeek)
        {
        case 1:
            StdOut.println("Monday");
            break;
        case 2:
            StdOut.println("Tuesday");
            break;
        case 3:
            StdOut.println("Wednesday");
            break;
        case 4:
            StdOut.println("Thursday");
            break;
        case 5:
            StdOut.println("Friday");
            break;
        case 6:
            StdOut.println("Saturday");
            break;
        case 7:
            StdOut.println("Sunday");
            break;
        }
    }


    public static void main(String[] args)
    {
        SmartDate SD = new SmartDate(Integer.parseInt(args[0]),Integer.parseInt(args[1]),Integer.parseInt(args[2]));
        SD.dayOfTheWeek();
    }

}