Recursive Data Types, null, and Linked Lists

Transcription

1 Recursive Data Types,, and Linked Lists Lecture 16 "hello" "world"

2 Data Buddies Survey Undergraduate Survey Graduate Survey What is it? Anonymous survey provided by CRA open now through Oct. 31st Why is it important? Your feedback gives department realtime on curriculum, pedagogy, student support and cultural climate from student POV What s in it for you? Completion of survey means raffle entry and chance to win Amazon gift card (dept to raffle more than $1K in gift cards) ***Check your for more details***

3 Announcements Women and Minorities in CS Info Session & Discussion Monday 10/23 at 5pm in SN011 PS3 Due Tonight Wednesday (tomorrow) Office Hours Close at 5pm for Fall Break No review session

4 Warm-up on References

5 Compound Data Type Properties So far we've focused on classes with value-type properties, such as: string number boolean Properties can also be reference types, like: arrays objects class Person { name: string; pets: Dog[]; class Dog { name: string; breed: string;

6 Recursive Data Types Properties can refer to other objects of the same type Notice the class left. It has a property named and its value must be... another. class { : string; : ; This allows us to form a Linked List or a "chain" of objects. "hello" "world"

7 Linked List A classic, simple structure in Computer Science Formed by chaining together a sequence of objects The first node is referred to as the head We will work with it today for pedagogical purposes in exploring What is? More advanced uses of references Recursive types "hello" "world"

8 Where does a Linked List end? In the class to the right, if a refers to a, and the refers to another, how does it end? In a linked list, the very last 's value will refer to which means nothing or "there is no " class { : string; : ; To permit the to be a value, TypeScript requires us to give it a special type ( slide) "world"

9 Possibly References (1/3) Because the property may refer to another OR, the type of is specified as: Notice this looks like the boolean OR operator but is only a single vertical bar. class { : string; : ; Now our linked list's last can be assigned a reference.

10 Possibly References (2/3) TypeScript helps us avoid errors when we declare the property's type to be Notice in the example left, we are prevented from accessing the property of the because the node is possibly. Other languages (like Java) do not provide this protection which gives way to " pointer" errors.

11 Handling possibly References (3/3) Whenever you access a reference whose type is "<class> ", you must test to ensure the value is not in order to access it. let a: = new (); if (a.!== ) { print(a..); The above code compiles because TypeScript is smart enough to know that inside of this if-then statement a. cannot be.

12 Follow-Along: Constructing a Linked List let a: = new (); a. = "Linked"; a. = ; let b: = new (); b. = "Lists"; b. = a; let c: = new (); c. = "!!!"; c. = b; c b a if (c.!== && c..!== ) { print(c.); print(c..); print(c...); "!!!" "Lists" "Linked"

13 Forming a Human Linked List Live demo with UTAs as s The first will be the "tail" and its is Subsequent s will place one hand on the 's shoulder What is your length? Jane John Sally

14 Finding the length of a Human Linked List What is your length? Jane John Sally

15 Finding the length of a Human Linked List What is your length? What is your length? Jane John Sally

16 Finding the length of a Human Linked List What is your length? What is your length? What is your length? Jane John Sally

17 Finding the length of a Human Linked List What is your length? What is your length? 1 Jane John Sally

18 Finding the length of a Human Linked List What is your length? 2 Jane John Sally

19 Finding the length of a Human Linked List 3 Jane John Sally

20 Hands-on: Implement the Length Function 1. Open lec16's list-functions.ts and 01-list-playground-app.ts 2. If the node's property is a reference, return 1 3. Otherwise, return 1 + the result of calling length with the node 4. Check-in when your length function is properly implemented 5. Done? Try adding an additional to the list in the playground's makelist function

21 export function length(head: ): number { if (head. === ) { return 1; else { return 1 + length(head.);

22 Finding the length imperatively with a loop How might we address this without recursion? We can walk the list -by- until the node is and count up by 1 each time. function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; This is an example of when a single reference-type variable is reassigned to many different objects

23 Finding the length imperatively count 1 node function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally We enter the function with node referring to the first node in our list. The count variable is initialized to 1.

24 Finding the length imperatively count 1 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The current variable is setup and assigned a reference to the same object as the node parameter refers to.

25 Finding the length imperatively count 1 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The current node's reference is not, so we'll enter the while loop.

26 Finding the length imperatively count 1 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The current variable is reassigned to be its (the 2 nd node in this case).

27 Finding the length imperatively count 2 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The count variable is incremented because we have walked to another node.

28 Finding the length imperatively count 2 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The while condition is tested again. Is the current 's property? No, so we enter the loop.

29 Finding the length imperatively count 2 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally Current is reassigned to be a reference to its.

30 Finding the length imperatively count 3 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally The count variable is incremented by 1.

31 Finding the length imperatively count 3 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally We test again. Is the current 's property? Yes, so we do not loop again.

32 Finding the length imperatively count 3 node current function lengthloop(node: ): number { let count: number = 1; let current: = node; while (current.!== ) { current = current.; count++; return count; Jane John Sally Finally, count is returned to the caller of lengthloop.

33 Generating a string Representation of the List Let's write a function with the following requirements. When we call with a tail node (its property is ), it should return the node's concatenated with "-> ". For example: tostring( Sally ) returns "Sally -> " When we call with a non-tail node, it should ultimately return a string with every node's separated by -> arrows and end with. tostring( John Sally ) returns "John -> Sally -> "

34 Hands-on: Generating a string Representation 1. In 01-list-playground's main, try: print(tostring(list)); 2. In the tostring function of list-functions.ts 3. If the node's property is, use concatenation to return: "<node's value> -> " 4. Otherwise, use concatenation and recursion to return: "<node's value> -> <tostring of the node>" 5. Check-in on PollEverywhere when complete

35 export function tostring(node: ): string { if (node. === ) { return node. + " -> "; else { return node. + " -> " + tostring(node.);

36 Accessing the nth Index With an array we can return the 0-indexed nth element using: a[0], a[1], and so on Let's implement a get function with the same semantics and the following signature: get(node:, i: number): string For example: get(list, 0) returns "Jane" get(list, 2) returns "Sally" get(list, 40) returns Jane John Sally

37 Accessing the nth Index: There are 2 base cases 1. Is i === 0? 1. Yes: we've found the i th! 2. No, i > 0? Is the node? 1. Yes: there is no i th! No, the node is not. So let's try calling get again on the node and subtract 1 from i.

38 Follow-along: Implementing the get function export function get(node:, i: number): string { if (i === 0) { return node.; else if (node. === ) { return ; else { return get(node., i - 1);

39 Challenge Functions Copying a List Appending to a List Reversing a List Want a challenge? Try implementing the remaining functions in list-functions.ts

40 Challenge function solutions

41 copy export function copy(node: ): { if (node. === ) { return node; else { return link(node., copy(node.));

42 append export function append(: string, node: ): void { if (node. === ) { let tail: = new (); tail. = ; node. = tail; else { append(, node.);

43 reverse export function reverse(node: ): { if (node. === ) { return node; else { let reversed: = reverse(node.); node.. = node; node. = ; return reversed;