1. CS
1321

2. CS1321: Introduction to Programming
Georgia Institute of Technology
College of Computing
Lecture 19
October 29, 2001
Fall Semester

3. Today’s Menu Generative Recursion: QuickSort
Generative Recursion: Fractals

4. Last time: Generative Recursion
Up until the last lecture, we had been working with a form of recursion that had been driven by the “structure” or characteristics of the data types passed to it.
Functions that processed a list of TAs or a tree full of numbers were “shaped” by the data definitions that they involved. A List or a Tree has built within it the idea that we will recur as we process the data as well as the idea that we will eventually terminate as we process the data.

5. Processing a Binary Tree
Processing a List
(define (process-lon in-lon)
(cond ((empty? in-lon) …)
(else …(first in-lon)
…(process-lon
(rest in-lon))))
By simply having our code reflect the data definition, most of our code was written for us!
These functions are driven by the “structure” of the data definition.
Processing a Binary Tree
(define (process-BT in-BT)
(cond ((not in-BT) …)
(else …(node-data in-BT)
…(process-BT (node-left in-BT))
…(process-BT (node-right in-BT)))))

6. Last time: Generative Recursion
As we began to discover last time, not all functions are shaped by the structure of the data being passed in. There exists a class of recursive functions for which the structure of the data being passed in is merely a side note to the recursive process. These functions generated “new” data at each recursive step and relied on an algorithmic process to determine whether or not they should terminate.

7. Last Time: Our Examples

8. Last Time: Our Examples
Our recursion in this case is driven by the location of the ball relative to the pocket, not by any intrinsic properties of the data definition.

9. Last Time: Our Examples
Merge Sort, rather than being driven by definition of the list, is driven by the size of the data being passed in.

10. Sorting
Last time we explored the idea behind merge-sort, a generative sorting algorithm that employed a “divide-and-conquer” methodology to sort a sequence of data elements into ascending order.
The algorithm for merge-sort involved splitting our list into two components of equal size, sorting each half recursively, and merging the result.

11. Sorting
If we examine the code, we find that the actual “sorting” of our elements didn’t take place until we had reached our termination condition (the list is empty), and were returning from our recursive calls.
(define (merge-sort lst)
(cond [(empty? lst) empty]
[else (local ((define halves (divide lst)))
(cond [(empty? (first halves))
(first (rest halves))]
[(empty? (first (rest halves)))
(first halves)]
[else (merge
(merge-sort (first halves))
(merge-sort (first
(rest halves))))]))]))

12. Sorting
If we examine the code, we find that the actual “sorting” of our elements didn’t take place until we had reached our termination condition (the list is empty), and were returning from our recursive calls.
(define (merge-sort lst)
(cond [(empty? lst) empty]
[else (local ((define halves (divide lst)))
(cond [(empty? (first halves))
(first (rest halves))]
[(empty? (first (rest halves)))
(first halves)]
[else (merge
(merge-sort (first halves))
(merge-sort (first
(rest halves))))]))]))
(merge
(merge-sort (first halves))
(merge-sort (first
(rest halves))))]))]))

13. Quick Sort
Quick sort is another generative “divide and conquer” algorithm that involves splitting our sequence of data into parts and sorting each component recursively. Unlike merge sort, however, quick sort performs the actual sorting as the sequence is being split. In terms of performance (which we’ll formally define in the next few weeks), quick sort is considered to be a “better” algorithm than merge sort.

14. Quick Sort: The basic premise
The basic idea of quick sort involves splitting up our list around a pivot item.
We arbitrarily chose an element of our list to be a pivot item.
We then separate our list into two components:
those elements that are smaller than our pivot
those elements that are larger than our pivot
We recursively sort the two components, and join the results together with our pivot item to form a sorted list.

15. 36 23 45 14 6 67 33 42
Here we start off with a list of unsorted elements. We arbitrarily choose a pivot point about which to organize our list. For the sake of expediency, let’s just choose the first element* of our list to be our pivot.
* In many theory books, there are whole chapters dedicated to the process of choosing which element to choose as the optimal pivot point. We’re just keeping things simple.

16. 36 23 45 14 6 67 33 42
Now, we have to organize our list about our pivot point.

17. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42
We start recurring on our two lists.

18. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42
The pivot points for each of our sub-lists.

19. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42 14 6 23 33 42 45 67

20. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42 14 6 23 33 42 45 67 6 14

21. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42 14 6 23 33 42 45 67 6 14 6 14

22. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42 14 6 23 33 42 45 67 6 14 6 14 6 14 23 33 42 45 67

23. 36 23 45 14 6 67 33 42 23 14 6 33 36 45 67 42 14 6 23 33 42 45 67 6 14 6 14 6 14 23 33 42 45 67 6 14 23 33 36 42 45 67

24. 36 23 45 14 6 67 33 42 6 14 23 33 36 42 45 67

25. Quicksort: the code
We arbitrarily chose an element of our list to be a pivot item.
We then separate our list into two components:
those elements that are smaller than our pivot
those elements that are larger than our pivot
We recursively sort the two components, and join the results together with our pivot item to form a sorted list.

26. Quicksort: the code (define (quick-sort in-lon)
We arbitrarily chose an element of our list to be a pivot item.
We then separate our list into two components:
those elements that are smaller than our pivot
those elements that are larger than our pivot
We recursively sort the two components, and join the results together with our pivot item to form a sorted list.

27. Quicksort: the code (define (quick-sort in-lon)
(cond ((empty? in-lon) empty)
(else (local ((define pivot (first in-lon)))
We then separate our list into two components:
those elements that are smaller than our pivot
those elements that are larger than our pivot
We recursively sort the two components, and join the results together with our pivot item to form a sorted list.

28. Quicksort: the code (define (quick-sort in-lon)
(cond ((empty? in-lon) empty)
(else (local ((define pivot (first in-lon)))
…(smaller-items in-lon pivot)
…(larger-items in-lon pivot)
))))
We recursively sort the two components, and join the results together with our pivot item to form a sorted list.

29. Quicksort: the code (define (quick-sort in-lon)
(cond ((empty? in-lon) empty)
(else (local ((define pivot (first in-lon)))
(append
(quick-sort
(smaller-items in-lon pivot))
(list pivot)
(larger-items in-lon pivot))
)))))

30. Quicksort: the code
The result of quick-sort is a sorted list of numbers. If one list contains items smaller than the pivot, and one contains items bigger than the pivot, the result we’re looking for should be:
Smaller + pivot + larger
(define (quick-sort in-lon)
(cond ((empty? in-lon) empty)
(else (local ((define pivot (first in-lon)))
(append
(quick-sort
(smaller-items in-lon pivot))
(list pivot)
(larger-items in-lon pivot))
)))))

31. smaller-items & larger items
smaller-items is a function that takes in a list of numbers and target item and creates a list of numbers that contains only elements that are smaller than the target item.
larger-items is a function that takes in a list of numbers and target item and creates a list of numbers that contains only elements that are larger than the target item.
My goodness, those functionalities are awfully similar…
Maybe you should ponder this…

32. Fractals
Perhaps one of the best-known (or at least most widely recognized) generative recursion example lies in the idea of fractals.
A formal definition of fractal is a geometrical figure consisting of an identical motif that repeats itself on an ever decreasing scale.
The images produced by fractals range greatly…

33. From the bizarre

34. From the bizarre

35. From the bizarre

36. From the bizarre

37. From the bizarre

38. From the bizarre

39. To the Beautiful

40. To the Beautiful

41. To the things we see every day

42. To the things we see every day

43. But how does it work?
Back to the reality of the situation, how does this work and why is it called “generative recursion”.

44. At each step…
At each step in the recursive process, we “generate” a new set of data based on established rules. At each step, we check to see if we’ve met a termination condition set up by our algorithm.

45. Example: Sierpinski’s Triangle
Many of you may have already been exposed to Sierpinski’s triangle.
It has a very simple set of rules:

46. Given a triangle…
Given a triangle with corners A, B, & C, calculate the coordinates of the midpoints of each side of the triangle. Draw lines connecting each of these midpoints.
For each new triangle generated except for the center triangle, repeat the process.
Do this until you can no longer draw triangles (you can’t see them).

48. We determine the midpoints of each of the three sides through simple mathematics

49. We repeat our algorithm for each of the “corner triangles”, generating new images.

51. After only a few iterations…

52. The Code
For the most part, the code for this function exists on pages 383 and 384 of your text.

53. Last Fractal Examples: Sierpinksi’s triangle and Mandelbrot
Thanks to James Hays for this code.

54. Another Example (define-struct box (p1 p2 p3 p4))
Let’s take a square. Can we represent this in Scheme?

55. Another Example (define-struct box (p1 p2 p3 p4))
Instead of our previous model of an upper-left posn and an edge length, we’ll just use 4 posns.
Let’s take a square. Can we represent this in Scheme?

56. Another Example
90%
10%
Now, let’s take a fixed value, some percentage of the box edge length.

57. Another Example
90%
10%
Do this for all sides . . .

58. Another Example
90%
10%
Do this for all sides and use the resulting points as the data for a new square.

59. Another Example
Wash, rinse, repeat.

60. How would we write this in code?
Another Example
How would we write this in code?

61. Another Example Implementation... The structure is already given.
(define-struct box
(p1 p2 p3 p4))
The structure is already given.
(define
(draw-box in-box)...
We know there must be a function to draw a box. The details of this are not interesting.

62. Another Example
We also need a function that takes in a box, and returns a new, smaller box.
(define (move-box b %move)
(local ((define p1 (box-p1 b))
(define p2 (box-p2 b))
(define p3 (box-p3 b))
(define p4 (box-p4 b))
(define (adjust-points a b %move)
(make-posn (+ (* %move (posn-x a))
(* (- 1 %move) (posn-x b)))
(+ (* %move (posn-y a))
(* (- 1 %move) (posn-y b))))))
(make-box (adjust-points p1 p2 %move)
(adjust-points p2 p3 %move)
(adjust-points p3 p4 %move)
(adjust-points p4 p1 %move))))

63. Another Example We know that there’s a recursive process at work.
That’s the most interesting part of this problem.
When does it terminate?

64. Another Example We know that there’s a recursive process at work.
That’s the most interesting part of this problem.
When does it terminate? It likely terminates when
the size of the box is too small to bother with.

65. Another Example When does it terminate? It likely terminates when
(define (draw-spirals in-box %move)
(cond
[ <trivial-case?> true ]
[ else
<draw-the-box>
(draw-spirals
<update-the-box>
%move) ]))
When does it terminate? It likely terminates when
the size of the box is too small to bother with.

66. Another Example
(define (draw-spirals in-box %move)
(cond
[ <trivial-case?> true ]
[ else
(draw-box in-box)
(draw-spirals
(move-box in-box %move)
%move) ]))
We already have functions for drawing the box and updating the box.

67. Another Example
(define (draw-spirals in-box %move)
(cond
[ <trivial-case?> true ]
[ else
(draw-box in-box)
(draw-spirals
(move-box in-box %move)
%move) ]))
The ‘trivial’ case function really just tests if the current recursive call has generated another need to recur.

68. Another Example (define (draw-spirals in-box %move) (cond
[ (too-small? in-box) true ]
[ else
(draw-box in-box)
(draw-spirals
(move-box in-box %move)
%move) ]))
(define (too-small? in-box)
(> 20 (distance (posn-x (box-p1 in-box))
(posn-x (box-p2 in-box))
(posn-y (box-p1 in-box))
(posn-y (box-p2 in-box)))))
(define (distance x1 x2 y1 y2)
(sqrt (+ (square (- x1 x2))
(square (- y1 y2)))))