IAT 800

1. IAT 800 Linked Lists Binary Trees IAT 800

2. Data Structures • With a collection of data, we often want to do many things • Store and organize data • Go through the list of data and do X per item • Add new data • Delete unwanted data • Search for data of some value • “Give me Smith’s phone number” IAT 800

3. Store data arr[3] = 33 Go through: for( i = 0 ; i < 10 ; i++) sum = sum + arr[i] ; Add arr[last] = newNumber ; last++ ; Delete i for( j = i+1 ; j < last ; j++ ) arr[j-1] = arr[j] ; last -- ; Search for 42 for( i = 0 ; i < last ; i++ ) if( arr[i] == 42 ) SUCCESS ; 0 1 2 3 4 5 6 Arrays IAT 800

4. First Pointer 0 P 1 P 3 P 4 P 2 P Linked List • A chain of nodes, where each node links to the next • Node Has: • Value • Pointer to Next Node • Inserting a new item is faster than array • move pointers around • Deleting is also faster than array • Searching takes time • Must go link by link from Node to Node IAT 800

5. Node n, first ; Store data n.value = 33 Go through: n = first ; while( n!= NULL ) { sum += n.value ; n = n.next; } Add n = new Node( 12 ); n.next = first ; first = n ; Delete n1 n1 = n.next ; n.next = n1.next ; Search 42 n = first ; while( n!= NULL ) { if( n.value == 42 ) SUCCESS ; n = n.next ; } First Pointer 0 P 1 P 3 P 4 P 2 P Linked List IAT 800

6. Runtime • Often, we care about the time that computation takes • It’s ok if unimportant things run slow • Important stuff needs to go fast • Stuff that gets run all the time • “The Inner Loop” is a slang term I use IAT 800

7. What’s Important • YOUR time is important • Runtime != Creation Time • If any old algorithm will work, • AND you’re only going to do it once or twice • Use it! • If you’re going to run it millions of times • Think about the algorithm! IAT 800

8. Trees • A Treeis a node-link structure • It is built to enable fast searching • What Write Runtime • Store Like linked list As fast • Go Thru More complex As fast • Add More complex A little slower • Delete More complex A little slower • Search A little complex Much faster IAT 800

9. Binary Search Tree IAT 800

10. Binary Search Tree Root Pointer LP 3 RP • Each Node has twolinks • left and right child • Top node is root • Node without children is leaf • Binary meaning two children • Search tree because of the node arrangement LP 5 RP IAT 800

11. Binary Search Tree Root Pointer LP 3 RP LP 5 RP LP 1 RP LP 2 RP LP 0 RP LP 4 RP LP 6 RP IAT 800

12. Binary Search Tree • For Any node n • To the left • All child values are Less Thann • To the right • All child values are Greater Thann • This is a recursive definition!!! IAT 800

13. Binary Search Tree IAT 800

14. Nodes • Typically, each node has 3 or 4 parts: • The key (names in pictures) • The payload that goes with the key (not shown) • The left child pointer (possibly null) • The right child pointer (possibly null) IAT 800

15. Binary Search Tree Search class BNode { int key ; BNode left, right ; } BNode root, cursor ; cursor = root ; while( cursor != null ) // search for SEARCH { if( SEARCH == cursor.key ) SUCCESS ; if( SEARCH > cursor.key ) cursor = cursor.right ; else cursor = cursor.left ; } IAT 800

16. Delete IAT 800

17. Go Through public void inOrder (BNode cursor) { if (cursor == null) return; inOrder(cursor.left ); System.out.println(cursor.key ); inOrder(cursor.right ); } IAT 800

18. Things aren’t perfect • Unbalanced trees cause slower searches • Balancing algorithms manage that • Inserting items in order can cause this problem IAT 800