1. 1 Welcome to Data Structures Spring 2009 The slides in this course includes slides by T. Tamir, A. Tal, S. Ar, Y. Moses. Thanks null 7 65 42

2. 2 Welcome to Data Structures Spring 2008  Instructor  Yael Moses (yael@idc.ac.il)@idc.ac.il office hours: Thu. 10:30-11:30 or by appointment  TA  Ran Eshel

3. 3 Textbook  Cormen, Leiserson, Rivest and Stein Introduction to Algorithms. (CLRS)  You will need this book also next year (for Algorithms) and maybe for additional elective courses.  A Hebrew translation exists (by Open univ.)  You will really need to read!!

4. 4 Student's Responsibilities: During the semester you will need to submit:  6-7 theoretical assignments  3 programming projects

5. 5 Final Grade If final exam < 60 then grade = fail else grade = 0.2 *assignmnets + 0.8 * final exam. Warning: DS is (considered) a difficult course.

6. 6 Today  What is data structure?  What is it good for?  Getting started  An overview of the course

7. 7 Solving a problem Input  manipulation  output

8. 8 input  algorithm  output

9. 9 Algorithm Data {input}  {data manipulated}  Data {output} 2,1,12,7 1,2,7,12 Shimon    

10. 10 Solving a problem Data: information for analysis. e.g., numbers, words, songs, movies Algorithm: A well-defined procedure to solve a problem Data structure: the way the data is organized

11. 11 The Sorting Problem Input: A sequence of n numbers Output: A permutation (reordering) of the input sequence such that b 1 ≤b 2 … ≤b n Note: the sets {a 1,a 2,..,a n }= {b 1,b 2,..,b n } Example:  input:  output:

12. 12 Insertion Sort  Picking the elements 1 by 1 from the sequence  For each element insert it into correct place in the sequence of already sorted elements  Until last element inserted into place

13. 13 Insertion Sort 524613 254613254613 245613245613 245613245613 124563124563 123456123456

14. 14 What is missing?  How the data (numbers) are represented:  Each number: binary  The sequence of numbers: ?  The operations required in the chosen representation?  Picking the elements 1 by 1 from the sequence  For each element insert it into correct place in the sequence of already sorted elements  Until last element inserted into place

15. 15 Insertion Sort (use array) Insertion-Sort(A) for i  2 to length[A] key  A[i] j  i-1 while j>0 and A[j]>key A[j+1]  A[j] j  j-1 end A[j+1]  key end 524613 What is the worse case?

16. 16 Pseudocode  In the lectures I will be presenting algorithms in pseudocode.  This is very common in the computer science literature  Pseudocode is usually easily translated to real code.  Pseudocode should also be used for homework

17. 17 Pseudocode  The algorithms you design in homework will be read by a person, not a computer  The No Code Rule:  Do not turn in Java or C code when asked for pseudocode  Explain algorithm precisely, but without all the details needed for a computer code

18. 18 Pseudocode example (good) Insertion-Sort(A) for i  2 to length[A] key  A[i] j  i-1 while j>0 and A[j]>key A[j+1]  A[j] j  j-1 end A[j+1]  key end

19. 19 Java code public static void insertionSort (int[] array){ for (int j = 1; j < array.length; j++) { int key = array[j]; int k = j - 1; while(k >= 0 && array[k] > key) { array[k+1] = array[k]; k--; } array[k+1] = key; }

20. 20 What is a Data Structure? The way the data is organized  What do we mean by “way”?  The organization should allow an efficient use of the data

21. 21 Abstract Data Type An abstract mathematical definition of objects, with operations defined on them

22. 22 Elementary Data Structures  Arrays  Lists  Stacks  Queues  Trees RF 1 2 3 4 56 78 In some languages these are basic data types – in others they need to be implemented head

23. 23 Examples  Basic Types  integer, real (floating point), boolean (0,1), character  Arrays  A[0..99] : integer array  A[0..99] : array of images 0 1 2 3 4 5 6 7 99 A … 2 1 3 3 2 9 9 6 10 0 1 2 99 …

24. 24 A mapping from an index set, such as {0,1,2,…,n}, into a cell type Objects: set of cells Operations:  create(A,n)  put(A,v,i) or A[i]  v  value(A,i) ADT: Array

25. 25 Simple Linked List Group data together in a linear and flexible way. Example: ABAC R Add an element (Firsy in the list)

26. 26 Examples of Lists  List of numbers  List of names  List of lists  List of arrays  Representing a sparse high order polynomial

27. 27 Objects: Sets of elements (e.g., integers) Operations:  Create a set  Insert an element  Remove an element  Check membership  Minimum  Maximum {5,1,2,2…,3} ADT: Finite Dynamic Sets

28. 28 Data Structures  Representation of objects of an Abstract Data Type (ADT)  Algorithms manipulate the data structures to implement the operations of the ADT ADT: An abstract mathematical definition of objects, with operations defined on them

29. 29 Objects: Finite sequences of nodes Operations:  Create  On a list  Get the first node  On a node  Get data  Get next node  Assign value to data  Assign next node ADT: Basic Linked List ABA nil

30. Examples of using linked list Operations 30

31. 31 Basic List Operations: in pseudo code  head[L] - the first node of L (in Java: L.head)  next[x] - the next node in L or NIL if x is the tail of L (in Java: x.next)  data[x] – the node data (in Java: x.data)

32. 32 More list operations Low level:  List-Search(L,k)  List-head-Insert(L,x)  Insert-after-key(L,k,x)  List-tail-Insert(L,x)  List-Delete(L,k) Higher level:  Sort(L)  Reverse(L) Can be implemented using the basic list operations

33. 33 Searching List-Search(L,k) x  head[L] while (x  NIL) and (data[x]  k) dox  next[x] return(x)

34. 34 Inserting into the head List-head-Insert(L,x) next[x]  head[L] head[L]  x

35. 35 Insert after a key k Value NULL L node ValueNext node k Insert the value v after P Next Value v Next

36. 36 Insert after a key Insert-after-key(L,k,x) y  List-Search(L,k) if y  NIL next[x]  next[y] next[y]  x end

37. 37 Linked List Delete a key L ValueNext node Value Next node k NULL ValueNext

38. 38 Linked List Delete a key L ValueNext node To delete the node pointed to by Q, need a pointer to the previous node; Value Next node Q NULL

39. 39 Linked List Delete L ValueNext node Value Next node NULL k prev_x

40. 40 Deleting a key List-Delete ( L,k) x  head[L] prev_x= head[L] while (x  NIL) and (data[x]  k) do prev_x  x x  next[x] end if prev_x  NIL next[prev_x]  next[x] end

41. 41 Doubly Linked Lists  As mentioned, for delete we need ‘findPrevious’. This is a slow [O(N)] function - because we cannot go directly to previous node  Solution: Keep a "previous" pointer at each node. head prev

42. 42 Double Link Pros and Cons  Advantage  Delete (not DeleteAfter) and FindPrev are faster  Disadvantages:  More space used up (double the number of pointers at each node)  More book-keeping for updating the two pointers at each node (pretty negligible overhead)

43. 43 Insertion Sort Using Linked Lists 98106 98 6 98 6

44. 44 Data Structure: linked list implementation  Using records and pointers  Using arrays

45. 45 Pointer Implementation Basic Idea  Data: For each node allocate memory  Pointer: Keep a pointer to the memory location. Value NULL L node ValueNext node Next

46. 46 Records A record (also called a struct, similar to object)  Group data together that are related  To access the fields we use “dot” notation. Example: x: name and image Example: x.name x.image imagename Elton John

47. 47 Pointer  A pointer is a reference to a variable or record (or to an object in Java world).  In C, if X is of type pointer to Y then *X is of type Y – same for pseudocode Example: x : record pointer record*x

48. 48 A node: a record which contains a pointer  Group data and a pointer  To access the fields we use Name: text Image: image Example: x : complex number Example: x.name x.image x.next next: node reference (a pointer) name[x] image [x] next[x] OR

49. 49 Simple Linked List A linked list  Group data together in a flexible, dynamic way. 491320 L : node pointer record node : ( data : integer (or any other structure) next : node pointer )

50. 50 Pointer Implementation Issues  Whenever you break a list, your code should fix the list up as soon as possible  Draw pictures of the list to visualize what needs to be done  Pay special attention to boundary conditions:  Empty list  Single item – same item is both first and last  Two items – first, last, but no middle items  Three or more items – first, last, and middle items

51. 51 Implementing Pointers using Arrays  This is needed in languages like Fortran, Basic, and assembly language  Easiest when number of records is known ahead of time.  Each record field of a basic type is associated with an array.  A pointer field is an unsigned integer indicating an array index.

52. 52 Idea data next n nodes 0 1 2 3 4 5. n-1 data : basic type next : node pointer D N D[ ] : basic type array N[ ] : integer array Pointer is an integer nil is -1 p.data is D[p] p.next is N[p] Two variables: L (head of list) Free (used for node allocation) Pointer WorldNonpointer World

53. 53 Initialization 012345...012345... 0 1 2 3 n-2 D N Free = n-1 means 0 1 2 3 4 5. n-1 D N nil Free

54. 54 Example of Use abc L null c a 2 5 7 D N b 1 4 0 0123456701234567 n = 8 L = 3 Free = 6 InsertFront (L, x) if (Free ≠ -1) then q  Free else return “overflow”; Free  N[Free]; D[q]  x; N[q]  L; L  q;

55. 55 Try DeleteFront  Define the cursor implementation of DeleteFront which removes the first member of the list when there is one.  Remember to add garbage to free list. DeleteFront (L) { ??? }

56. 56 DeleteFront Solution DeleteFront (L) if L = -1 then return “underflow” else q  L; L  N[L]; N[q]  Free; Free  q; c a 2 5 7 D N b 1 4 0 0123456701234567 n = 8 L = 3 Free = 6 abc L null 3 0 0 7 8 2 5 1 n = 8 L = 5 Free = 4

57. 57 Insert Running Time  List implementation by array  Worst case is insert at position 0. Must move all N items one position before the insert  On average, must move half the elements to make room – assuming insertions at positions are equally likely  Probably too slow  List implementation by Pointers:  Independent on the list length

58. 58 Summary  ADT: An abstract mathematical definition of objects, with operations defined on them  Data Structures:  Representation of objects of an Abstract Data Type (ADT)  Algorithms manipulate the data structures to implement the operations of the ADT  Examples

59. 59 Next Class  Application example of lists: Sparse Polynomial  Stacks  Queues

60. 60 Course Overview  Introduction to many of the basic data structures used in computer software  Understand the data structures  How to implement them  Analyze the algorithms that use them  Know when to apply them  Practice design and analysis of data structures.  Practice using these data structures by writing programs.

61. 61 Application example: Sparse Polynomials  10 + 4 x 2 + 20 x 40 + 8 x 86 0 10 2 4 40 20 86 8 P record poly : ( exp : integer, coef : integer, next : poly pointer ) exp coef next