《算法》第一章部分程序 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("\n%d,%d\n",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("\n%d,%d,%d\n",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("\n");
 
         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("\np = " + p + "is illegal\n");
     }
 
     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");
     }
 }