Scribd
Upload
180 views3 pages

CS61A Notes 03 - Lists: Chongyang Wang, Courtesy of Chung Wu and Evan Chou

This document discusses lists in Scheme. It introduces pairs as the basic data structure, consisting of two elements separated by a period. Lists are recursively defined as either the empty list '() or a pair whose car is an element and whose cdr is another list. Common list procedures include cons, car, cdr, list, append, length, and interleave. Sentences are a special type of flat list used for natural language, with their own set of procedures that should not be mixed up with general list procedures.

Uploaded by

studboy
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
180 views3 pages

CS61A Notes 03 - Lists: Chongyang Wang, Courtesy of Chung Wu and Evan Chou

This document discusses lists in Scheme. It introduces pairs as the basic data structure, consisting of two elements separated by a period. Lists are recursively defined as either the empty list '() or a pair whose car is an element and whose cdr is another list. Common list procedures include cons, car, cdr, list, append, length, and interleave. Sentences are a special type of flat list used for natural language, with their own set of procedures that should not be mixed up with general list procedures.

Uploaded by

studboy
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

1

CS61A Notes 03 – Lists


Pair Up!

Introducing – the only data structure you’ll ever need in 61A – pairs.

A pair is a data structure that contains two things – the ”things” can be atomic values or even another pair. For
example, you can represent a point as (x . y), and a date as (July . 1). Note the Scheme representation of a
pair; the pair is enclosed in parentheses, and separated by a single period.

You’ve read about “cons”, “car”, and “cdr”:


cons – takes in two parameters and constructs a pair out of them. So (cons 3 4) will return (3 . 4)
car – takes in a pair and returns the first part of the pair. So (car (cons 3 4)) will return 3.
cdr – takes in a pair and returns the second part of the pair. So (cdr (cons 3 4)) will return 4.

These, believe it or not, will be all we’ll ever need to build complex data structures in this course.

SCHEME OUTPUT RULES FOR PAIR STRUCTURES:


1. Scheme prints pairs in this format: (car . cdr)
i.e. (cons 1 2) => (1 . 2)
2. (Simplify Rule) “. (“ is eliminated, with the corresponding “)”
i.e. (cons 1 (cons 2 3)) => (1 . (2 . 3)) => (1 2 . 3)

...... Then Came Lists

The super-cool definition of “list”: a list is either an empty list, or a pair whose car is an element of the list
and whose cdr is another list. Note the recursive definition – a list is a pair that contains a list! So then how does
it end? Wouldn’t there be an infinite number of list? Not so: an empty list, called “nil” and denoted '() is a list
containing no elements. And so it is, that every list ends with the empty list. To test whether a list is empty, you
can use the null? operator on a list.

So, to make a list of elements 2, 3, 4, we do this:

(define x (cons 2 (cons 3 (cons 4 '() ) ) ))

So x will be then represented as:

(2 . (3 . (4 . '() ) ) )

Now, that looks a bit ugly, so Scheme, the nice friendly language that it is, sugar-coats the notation a bit so you get:

(2 3 4)

It’s a bit annoying to write so many cons to define x. So Scheme, the mushy-gushy language that it is, provides an
operator list that takes in elements and returns them in a list. So we can also define x this way:

(define x (list 2 3 4))

Note: (car x) is 2, (cdr x) is (3 4), and (car (cdr x)) is 3! Well, it’s a bit tiresome to write (car
(cdr x)) to get the second element of x. So Scheme, again the huggable lovable language that it is, provides a
nifty short hand: (cadr x). This reads cader, and means “take the car of the cdr of”. Similarly, you can use
(caddr x) – caderder – to take the car of the cdr of the cdr of x, which is 4. You can mix and match the ‘a’
and ‘d’ between the ‘c’ and ‘r’ to get the desired element of the list (up to a certain length).

Chongyang Wang, courtesy of Chung Wu and Evan Chou


2

You can also append two lists together. append takes in any number of lists and outputs a list containing those
lists concatenated together. So (append (list 3 4) (list 5 6)) returns (3 4 5 6).

QUESTIONS: Evaluate the following, and draw box-and-pointer diagrams of the results.

1. (cons (cons 1 2) (cons 3 4))

2. (cons '((a b) (c d)) '(e f))

3. (list '((a b) (c d)) '(e f))

4. (append '((a b) (c d)) '(e f))

5. (cdadr '(((1) 3) (4 (5 6))) )

_____________________________________________________________________________________________
Don’t You Mean sentence?

Oh stop grumbling. A “sentence” is actually a special kind of “list” – more specifically, a “sentence” is a flat list – a
list without any sublists – whose elements can only be words or numbers. Sentences and lists use different
constructors, selectors, predicates, and higher-order procedures. Using sentence procedures on lists or vice versa
constitutes Data Abstraction Violation, so be very careful which one you're dealing with!

Here's a comparison of sentence and list procedures:

LIST PROCEDURES SENTENCE ANALOGUES


cons,list,append se
car, cdr first, bf
cadr, caddr second, third
listref nth
member member? (with slight difference)
length count
last, bl (no list version of these!)
list? sentence?
null? empty?
map, filter every, keep
accumulate accumulate

Chongyang Wang, courtesy of Chung Wu and Evan Chou


3

After a week of using sentence procedures, now let's get some practice for the list procedures!

QUESTIONS:

1. Suppose we have x bound to a mysterious element. All we know is this:


(list? x) ==> #t
(pair? x) ==> #f
What is x?

2. Define a procedure length that takes in a list and returns the number of elements within the list.

3. Define append for two lists.

4. Define a procedure (remove item ls) that takes in a list and returns a new list with item removed
from ls.

5. Define a procedure (interleave ls1 ls2) that takes in two lists and returns one list with elements from
both lists interleaved. So,
(interleave '(a b c d) '(1 2 3 4 5 6 7)) ==> (a 1 b 2 c 3 d 4 5 6 7)

Chongyang Wang, courtesy of Chung Wu and Evan Chou

You might also like