I've received a few PM's over the last couple weeks with requests asking how to get started learning data structures. This entry will cover a list of competencies associated with an ideal Data Structures and Algorithms I course. Some courses I've seen may focus on OOP more than the more advanced topics listed, and push the rest to the Data Structures II class. It really depends on your school. In my opinion, all of these are important for a strong foundation in computer science.

-Linked Lists: This data structure is perhaps one of the more challenging for students to grasp, simply due to the concept of working with linked Nodes instead of fixed array indices. Topics associated with Linked Lists include singly, doubly, and circularly linked lists, understanding the importance of the linked Nodes, Big-O analysis of the major List operations (insertion, removal, and lookup), and studying the various methods of sorting Linked Lists. Searching algorithms include binary vs. linear search, and sorting algorithms that should be covered include insertion sort and mergesort at the very least.

-Hashtables and Hashing: This section doesn't fit in as cleanly with the rest of the sections, so covering it early is, in my opinion, a better way to approach it. There are a number of different hashing algorithms that can be covered. The important concepts deal with collision and perfect hashing, leading up to designing a hashtable data structure.

-Stacks, Queues, Deques: These data structures either expand on linked lists or arrays. It is important to compare and contrast the implementations of each with both linked lists and arrays.

-Recursion: While recursion may be covered in an intro to programming class, there is no guarantee. Regardless, it is good to review recursion from a data structures perspective to better understand how the call stack works, as well as introducing the recursive nature of trees and the depth-first traversal algorithm.

-Trees, Binary Heaps, Graphs: These will be towards the end of the data structures course. It is important to introduce rooted Trees, understanding it as an acyclic, directed graph and recursively defined. Binary heaps are a logical next step, and both the array and tree implementations should be covered. It is also important to recognize the usage of the "bubbling" algorithm to swap elements in a similar manner as bubble sort. Finally, Graphs should be covered to the point where one is comfortable implementing the structure. In this unit, the breadth-first and depth-first algorithms should be reviewed as well.

-Additional topics: If there is time remaining in a Data Structures I course, the ideal topics to cover should hit more on Graph Theory. The Shunting-Yard algorithm is good to cover, introducing infix, prefix, and postfix traversals for trees as well. Dijkstra's algorithm may be introduced, as well as minimum spanning tree algorithms including Prim's and Kruskal's algorithms.

-Linked Lists: This data structure is perhaps one of the more challenging for students to grasp, simply due to the concept of working with linked Nodes instead of fixed array indices. Topics associated with Linked Lists include singly, doubly, and circularly linked lists, understanding the importance of the linked Nodes, Big-O analysis of the major List operations (insertion, removal, and lookup), and studying the various methods of sorting Linked Lists. Searching algorithms include binary vs. linear search, and sorting algorithms that should be covered include insertion sort and mergesort at the very least.

-Hashtables and Hashing: This section doesn't fit in as cleanly with the rest of the sections, so covering it early is, in my opinion, a better way to approach it. There are a number of different hashing algorithms that can be covered. The important concepts deal with collision and perfect hashing, leading up to designing a hashtable data structure.

-Stacks, Queues, Deques: These data structures either expand on linked lists or arrays. It is important to compare and contrast the implementations of each with both linked lists and arrays.

-Recursion: While recursion may be covered in an intro to programming class, there is no guarantee. Regardless, it is good to review recursion from a data structures perspective to better understand how the call stack works, as well as introducing the recursive nature of trees and the depth-first traversal algorithm.

-Trees, Binary Heaps, Graphs: These will be towards the end of the data structures course. It is important to introduce rooted Trees, understanding it as an acyclic, directed graph and recursively defined. Binary heaps are a logical next step, and both the array and tree implementations should be covered. It is also important to recognize the usage of the "bubbling" algorithm to swap elements in a similar manner as bubble sort. Finally, Graphs should be covered to the point where one is comfortable implementing the structure. In this unit, the breadth-first and depth-first algorithms should be reviewed as well.

-Additional topics: If there is time remaining in a Data Structures I course, the ideal topics to cover should hit more on Graph Theory. The Shunting-Yard algorithm is good to cover, introducing infix, prefix, and postfix traversals for trees as well. Dijkstra's algorithm may be introduced, as well as minimum spanning tree algorithms including Prim's and Kruskal's algorithms.

### 3 Comments On This Entry

Page 1 of 1

#### keziahcook

25 September 2012 - 08:07 AM
I need this lesson

cause my instructor in college always absent and she never teach well about this data structurer

cause my instructor in college always absent and she never teach well about this data structurer

Page 1 of 1

### ← October 2016 →

S | M | T | W | T | F | S |
---|---|---|---|---|---|---|

1 | ||||||

2 | 3 | 4 | 5 | 6 | 7 | 8 |

9 | 10 | 11 | 12 | 13 | 14 | 15 |

16 | 17 | 18 | 19 | 20 | 21 | 22 |

23
| 24 | 25 | 26 | 27 | 28 | 29 |

30 | 31 |

### My Blog Links

### Recent Entries

### Recent Comments

### Search My Blog

### 0 user(s) viewing

**0**Guests

**0**member(s)

**0**anonymous member(s)