1. Announcements Project checkpoint next week after lab sessions
We will look at your Java programs written so far
Bring a one-page report describing what you have done till now
Only Tuesday group will have lab this week
Class on 25th October (Thursday) is canceled

2. Examples of class: Recursive data structures
Instructor: Mainak Chaudhuri

3. Recursive data structures
Refers to a “connected” set of similar objects
Object A “connects” or “refers” to object B
For example, in a list of integers you can imagine each integer in the list as an object and each object connects to its next object thereby forming a list
The structure is called recursive because an object of type class A connects to another object of the same class type
Very important to build complex connected structures e.g., a network of cities where a “connection” could mean rail or road

4. List structure Why not just an array?
Basic operations needed on a list: search, insertion, deletion
All these are time consuming in arrays e.g., searching is O(n), insertion at head is O(n), and deletion from head is also O(n)
With lists, arbitrary insertion and deletion can be made in O(1) time; searching is still costly (we will discuss techniques to improve it on average)
Insertion and deletion involve changing a few references (independent of n)

5. List structure Consider insertion sort
For each element, we compared it with all elements on its left until a comparison failed and then shifted up all the elements on the right to make a hole for insertion
If the numbers are stored in a list, the last shift-up step can be completely avoided
Just insert one element and delete another: O(1)
Recall that with a reverse-sorted array, the number of comparisons is minimum while with a sorted array, the number of comparisons is maximum
But former spends more time in shift-up leading to both cases requiring roughly the same amount of time
With a list implementation, the first case will indeed be the fastest
Program = Algorithm + Data structure

6. List structure public class IntegerList { private int data;
private IntegerList next;
public IntegerList (int x, IntegerList rest) {
data = x;
next = rest; }
// next slide

7. List structure public IntegerList (int x) { data = x; next = null; }
public int GetHead () {
return data;
// next slide

8. List structure public IntegerList GetBody () { return next; }
public int Length () {
if (next==null) return 1;
return (1 + GetBody().Length());
public int GetTail () {
if (next==null) return data;
return GetBody().GetTail();

9. List structure public IntegerList Search (int x) {
if (data==x) return this;
if (next==null) return null;
return GetBody().Search(x); }
public int ExtractElement (int index) {
// This is slower compared to array
if (index==0) return data;
if (next==null) {
System.out.println (“Query index too large!”);
return -1;
return GetBody().ExtractElement (index-1);

10. List structure public void Enqueue (int x) { if (next==null) {
next = new IntegerList (x); }
else {
GetBody().Enqueue(x);
// next slide

11. List structure public IntegerList Dequeue () { return next; }
public IntegerList Reverse () {
if (next==null) return this;
IntegerList temp = GetBody().Reverse();
temp.Enqueue (data);
return temp;
// next slide

12. List structure
public void SetBody (IntegerList x) {
next = x; }

13. List structure public void Print () { if (next==null) {
System.out.println (data); }
else {
System.out.print (data + “, ”);
GetBody().Print();
// next slide

14. List structure
public IntegerList SearchAndDelete (int x) { // return the new head of the list
IntegerList temp = this;
IntegerList prev = null;
while ((temp != null) &&
(temp.GetHead() != x)) {
prev = temp;
temp = temp.GetBody(); }
// next slide

15. List structure if (temp != null) { // found x
if (prev == null) { // first one is x
return temp.GetBody(); // new head of list }
else {
prev.SetBody (temp.GetBody());
return this;
else { // did not find x
} // next slide

16. List structure public IntegerList SortedInsert (int x) {
// return the new head of the list
IntegerList temp = this;
IntegerList prev = null;
IntegerList newBorn = new IntegerList (x);
while ((temp != null) &&
(temp.GetHead() < x)) {
prev = temp;
temp = temp.GetBody(); }
// next slide

17. List structure if (temp != null) {
if (prev == null) { // Insert at head
newBorn.SetBody(this);
return newBorn; }
else { // Insert in middle
prev.SetBody(newBorn);
newBorn.SetBody(temp);
return this;
// next slide

18. List structure else { // Insert at end prev.SetBody(newBorn);
return this; }
} // end class
Sometimes a tail reference helps
Could enqueue at end without traversing the entire list

19. List structure class ListBuilder {
public static void main (String a[]) {
IntegerList iL = new IntegerList (5);
iL = new IntegerList (6, iL);
iL = new IntegerList (-2, iL);
iL.Enqueue (13);
System.out.println (“Length: ” + iL.Length());
System.out.println (“Position 2: ” + iL.ExtractElement (2));
iL.Print (); // next slide

20. List structure iL = iL.Reverse(); iL.Print();
iL = iL.SearchAndDelete(-2);
iL = iL.SortedInsert(10); }

21. Maintaining a tail reference
Want to have a “global” tail reference shared by all the objects in the list
Need to declare tail as a static variable
These are also called class variables because these are attached to a class as opposed to specific objects

22. Maintaining a tail reference
public class IntegerListWithTail {
private int data;
private IntegerListWithTail next;
private static IntegerListWithTail tail = null;
// Could maintain a global length also
private static int length = 0;
public IntegerListWithTail (int x, IntegerListWithTail rest) {
data = x;
next = rest;
if (tail == null) tail = this;
length++; }
// Next slide

23. Maintaining a tail reference
public IntegerListWithTail (int x) {
data = x;
next = null;
tail = this;
length++; }
public static int GetTail () {
if (tail == null) return -1;
else return tail.GetHead();
// Next slide

24. Maintaining a tail reference
public static int Length() {
return length; }
public IntegerListWithTail SearchAndDelete (int x) {
// return the new head of the list
IntegerListWithTail temp = this;
IntegerListWithTail prev = null;
while ((temp != null) &&
(temp.GetHead() != x)) {
prev = temp;
temp = temp.GetBody();
// Next slide

25. Maintaining a tail reference
if (temp != null) { // found x
length--;
if (prev == null) { // first one is x
return temp.GetBody();
// new head of list }
else {
prev.SetBody (temp.GetBody());
// update tail
if (temp.GetBody() == null) tail = prev;
return this;
// Next slide

26. Maintaining a tail reference
else { // did not find x
return this; }
public int GetHead () {
return data;
public IntegerListWithTail GetBody() {
return next;
// Next slide

27. Maintaining a tail reference
public void SetBody (IntegerListWithTail x) {
next = x; }
} // end class
class ListBuilder {
public static void main (String a[]) {
IntegerListWithTail iL = new IntegerListWithTail (5);
iL = new IntegerListWithTail (6, iL);
iL = new IntegerListWithTail (-2, iL);
System.out.println (“Length: ” + IntegerListWithTail.Length());
// Next slide

28. Maintaining a tail reference
iL = iL.SearchAndDelete(-2);
System.out.println(“Tail: ” + IntegerListWithTail.GetTail());
iL = iL.SearchAndDelete(5);
System.out.println(“Length: ” + IntegerListWithTail.GetLength()); }