Chapter 02 section 05 C++ codes updated, Java codes added.

Author: liuyubobobo

02-Time-Complexity/Course Code (C++)/05-Recursion-Time-Complexity/main.cpp

@@ -6,48 +6,48 @@ using namespace std;
 // binarySearch
 int binarySearch(int arr[], int l, int r, int target){
 
-    if( l > r )
+    if(l > r)
         return -1;
 
-    int mid = l + (r-l)/2;
-    if( arr[mid] == target )
+    int mid = l + (r - l) / 2;
+    if(arr[mid] == target)
         return mid;
-    else if( arr[mid] > target )
-        return binarySearch(arr, l, mid-1, target);
+    else if(arr[mid] > target)
+        return binarySearch(arr, l, mid - 1, target);
     else
-        return binarySearch(arr, mid+1, r, target);
+        return binarySearch(arr, mid + 1, r, target);
 
 }
 
 // sum
-int sum( int n ){
+int sum(int n){
 
-    assert( n >= 0 );
+    assert(n >= 0);
 
-    if( n == 0 )
+    if(n == 0)
         return 0;
-    return n + sum(n-1);
+    return n + sum(n - 1);
 }
 
 // pow2
-double pow( double x, int n ){
+double pow(double x, int n){
 
-    assert( n >= 0 );
+    assert(n >= 0);
 
-    if( n == 0 )
+    if(n == 0)
         return 1.0;
 
-    double t = pow(x, n/2);
-    if( n%2 )
-        return x*t*t;
+    double t = pow(x, n / 2);
+    if(n % 2)
+        return x * t * t;
 
-    return t*t;
+    return t * t;
 }
 
 int main() {
 
-    cout<<sum(100)<<endl;
-    cout<<pow(2,10)<<endl;
+    cout << sum(100) << endl;
+    cout << pow(2, 10) << endl;
 
     return 0;
 }

02-Time-Complexity/Course Code (C++)/05-Recursion-Time-Complexity/main2.cpp

@@ -8,27 +8,29 @@ int f(int n){
 
     assert( n >= 0 );
 
-    if( n == 0 )
+    if(n == 0)
         return 1;
 
-    return f(n-1) + f(n-1);
+    return f(n - 1) + f(n - 1);
 }
 
+/*
 // mergeSort
 void mergeSort(int arr[], int l, int r){
 
-    if( l >= r )
+    if(l >= r)
         return;
 
     int mid = (l+r)/2;
     mergeSort(arr, l, mid);
-    mergeSort(arr, mid+1, r);
+    mergeSort(arr, mid + 1, r);
     merge(arr, l, mid, r);
 }
+*/
 
 int main() {
 
-    cout<<f(4)<<endl;
+    cout << f(10) << endl;
 
     return 0;
 }

02-Time-Complexity/Course Code (Java)/05-Recursion-Time-Complexity/src/Main.java

@@ -0,0 +1,49 @@
+public class Main {
+
+    // binarySearch
+    private static int binarySearch(Comparable[] arr, int l, int r, int target){
+
+        if(l > r)
+            return -1;
+
+        int mid = l + (r - l) / 2;
+        if(arr[mid].compareTo(target) == 0)
+            return mid;
+        else if(arr[mid].compareTo(target) > 0)
+            return binarySearch(arr, l, mid - 1, target);
+        else
+            return binarySearch(arr, mid + 1, r, target);
+
+    }
+
+    // sum
+    private static int sum(int n){
+
+        assert n >= 0;
+
+        if(n == 0)
+            return 0;
+        return n + sum(n - 1);
+    }
+
+    // pow2
+    private static double pow(double x, int n){
+
+        assert n >= 0;
+
+        if(n == 0)
+            return 1.0;
+
+        double t = pow(x, n / 2);
+        if(n % 2 == 1)
+            return x * t * t;
+
+        return t * t;
+    }
+
+    public static void main(String[] args) {
+
+        System.out.println(sum(100));
+        System.out.println(pow(2, 10));
+    }
+}

02-Time-Complexity/Course Code (Java)/05-Recursion-Time-Complexity/src/Main2.java

@@ -0,0 +1,35 @@
+/**
+ * Created by liuyubobobo.
+ */
+public class Main2 {
+
+    // f
+    private static int f(int n){
+
+        assert( n >= 0 );
+
+        if(n == 0)
+            return 1;
+
+        return f(n - 1) + f(n - 1);
+    }
+
+    /*
+    // mergeSort
+    private static void mergeSort(Comparable[] arr, int l, int r){
+
+        if(l >= r)
+            return;
+
+        int mid = (l+r)/2;
+        mergeSort(arr, l, mid);
+        mergeSort(arr, mid + 1, r);
+        merge(arr, l, mid, r);
+    }
+    */
+
+    public static void main(String[] args) {
+
+        System.out.println(f(10));
+    }
+}