Recursion

Recursive selection sort

-*Base case*- occurs when our smaller array of larger values has only *one value* -We can recursively sort the smaller arrays by swapping the *smallest value* in our selection into the i position of the array, and then plugging values *back into function* where i = i+1 and the size = size-1 -This will continue until size = 1 -Basically we are replacing the *for loop*

Recursive bubble sort

-*Base case*- occurs when there is only *one value left* in "bubbled down" array, then it will just return what is in the array -You're using the recursion to tell the function to run again when for the next element up in your matrix

Recursive insertion sort

-*base case*- occurs when small array not being sorted has only *1 value* -Will still need one for loop to sort the elements in our selected array -Recursion comes into play when we want to prompt function to *sort the next array* that will have size of size-1 -We tell the function to keep on taking itself until the size=1

Recursive binary search

-Basically you are telling the program to *run again* if it has no yet found the value or proven it doesn't exist -*Two base cases*- it will not find the value if left>right, or it will find the value and it will be at the middle

Recursion example- Factorial function

-Classic example of how a recursive function works -We are defining the function *in terms of itself* and then we define a simple version -*Base case*- we have factorial 1 which returns 1xfactorial(0) which will equal 1 -Will keep on diving back into the function until it finishes, there will not be just one n value

What is recursion

-In some languages we have to use what is called a *recursive method* to solve problems -We will want to write a function that will *call itself* in the function -Assume that the computer can solve smaller problems in smaller instances -We are *breaking up* the problem into a more general problem

Divide and conquer approach

-Split each problem in *half* -Split the problem into *smaller more simpler subproblems* -Recursively solve the two subproblems -Combine the solutions to create one solution

Recursive Sum of Squares- computing the sum of squares between two numbers, m and n

-We use what is called a *divide and conquer* approach -This function will run for this *base case* and continue to run until m=n

How to solve problems recursively?

1) Write *if else statements*- we will need *at least 2* statements -One statement will be the *recursive case* where the function *calls itself* -The other statement will be the *base case* where the method doesn't call itself 2) The base case- will be the *simplest case* 3) Write recursive call- on the *next simplest case*, with the function in it -The less simple cases must always return to the base case! -Identify *smaller problem*- we must think to the smallest, simplest version of the problem that we can solve directly, this is called the *base case*