CS

1
1321

• CS

2
CS1321Introduction to Programming

• Georgia Institute of Technology
• College of Computing
• Lecture 19
• October 29, 2001
• Fall Semester

3
Todays 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 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 didnt 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 didnt 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))))))))
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 well 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
67
45
23
14
6
33
36
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, lets 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.
Were just keeping things simple.
16
67
45
23
14
6
33
36
42
Now, we have to organize our list about our pivot
point.
17
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
We start recurring on our two lists.
18
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
The pivot points for each of our sub-lists.
19
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
6
14
33
67
45
42
23
20
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
6
14
33
67
45
42
23
6
14
21
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
6
14
33
67
45
42
23
6
14
6
14
22
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
6
14
33
67
45
42
23
6
14
6
14
6
14
33
23
67
45
42
23
67
45
23
14
6
33
36
42
67
6
14
36
45
33
23
42
6
14
33
23
67
45
42
6
14
6
14
6
14
33
23
67
45
42
6
14
33
23
67
45
42
36
24
67
45
23
14
6
33
36
42
6
14
33
23
67
45
42
36
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)
(quick-sort
(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 were 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)
(quick-sort
(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 weve
met a termination condition set up by our
algorithm.
45
Example Sierpinskis Triangle
Many of you may have already been exposed to
Sierpinskis 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 cant see them).
47
(No Transcript)
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.
50
(No Transcript)
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 Sierpinksis triangle and
Mandelbrot
Thanks to James Hays for this code.
54
Another Example
(define-struct box (p1 p2 p3 p4))
Lets 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, well just use 4 posns.
Lets take a square. Can we represent this in
Scheme?
56
Another Example
90
10
Now, lets 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
Another Example
How would we write this in code?
61
Another Example
Implementation...
(define-struct box (p1 p2 p3 p4))
The structure is already given.
We know there must be a function to draw a box.
The details of this are not interesting.
62
Another Example
(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 theres a recursive process at
work. Thats the most interesting part of this
problem.
When does it terminate?
64
Another Example
We know that theres a recursive process at
work. Thats 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
(define (draw-spirals in-box move) (cond
lttrivial-case?gt true else
ltdraw-the-boxgt (draw-spirals
ltupdate-the-boxgt 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
lttrivial-case?gt 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
lttrivial-case?gt 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) (gt 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)))))