W15 Phan Thiet stats & predictions

Eve<|repo_name|>sharadchauhan/CS-101<|file_sep|>/Lecture Notes/week7/lecture7.md # Lecture 7: Recursion ## Learning Objectives * Define recursion. * Explain how recursive methods work. * Recognize when recursion can be used. ## What Is Recursion? Recursion occurs when a method calls itself. java public void recursiveMethod() { recursiveMethod(); } Recursive methods are useful when solving problems that have repeating sub-problems. For example: * Compute Fibonacci numbers. * Compute factorial values. * Perform binary search. ## How Does Recursion Work? To understand how recursion works we need to understand call stacks. A call stack keeps track of active method invocations. When we invoke `recursiveMethod`, it gets added onto top of call stack: +-------------------+ | recursiveMethod() | +-------------------+ When `recursiveMethod` invokes itself again (and again), each invocation gets added onto top of call stack: +---------------------+ | recursiveMethod() | +---------------------+ | recursiveMethod() | +---------------------+ | recursiveMethod() | +---------------------+ Each invocation waits for other invocations above it (on top of call stack) before returning. So after three invocations (three items on call stack), `recursiveMethod` returns once after third invocation returns: +---------------------+ | recursiveMethod() | <- returns here +---------------------+ | recursiveMethod() | +---------------------+ | recursiveMethod() | +---------------------+ Then second invocation returns: +---------------------+ | recursiveMethod() | <- returns here +---------------------+ | recursiveMethod() | <- returns here +---------------------+ Finally first invocation returns: +---------------------+ | recursiveMethod() | <- returns here +---------------------+ The last item on call stack always returns first! This process continues until there are no more items left on call stack:  ### Stack Overflow When there are too many items on call stack then there isn't enough memory available anymore! This results in `StackOverflowError`. ### Base Case In order avoid `StackOverflowError`, we need base case(s). Base case(s) should not result in further method invocations! For example: java public void printHello(int n) { if (n <= 0) return; System.out.println("Hello"); printHello(n - 1); } In this example base case occurs when `n <= 0`. Base case causes method invocation chain stops by returning without invoking itself again. ## Example: Factorial Method Factorial method computes factorial value using recursion. java public int factorial(int n) { if (n == 0) return 1; return n * factorial(n - 1); } Here base case occurs when `n == 0`. To compute factorial value we multiply current number (`n`) by factorial value of next smaller number (`n - 1`). ### How Does Factorial Method Work? Let us trace execution flow step-by-step using following input: `factorial(5)`. Initially call stack looks like this:  Since `5 != 0`, first line inside body executes resulting into multiplication operation (`5 * factorial(4)`). Next line executes resulting into further multiplication operation (`5 * (4 * factorial(3))`). And so on... Eventually base case occurs when input becomes zero resulting into following sequence of operations:  Now let us evaluate these operations from rightmost side since they depend upon each other! First we evaluate rightmost operation resulting into following state:  Next we evaluate next operation resulting into following state:  And so on... Until eventually final result becomes available resulting into following state:  ### Factorial Method In Practice Let us see how we can use factorial method in practice! We can use this method inside another method called `printStars`. java public static void printStars(int n) { for (int i = 0; i < n; i++) System.out.print("*"); System.out.println(); } public static int factorial(int n) { if (n == 0) return 1; return n * factorial(n - 1); } public static void main(String[] args) { for (int i = factorail(5); i >= factorail(0); i--) { printStars(i); } } This program prints out pattern similar as follows: #### Explanation First line inside loop calls `printStars(i)` where value of `i` initially equals five! So first line prints out five stars followed by newline character resulting into following output: Next iteration happens when value of `i` decrements down by one! So next iteration prints out four stars followed by newline character resulting into following output: And so on... Until eventually loop terminates once value of `i` reaches zero! #### Output ## Example: Fibonacci Method Fibonacci method computes Fibonacci number using recursion. java public int fibonacci(int n) { if (n == 0 || n == 1) return n; return fibonacci(n - 2) + fibonacci(n -1); } Here base cases occur when either input equals zero or one. To compute Fibonacci number we add together two previous Fibonacci numbers starting from index zero! ### How Does Fibonacci Method Work? Let us trace execution flow step-by-step using following input: `fibonacci(6)`. Initially call stack looks like this: Since neither condition evaluates true (`6 != O && O != l`) then next line executes resulting into addition operation (`fibonacci(4) + fibonacci(5)`). Next two lines execute recursively causing two more addition operations. And so on... Eventually base cases occur causing some operations stop executing further! Now let us evaluate these operations from rightmost side since they depend upon each other! First we evaluate rightmost operation causing another addition operation. Next we evaluate next operation causing yet another addition operation. And so on... Until eventually final result becomes available. ### Fibonacci Method In Practice Let us see how we can use fibonacci method in practice! We can use this method inside another method called printFibonacciPattern. This program prints out pattern similar as follows: #### Explanation First line inside loop calls printStars(fibonacci(i)) where value of i initially equals zero! So first iteration prints out zero stars followed by newline character resulting into following output: Next iteration happens when value of i increments up by one! So second iteration prints out one star followed by newline character resulting into following output: And so on... Until eventually loop terminates once value reaches six! #### Output ## When Should We Use Recursion? We should only use recursion if problem naturally fits recursion model or if problem cannot easily solved without recursion! Otherwise iterative solution will be better choice since iterative solutions tend consume less memory than corresponding recursive solutions.<|file_sep[TOC] # Lecture Notes Week #9 ## Learning Objectives * Understand why Java uses references instead pointers * Understand difference between primitive types vs reference types * Understand difference between primitive types vs objects * Understand concept behind immutable objects * Know difference between mutable & immutable objects * Know difference between shallow copy & deep copy * Know difference between pass-by-value & pass-by-reference ## References vs Pointers Java uses references instead pointers because references don't allow pointer arithmetic which makes Java programs safer than programs written using languages that support pointers such as C++ or C! A reference points towards an object whereas pointer points towards address! There isn't any difference between references & pointers except they behave differently! For example consider below code snippet written using C++ language which supports pointers! cpp #include class MyInteger { private: int data; public: MyInteger(int d): data(d){} void setData(int d){ data = d; } int getData(){ return data; } }; void increment(MyInteger& m){ m.setData(m.getData()+10); } void main(){ MyInteger m(100); cout << "Before incrementing : " << m.getData()<< endl; increment(m); cout << "After incrementing : " << m.getData()<< endl; } Above code outputs below output: Before incrementing : **100** After incrementing : **110** Above code shows that passing argument by reference allows caller function access actual object instead copy created during function invocation! So changes made within callee function affect original object passed as argument! Now consider below code snippet written using Java language which doesn't support pointers! java class MyInteger { private int data; public MyInteger(int d){ data = d; } void setData(int d){ data = d; } int getData(){ return data; } } void increment(MyInteger m){ m.setData(m.getData()+10); } void main(){ MyInteger m = new MyInteger(100); System.out.println("Before incrementing : "+m.getData()); increment(m); System.out.println("After incrementing : "+m.getData()); } Above code outputs below output: Before incrementing : **100** After incrementing : **110** Although Java doesn't support passing arguments by reference still above code produces same effect as passing arguments by reference because Java passes references during function invocation instead actual objects! So changes made within callee function affect original object passed as argument even though argument is passed by value! In above code snippet variable 'm' stores reference towards MyInteger object whereas 'increment' parameter stores copy created during function invocation referencing same MyInteger object referenced through 'm'. So changes made within callee function affect original object passed as argument even though argument is passed by value because both 'm' & 'increment' parameter store reference towards same MyInteger object! Note that if callee function creates new object then caller won't see those changes because caller stores reference towards different object than callee creates during function execution! For example consider below modified version of above code snippet where callee creates new instance rather than changing existing instance passed as argument! java class MyInteger { private int data; public MyInteger(int d){ data = d; } void setData(int d){ data = d; } int getData(){ return data; } } void increment(MyInteger m){ m = new MyInteger(m.getData()+10); } void main(){ MyInteger m = new MyInteger(100); System.out.println("Before incrementing : "+m.getData()); increment(m); System.out.println("After incrementing : "+m.getData()); } Above code outputs below output: Before incrementing : **100** After incrementing : **100** Above code shows that if callee creates new instance rather than changing existing instance passed as argument then caller won't see those changes because caller stores reference towards different object than callee creates during function execution! ## Primitive Types vs Reference Types Primitive types store values directly whereas reference types store references towards objects storing values indirectly via heap memory allocation ! Primitive types include boolean , byte , short , char , int , long , float & double whereas everything else including arrays & custom classes are considered reference types ! Following table summarizes differences between primitive types & reference types !

Property	Primitive Type	Reference Type
Size	Size depends upon architecture !	Size depends upon JVM implementation !
Memory Allocation	Allocated directly onto stack memory !	Allocated indirectly onto heap memory via stack memory allocation !
Default Value	Predefined default values exist ! For example boolean variables default initialized with false while integer variables default initialized with zero !	Null values exists unless explicitly initialized otherwise nulls exist otherwise ! For example arrays default initialized with null unless explicitly initialized otherwise nulls exist otherwise ! Custom classes also default initialized with null unless explicitly initialized otherwise nulls exist otherwise ! Note that class instances cannot be created automatically without explicit constructor calls unlike primitive type instances which can be created automatically without explicit constructor calls since predefined constructors exist implicitly ! To create class instances explicit constructor calls required like shown below example showing creation MyClass instance named myObject via calling MyClass constructor explicitly ! MyClass myObject=new MyClass(); Note that MyClass constructor must exist either explicitly defined or implicitly defined via compiler generated no arguments constructor provided no constructors explicitly defined ! If multiple constructors exist then compiler won't generate implicit no arguments constructor ! Example showing compilation error due absence implicit no arguments constructor caused due presence explicit constructors ! class MyClass {     MyClass(){ }     MyClass(String s){ }     MyClass(String s,int i){ } } Note that above class compiles successfully since at least one implicit no arguments constructor exists ! But note that below class doesn't compile successfully since absence implicit no arguments caused due presence multiple explicit constructors ! class MyClass {     MyClass(String s){ }     MyClass(String s,int i){ } } Error message shown below indicates absence implicit no arguments constructor caused due presence multiple explicit constructors ! The type MyClass must implement abstract type java.lang.Comparable or must declare abstract or concrete comparator . Class file contains class definition for MyClass but does not contain definition for any public java.lang.Comparable.compareTo(com.company.MyClass)argx methods . Multiple markers at this line : -The type MyClass must implement abstract type java.lang.Comparable or must declare abstract or concrete comparator . -Class file contains class definition for MyClass but does not contain definition for any public java.lang.Comparable.compareTo(com.company.MyClass)argx methods . At com/company/MyClass.java:[8] error : -The type MyClass must implement abstract type java.lang.Comparable or must declare abstract or concrete comparator . At com/company/MyClass.java:[8] error : -Class file contains class definition for MyClass but does not contain definition for any public java.lang.Comparable.compareTo(com.company.MyClass)argx methods . Compilation failed .
Access Speed	Accessed faster than reference types since stored directly onto stack memory accessed faster compared heap memory accessed slower compared stack memory accessed faster !
Default Constructor Availability	Predefined implicit no arguments constructors exists !
Type Name Format	Type names end either suffixes like boolean , byte , short , char , int , long , float & double indicating primitive nature !	Type names end either suffixes like String indicating non-primitive nature !	Type names end either suffixes like String indicating non-primitive nature !	Type names end either suffixes like String indicating non-primitive nature !	Type names end either suffixes like String indicating non-primitive nature !	Type names end either suffixes like String indicating non-primitive nature !               Property Name Primitive Type Reference Type Explanation Size bite 'b' - '*'b' - '*' indicates size varies depending upon JVM implementation  'byte'    '-'    'String'    '-'    '*' indicates size varies depending upon JVM implementation  'short'    '-'    'String[]'  'char'  'int'  'long'  'float'  'double' Type Name Format Welcome Bonus Up to $6000 GET BONUS ✕