算法第四版第一章学习笔记

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;

public class One {
    public static void main(String[] args) {
        //oneOneThree();
       // oneOneFive();
      //  System.out.println(onOneNine(4));
//        boolean[][] booleans = randomBooleanArray(3, 4);
//        eleven(booleans);
//        boolean[][] booleans1 = switchBooleanArray(booleans);
//        System.out.println("转置后");
//        eleven(booleans1);
       // System.out.println(lg(2));

//        int[] a={1,2,2,3,3,3,4,4,4,4,5,6};
//        int[] histogram = histogram(a, 7);
//        int b=0;
//        for (int i:histogram){
//            System.out.println(i);
//            b=b+i;
//        }
//        System.out.println(b==a.length);
//        twenty1();
//        int[] a={1,2,3,8,45,110,154,542,5464};
//        System.out.println(rank(3, a));



    }
    //习题1.1.3
    public static void oneOneThree(){
        System.out.println("请输入三个整数");
        Scanner scanner=new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();
        if (a==b&&a==c){
            System.out.println("equal");
            return;
        }
        System.out.println("not equal");
    }

    public static void oneOneFive(){
        System.out.println("请输入两个浮点数");
        Scanner scanner=new Scanner(System.in);
        double a = scanner.nextDouble();
        double b = scanner.nextDouble();
        System.out.println(a<1&&a>0?(b<1&&b>0?true:false):false);
    }

    public static String onOneNine(int n){
        String s="";
        for(int i=n;i>0;i=i/2){
            s=(i%2)+s;
        }

        return s;

    }

    //编写一段代码，打印出一个二维布尔数组的内容。其中，使用*表示真，空格表示假。打印出行号和列号。
    public static void eleven(boolean[][] a){
        System.out.print("  ");
        for (int j=0;j<a[0].length;j++){
            System.out.print(" "+(j+1)+" ");
        }
        System.out.println();
        for (int i=0;i<a.length;i++){

            System.out.print(" "+(i+1)+" ");
            for (int j=0;j<a[0].length;j++){

                if (a[i][j]){
                    System.out.print("*  ");

                }else {
                    System.out.print("   ");
                }
            }
            System.out.println();
        }
    }

    //生成随机boolean数组
    public static boolean[][] randomBooleanArray(int row,int col){
        boolean [][] a=new boolean[row][col];
        Random random=new Random();
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[0].length;j++){
                a[i][j]=random.nextBoolean();
            }
        }
        return a;
    }
    //编写一段代码，打印出一个M行N列的二维数组的转置（交换行和列）。
    public static  boolean[][] switchBooleanArray(boolean[][] a){
        boolean [][] b=new boolean[a[0].length][a.length];
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[0].length;j++){
                b[j][i]=a[i][j];
            }
        }
        return b;
    }
        //1.1.14编写一个静态方法1g（），接受一个整型参数N，返回不大于log2N的最大整数。不要使用Math库。
    public static int lg(int N){
        int num=1;
        int b=0;
        while (num<=N){
            num=num*2;
            b++;
        }
        return b-1;
    }

    //编写一个静态方法histogram（），
    // 接受一个整型数组a[]和一个整数M为参数并返回一个大小为M的数组，
    // 其中第i个元素的值为整数i在参数数组中出现的次数。
    // 如果a[]中的值均在0到M-1之间，返回数组中所有元素之和应该和a.1ength相等。
    public static int[] histogram(int[] a,int M){
        int [] b=new int[M];
        for (int i=0;i<a.length;i++){
            b[a[i]]++;
        }
        return b;
    }

    //编写一个递归的静态方法计算1n（N！）的值。
    public static double twenty(double N){
        if (N>1){
            return Math.log(N)+twenty(N-1);
        }else {
            return 0;
        }
    }


    //1.1.21编写一段程序，从标准输入按行读取数据，
    // 其中每行都包含一个名字和两个整数。
    // 然后用printf（）打印一张表格，
    // 每行的若干列数据包括名字、两个整数和第一个整数除以第二个整数的结果，
    // 精确到小数点后三位。
    // 可以用这种程序将棒球球手的击球命中率或者学生的考试分数制成表格。
    public static void twenty1(){
        String s="";
        ArrayList<String> strings= new ArrayList<>();
        while (!s.equals("end")){
            Scanner scanner=new Scanner(System.in);
            s = scanner.nextLine();
            if (s.equals("end")){
                break;
            }
            String[] strs = s.split(" ");
            double i  = new Double(strs[1])/ new Double(strs[2]);
            DecimalFormat df = new DecimalFormat("0.000");
            String s1 = df.format(i);
            strings.add(strs[0]+"---"+strs[1]+"---"+strs[2]+"---"+s1);
        }

        for (String str:strings){
            System.out.println(str);
        }
    }

/*    1.1.22使用1.1.6.4节中的rank（）递归方法重新实现Binarysearch并跟踪该方法的调用。
    每当该方法被调用时，打印出它的参数10和hi并按照递归的深度缩进。
    提示：为递归方法添加一个参数来保存递归的深度。*/
    
    public static  int rank(int key,int[] a){
        return rank(key,a,0,a.length-1);
    }

    private static int deep=0;
    private static int rank(int key, int[] a, int lo, int hi) {
       deep++;
        System.out.println("low="+lo+"----hi"+hi+"---深度"+deep);
        if (lo>hi) return -1;
        int mid= lo+(hi-lo)/2;
        if (key<a[mid]){
            return rank(key,a,lo,mid-1);
        }else if(key>a[mid]){
            return rank(key,a,mid+1,hi);
        }else {
            return mid;
        }
    }



    
}