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

▶ 书中第一章部分程序，加上自己补充的代码，包括若干种二分搜索，寻找图上连通分量数的两种算法

● 代码，二分搜索

package package01;

import java.util.Arrays;
import edu.princeton.cs.algs4.StdRandom;

public class class01
{
    public int binarySearch(int [] a, int target)   // 非递归实现
    {
        int lp = 0, rp = a.length - 1;
        for(;lp <= rp;)                             // 含等号的条件，后面修改 lp 和 rp 是使用强的跳跃条件
        {
            int mp = lp + (rp - lp) / 2;
            if (target < a[mp])
                rp = mp - 1;                        // 不要使用 mp 作为跳跃条件，会导致死循环
            else if (target > a[mp])
                lp = mp + 1;
            else
                return mp;
        }
        return -1;
    }

    public int binarySearchRecursion(int [] a, int target)// 递归实现
    {
        return binarySearchRecursionKernel(a,target,0,a.length-1);
    }

    private int binarySearchRecursionKernel(int [] a, int target, int lp, int rp)
    {
        for(;lp<=rp;)
        {
            int mp = lp + (rp - lp) / 2;
            if (target < a[mp])
                return binarySearchRecursionKernel(a,target,lp,mp - 1);
            else if (target > a[mp])
                return binarySearchRecursionKernel(a,target,mp + 1, rp);
            else
                return mp;
        }
        return -1;
    }

    public static void main(String[] args)
    {
        int N = 10000;
        int [] a = new int [N];
        for(int i=0;i<N;i++)
            a[i] = i;//(int)(StdRandom.uniform()*10000);    // 注释部分留作随机检验
        //Arrays.sort(a);

        int target = 7919;//(int)(StdRandom.uniform()*10000);
        int output1 = binarySearch(a,target);
        int output2 = binarySearchRecursion(a,target);

        System.out.printf("
%d,%d
",output1,output2);
        return;
    }
}

● 重复元素二分搜索，包括查找第一次出现、最后一次出现，以及出现多少次

package package01;

import java.util.Arrays;
import edu.princeton.cs.algs4.StdRandom;

public class class01
{
    public int binarySearchFirst(int [] a, int target)                        // 寻找第一个等于键值的目标
    {
        return binarySearchFirstKernel(a, target, 0, a.length-1);
    }

    private int binarySearchFirstKernel(int [] a, int target,int lp,int rp)    // 添加起点和终点（两端点都包含），为了能与 Count 函数配合
    {
        for(;lp<=rp;)
        {
            int mp = lp + (rp - lp) / 2;
            if (target < a[mp])
                rp = mp - 1;
            else if (target > a[mp])
                lp = mp + 1;
            else if(mp == 0 || target > a[mp-1])    // target == a[mp]，找第一个
                return mp;                          // a[mp] 就是第一个
            else                                    // a[mp] 前面还有等值的，不能强跳跃，否则可能跨空
                rp = mp;
        }
        return -1;
    }

    public int binarySearchLast(int [] a, int target)                        // 寻找最后一个等于键值的目标
    {
        return binarySearchLastKernel(a,target, 0, a.length-1);
    }

    private int binarySearchLastKernel(int [] a, int target,int lp, int rp)    // 添加起点和终点（两端点都包含）
    {
        for(;lp<=rp;)
        {
            int mp = lp + (rp - lp) / 2;
            if (target < a[mp])
                rp = mp - 1;
            else if (target > a[mp])
                lp = mp + 1;
            else if(mp == a.length-1 || target < a[mp+1])   // target == a[mp]，找最后一个
                return mp;                                  // a[mp] 就是第一个
            else                                            // a[mp] 后面还有等值的，不能强跳跃，否则可能跨空
                lp = mp;
        }
        return -1;
    }

    public int binarySearchCount(int [] a, int target)                        // 寻找等于键值的元素个数
    {
        int lp = 0, rp = a.length-1;
        for(;lp<=rp;)
        {
            int mp = lp + (rp - lp) / 2;
            if (target < a[mp])
                rp = mp - 1;
            else if (target > a[mp])
                lp = mp + 1;
            else                                            // 找到元素后，搜查首个和最后一个进行计数
                return binarySearchLastKernel(a,target,lp,rp) - binarySearchFirstKernel(a,target,lp,rp) + 1;
        }
        return -1;
    }

    public static void main(String[] args)
    {
        int N = 10000;
        int [] a = new int [N];
        for(int i=0;i<N;i++)
            a[i] = i/100;//(int)(StdRandom.uniform()*10000);    // 用于随机测试
        //Arrays.sort(a);

        int target = 29;//(int)(StdRandom.uniform()*10000);        // 可以检验边界 0，99 等情况
        int output1 = binarySearchFirst(a,target);
        int output2 = binarySearchLast(a,target);
        int output3 = binarySearchCount(a,target);

        System.out.printf("
%d,%d,%d
",output1,output2,output3);
        return;
    }
}

 ● 数组随机化

package package01;

public class class01
{
    public static void shuffle(Object[] a)
    {
        int n = a.length;
        for (int i = 0; i < n; i++)// 每次在 a[0] ~ a[i] 中随机挑一个 a[r]，交换 a[i] 与a[r]
        {
            int r = (int)(Math.random() * (i + 1));
            Object swap = a[r];
            a[r] = a[i];
            a[i] = swap;
        }
    }

    public static void shuffle2(Object[] a)
    {
        int n = a.length;
        for (int i = 0; i < n; i++)// 每次在 a[i] 右边随机挑一个 a[r]，交换 a[i] 与a[r]
        {
            int r = i + (int)(Math.random() * (n - i));
            Object swap = a[r];
            a[r] = a[i];
            a[i] = swap;
        }
    }

    public static void main(String[] args)
    {
        String[] a = { "0","1","2","3","4","5","6","7","8","9" };
        class01.shuffle(a);
        for (int i = 0; i < a.length; i++)
            System.out.print(a[i]);

        System.out.print("
");

        String[] b = { "0","1","2","3","4","5","6","7","8","9" };
        class01.shuffle2(b);
        for (int i = 0; i < a.length; i++)
            System.out.print(b[i]);

        return;
    }
}

 ● 计算图连通分量的算法。输入文件第一行是节点数，后面每行是一个连接的两端节点编号，用 java class01 < inputFile.txt 来运行。

package package01;

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

public class class01
{
    private int[] parent;   // 节点祖先标记
    private int[] rank;     // 树深度，仅根节点有效
    private int count;      // 节点数

    public class01(int n)
    {
        count = n;
        parent = new int[n];
        rank = new int[n];
        for (int i = 0; i < n; i++)
        {
            parent[i] = i;
            rank[i] = 1;    // 源代码用的是 0 
        }
    }

    public int find(int p)  // 寻找 p 的根标号
    {
        for (validate(p); p != parent[p]; p = parent[p]);
        return p;
    }

    public int count()  // 节点数
    {
        return count;
    }

    public boolean connected(int p, int q)  // 判断 p 与 q 是否连通
    {
        return find(p) == find(q);
    }

    public void union(int p, int q)         // 合并 p 和 q
    {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ)
            return;

        if (rank[rootP] < rank[rootQ])      // 较小树连接到较大树的树根上，树高按最大值计算
            parent[rootP] = rootQ;
        else if (rank[rootP] > rank[rootQ])
            parent[rootQ] = rootP;
        else                                // 两树等大，合并后树高增一
        {
            parent[rootQ] = rootP;
            rank[rootP]++;
        }
        count--;                            // 合并后连接分量减少
    }

    public void union2(int p, int q)        // 合并 p 和 q，第二种方法，更快
    {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ)
            return;

        if (rank[rootP] < rank[rootQ])
        {
            parent[rootP] = rootQ;
            rank[rootQ] += rank[rootP];     // 树高按加和计算
        }
        else
        {
            parent[rootQ] = rootP;
            rank[rootP] += rank[rootQ];
        }
        count--;
    }

    private void validate(int p)    // 判断输入的 p 是否合法
    {
        if (p < 0 || p >= parent.length)
            throw new IllegalArgumentException("
p = " + p + "is illegal
");
    }

    public static void main(String[] args)
    {
        int n = StdIn.readInt();
        class01 uf = new class01(n);
        for (; !StdIn.isEmpty();)
        {
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if (uf.connected(p, q))
                continue;
            uf.union(p, q);
            //StdOut.println(p + " " + q);
        }
        StdOut.println(uf.count() + " components");
    }
}