solutions of wanghuan

实操演练/solutions/s001-[njustwh2014].java

@@ -0,0 +1,122 @@
+import java.util.*;
+public class Solution {
+
+    //////////////////////////////////////////////////////////////
+    //                                                          //
+    //            请在此处添加你的代码（函数）                  //
+    //                                                          //
+    //////////////////////////////////////////////////////////////
+    //请务必保证你的方法名（函数名）与题目中所给的一致，否则无法编译
+    //start
+    //输入参数:
+    //    numbers:     输入的数组
+    //    length:      输入数组的长度
+    //    duplication: 输出数组，判题程序会取duplication[0] 作为重复的数字
+    //    这里要特别注意~返回重复的第一个，赋值duplication[0]
+    public boolean duplicate(int numbers[],int length,int [] duplication) {
+        Map temp_map=new HashMap();
+        for(int i=0;i<length;i++){
+
+            if(temp_map.get(numbers[i])!=null){
+                duplication[0]=numbers[i];
+                return true;
+            }
+            else{
+                temp_map.put(numbers[i],numbers[i]);
+            }
+
+        }
+
+
+        return false;
+
+    }
+    //end
+
+
+    class Test{
+        public int[] numbers;
+        public int length;
+        public int[] duplication;
+        public boolean result ;
+        public Test(int[] numbers,int length,boolean result,int num){
+            this.numbers = numbers;
+            this.length = length;
+            this.result = result;
+            duplication = new int[1];
+            duplication[0] = num;
+        }
+        public Test(){
+        }
+        public void printSelf(){
+            System.out.print("正确输出为："+result);
+            if(result) {
+                System.out.println(" 重复数字是：" + duplication[0]);
+            }else{
+                System.out.println(" ");
+            }
+            System.out.println("当前测试用例为：");
+            if(numbers==null){
+                System.out.println("空数组引用");
+                return;
+            }
+            if(numbers.length==0){
+                System.out.println("空数组");
+                return;
+            }
+            for(int i = 0;i<numbers.length;i++){
+                System.out.print(numbers[i]+" ");
+            }
+            System.out.println(" ");
+        }
+    }
+    public static void main(String args[]){
+        Solution solution = new Solution();
+        int total = 8;
+        Test[] tests = new Test[total];
+        tests[0] = solution.new Test(new int[]{2,3,1,0,2,5,3},7,true,2);
+        tests[1] = solution.new Test(new int[]{2,3,4,0,9,8,7,1,1},9,true,1);
+        tests[2] = solution.new Test(new int[]{2,3,4,0,9,8,7,10,13},9,false,0);
+        tests[3] = solution.new Test(new int[]{},0,false,0);
+        tests[4] = solution.new Test(null,0,false,0);
+        tests[5] = solution.new Test(new int[]{2,1,1,2},4,true,1);
+        tests[6] = solution.new Test(new int[]{1},1,false,0);
+        tests[7] = solution.new Test(new int[]{1,1},2,true,1);
+        int i = 0;
+        long runtimeCount = System.currentTimeMillis();//获取当前系统时间(毫秒)
+        try {
+            for (i = 0; i < total; i++) {
+                int temp = tests[i].duplication[0];
+                tests[i].duplication[0] = 0;
+                if(!solution.compare(tests[i].result,temp,solution.duplicate(tests[i].numbers,tests[i].length,tests[i].duplication),tests[i].duplication[0])){
+                    solution.printFail(i*100/total,String.valueOf(solution.duplicate(tests[i].numbers,tests[i].length,tests[i].duplication)));
+                    tests[i].duplication[0] = temp;
+                    tests[i].printSelf();
+                    return;
+                }
+            }
+            solution.printSuccess();
+            int runtime = (int)(System.currentTimeMillis()-runtimeCount);
+            System.out.println("运行时间为："+runtime+"ms");
+        }catch (Exception e){
+            solution.printFail(i*100/total,"异常！");
+            tests[i].printSelf();
+            System.out.println("出现异常!");
+            e.printStackTrace();
+        }
+    }
+    private void printSuccess(){
+        System.out.println("恭喜！你通过了所有的测试用例");
+    }
+    private void printFail(int percent,String str){
+        System.out.println("你未能通过所有的测试用例！("+percent+"%)");
+        System.out.println("你的输出为："+str);
+    }
+    private boolean compare(boolean test,int testDup,boolean standard,int standardDup){
+        if(test==standard&&testDup==standardDup){
+            return true;
+        }
+        return false;
+    }
+}
+

实操演练/solutions/s002-[njustwh2014].java

@@ -0,0 +1,92 @@
+import java.util.*;
+public class Solution {
+
+    //////////////////////////////////////////////////////////////
+    //                                                          //
+    //            请在此处添加你的代码（函数）                  //
+    //                                                          //
+    //////////////////////////////////////////////////////////////
+    //start
+    //target：输入的大矩形的长
+    //返回值：一共有多少种方法
+    //分治法 加 递归求解
+    public int RectCover(int target) {
+        if(target<=0)
+            return 1;
+        else if(target==1)
+            return 1;
+        else if(target==2)
+            return 2;
+        else
+            return RectCover(target-1)+RectCover(target-2);
+    }
+    //end
+
+
+    class Test{
+        public int target;
+        public int result;
+        public Test(int target,int result){
+            this.target = target;
+            this.result = result;
+        }
+        public Test(){
+        }
+        public void printSelf(){
+            System.out.println("正确输出为："+result);
+            System.out.println("当前测试用例为："+target);
+        }
+    }
+    public static void main(String args[]){
+        Solution solution = new Solution();
+        int total = 6;
+        Test[] tests = new Test[total];
+        tests[0] = solution.new Test(0,1);
+        tests[1] = solution.new Test(1,1);
+        tests[2] = solution.new Test(2,2);
+        tests[3] = solution.new Test(5,8);
+        tests[4] = solution.new Test(10,89);
+        tests[5] = solution.new Test(20,10946);
+        int i = 0;
+        long runtimeCount = System.currentTimeMillis();//获取当前系统时间(毫秒)
+        try {
+            for (i = 0; i < total; i++) {
+                if(!solution.compare(tests[i].result,solution.RectCover(tests[i].target))){
+                    solution.printFail(i*100/total,String.valueOf(solution.RectCover(tests[i].target)));
+                    tests[i].printSelf();
+                    return;
+                }
+            }
+            solution.printSuccess();
+            int runtime = (int)(System.currentTimeMillis()-runtimeCount);
+            System.out.println("运行时间为："+runtime+"ms");
+        }catch (Exception e){
+            solution.printFail(i*100/total,"异常！");
+            tests[i].printSelf();
+            System.out.println("出现异常!");
+            e.printStackTrace();
+        }
+    }
+    private void printSuccess(){
+        System.out.println("恭喜！你通过了所有的测试用例");
+    }
+    private void printFail(int percent,String str){
+        System.out.println("你未能通过所有的测试用例！("+percent+"%)");
+        System.out.println("你的输出为："+str);
+    }
+    private boolean compare(int test,int standard){
+        if(test==standard){
+            return true;
+        }
+        return false;
+    }
+}
+
+
+
+
+
+
+
+
+

实操演练/solutions/s003-[njustwh2014].java

@@ -0,0 +1,120 @@
+import java.util.*;
+public class Solution {
+
+    //////////////////////////////////////////////////////////////
+    //                                                          //
+    //            请在此处添加你的代码（函数）                  //
+    //                                                          //
+    //////////////////////////////////////////////////////////////
+    //start
+    //input:输入数组
+    //k：需要获取输入数组的最小的k个数
+    //返回值：以ArrayList的结构返回最小的k个数
+    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
+        ArrayList<Integer> ret=new ArrayList<Integer>(k);
+        if(input==null){
+            return ret;
+        }
+        else if(k>input.length){
+            return ret;
+        }
+        TreeSet<Integer> temp_tree=new TreeSet<>();
+        for(int i=0;i<input.length;i++){
+            temp_tree.add(input[i]);
+        }
+        int  i=0;
+        Iterator it_temp_tree=temp_tree.iterator();
+        while(it_temp_tree.hasNext() && i<k){
+            ret.add((Integer) it_temp_tree.next());
+            i++;
+        }
+        return ret;
+
+    }
+    //end
+
+
+    class Test{
+        public int k;
+        public int[] input;
+        public ArrayList<Integer> result;
+        public Test(int k,int[] input,ArrayList<Integer> result){
+            this.k = k;
+            this.input=input;
+            this.result = result;
+        }
+        public Test(){
+        }
+        public void printSelf(){
+            System.out.println("正确输出为："+result);
+            System.out.println("当前测试用例为：");
+            if(input==null){
+                System.out.println("空数组引用");
+                return;
+            }
+            if(input.length==0){
+                System.out.println("空数组");
+                return;
+            }
+            for(int i : input) {
+                System.out.print(i);
+            }
+            System.out.println(" k="+k);
+        }
+    }
+    public static void main(String args[]){
+        Solution solution = new Solution();
+        int total = 8;
+        Test[] tests = new Test[total];
+        tests[0] = solution.new Test(4,new int[]{4,5,1,6,2,7,3,8},new ArrayList<>(Arrays.asList(new Integer[]{1,2,3,4})));
+        tests[1] = solution.new Test(0,new int[]{},new ArrayList<>());
+        tests[2] = solution.new Test(0,null,new ArrayList<>());
+        tests[3] = solution.new Test(1,new int[]{1},new ArrayList<>(Arrays.asList(new Integer[]{1})));
+        tests[4] = solution.new Test(0,new int[]{4,5,1,6,2,7,3,8},new ArrayList<>());
+        tests[5] = solution.new Test(8,new int[]{4,5,1,6,2,7,3,8},new ArrayList<>(Arrays.asList(new Integer[]{4,5,1,6,2,7,3,8})));
+        tests[6] = solution.new Test(8,new int[]{11,33,4,5,1,6,99,384,27,2,7,3,8,10},new ArrayList<>(Arrays.asList(new Integer[]{4,5,1,6,2,7,3,8})));
+        tests[7] = solution.new Test(2,new int[]{1,99},new ArrayList<>(Arrays.asList(new Integer[]{1,99})));
+        int i = 0;
+        long runtimeCount = System.currentTimeMillis();//获取当前系统时间(毫秒)
+        try {
+            for (i = 0; i < total; i++) {
+                if(!solution.compare(tests[i].result,solution.GetLeastNumbers_Solution(tests[i].input,tests[i].k))){
+                    solution.printFail(i*100/total,String.valueOf(solution.GetLeastNumbers_Solution(tests[i].input,tests[i].k)));
+                    tests[i].printSelf();
+                    return;
+                }
+            }
+            solution.printSuccess();
+            int runtime = (int)(System.currentTimeMillis()-runtimeCount);
+            System.out.println("运行时间为："+runtime+"ms");
+        }catch (Exception e){
+            solution.printFail(i*100/total,"异常！");
+            tests[i].printSelf();
+            System.out.println("出现异常!");
+            e.printStackTrace();
+        }
+    }
+    private void printSuccess(){
+        System.out.println("恭喜！你通过了所有的测试用例");
+    }
+    private void printFail(int percent,String str){
+        System.out.println("你未能通过所有的测试用例！("+percent+"%)");
+        System.out.println("你的输出为："+str);
+    }
+    private boolean compare(ArrayList<Integer> test,ArrayList<Integer> standard){
+        if(test.size()!=standard.size()){
+            return false;
+        }
+        for(int i = 0;i<standard.size();i++){
+            if(!test.contains(standard.get(i))){
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+
+
+
+

算法和数据结构基础/1 算法分析基础-Java/算法分析基础.md

@@ -18,7 +18,7 @@
 
 首先需要明确，输入规模在算法效率分析过程中，是一个很重要的问题。因为，显然，在算法相同、计算机硬件相同的条件下，算法输入规模越大，运行时间越长（比如，数组越大，对数组排序需要的时间越长）。因此，算法效率和输入规模$n$紧密关联。
 
-那么，如何确定这个**输入规模$n$**呢？
+那么，如何确定这个**输入规模$n$** 呢？
 
 在大多数情况下，这是显而易见的。例如，对于排序、查找等列表相关的算法，输入规模$n$就是列表的长度。
 

算法和数据结构基础/3.1 暴力美学-排序/code/java/BubbleSort.java

@@ -2,24 +2,37 @@
 
 public class BubbleSort extends SortAlgorithm
 {
-    /**
-     * Sorts the input array.
-     *
-     * @param array Array to be sorted.
-     */
     public void sort(int[] array) {
 
         for (int i = 0; i < array.length-1 ; i++) {
             for (int j = 0; j < array.length - 1 - i; j++) {
-                // check if we need to swap
+                // 交换
                 if (array[j] > array[j+1]) {
+                    new Thread(new Runnable() {
+                        public void run() {
+                            while (true) {
+                                test();
+                                try {
+                                    Thread.sleep(1);
+                                } catch (InterruptedException e) {
+                                    // TODO Auto-generated catch block
+                                    e.printStackTrace();
+                                }
+                            }
+                        }
+                        private void test() {
+                            // TODO Auto-generated method stub
+                        }
+                        public Runnable start() {
+                            // TODO Auto-generated method stub
+                            return null;
+                        }
+                    }.start());
                     Integer temp = array[j];
                     array[j] = array[j+1];
                     array[j+1] = temp;
                 }
             }
         }
-
-    } // end of sort()
-
-} // end of class BubbleSort
+    }
+}