Question? Leave a message!
I Agree to Thesis Scientist
Terms and Conditions
Not a member?
Sign Up Now
Register a Free Account
I Agree to Thesis Scientist
Terms and Conditions
Sign up At Thesis Scientist
Done, your profile is created.Finish your profile by filling in the following fields
Earn Money,Free Notes
Password sent to your Email Id, Please Check your Mail
Updating Cart........ Please Wait........
Data Structures and Algorithms
Data Structures and Algorithms
ECE 250 Algorithms and Data Structures Data Structures and Algorithms Douglas Wilhelm Harder, M.Math. LEL Department of Electrical and Computer Engineering University of Waterloo Waterloo, Ontario, Canada ece.uwaterloo.ca dwharderalumni.uwaterloo.ca © 20062013 by Douglas Wilhelm Harder. Some rights reserved.Data Structures and Algorithms 2 2.2 Outline This topic will describe: – The concrete data structures that can be used to store information – The basic forms of memory allocation • Contiguous • Linked • Indexed – The prototypical examples of these: arrays and linked lists – Other data structures: • Trees • Hybrids • Higherdimensional arrays – Finally, we will discuss the runtime of queries and operations on arrays and linked listsData Structures and Algorithms 3 2.2.1 Memory Allocation Memory allocation can be classified as either – Contiguous – Linked – Indexed Prototypical examples: – Contiguous allocation: arrays – Linked allocation: linked listsData Structures and Algorithms 4 220.127.116.11 Memory Allocation Contiguous, adj. Touching or connected throughout in an unbroken sequence. Meriam Webster Touching, in actual contact, next in space; meeting at a common boundary, bordering, adjoining. www.oed.comData Structures and Algorithms 5 2 2.2 .2.1 .1.1 Contiguous Allocation An array stores n objects in a single contiguous space of memory Unfortunately, if more memory is required, a request for new memory usually requires copying all information into the new memory – In general, you cannot request for the operating system to allocate to you the next n memory locationsData Structures and Algorithms 6 18.104.22.168 Linked Allocation Linked storage such as a linked list associates two pieces of data with each item being stored: – The object itself, and – A reference to the next item • In C++ that reference is the address of the next nodeData Structures and Algorithms 7 22.214.171.124 Linked Allocation This is a class describing such a node template typename Type class Node private: Type element; Node nextnode; public: // ... ;Data Structures and Algorithms 8 126.96.36.199 Linked Allocation The operations on this node must include: – Constructing a new node – Accessing (retrieving) the value – Accessing the next pointer Node( const Type = Type(), Node = nullptr ); Type retrieve() const; Node next() const; Pointing to nothing has been represented as: C NULL Java/C null C++ (old) 0 C++ (new) nullptr Symbolically ØData Structures and Algorithms 9 188.8.131.52 Linked Allocation For a linked list, however, we also require an object which links to the first object The actual linked list class must store two pointers – A head and tail: Node head; Node tail; Optionally, we can also keep a count int count; The nextnode of the last node is assigned nullptrData Structures and Algorithms 10 184.108.40.206 Linked Allocation The class structure would be: template typename Type class List private: NodeType head; NodeType tail; int count; public: // constructor(s)... // accessor(s)... // mutator(s)... ;Data Structures and Algorithms 11 220.127.116.11 Indexed Allocation With indexed allocation, an array of pointers (possibly NULL) link to a sequence of allocated memory locations Used in the C++ standard template library Computer engineering students will see indexed allocation in their operating systems courseData Structures and Algorithms 12 18.104.22.168 Indexed Allocation Matrices can be implemented using indexed allocation: 1 2 3 456 Data Structures and Algorithms 13 22.214.171.124 Indexed Allocation Matrices can be implemented using indexed allocation – Most implementations of matrices (or higherdimensional arrays) use indices pointing into a single contiguous block of memory Columnmajor order Rowmajor order 1 2 3 456 C, Python Matlab, FortranData Structures and Algorithms 14 2.2.2 Other Allocation Formats We will look at some variations or hybrids of these memory allocations including: – Trees – Graphs – Deques (linked arrays) – inodesData Structures and Algorithms 15 126.96.36.199 Trees The linked list can be used to store linearly ordered data – What if we have multiple next pointers A rooted tree (weeks 46) is similar to a linked list but with multiple next pointersData Structures and Algorithms 16 188.8.131.52 Trees A tree is a variation on a linked list: – Each node points to an arbitrary number of subsequent nodes – Useful for storing hierarchical data – We will see that it is also useful for storing sorted data – Usually we will restrict ourselves to trees where each node points to at most two other nodesData Structures and Algorithms 17 184.108.40.206 Graphs Suppose we allow arbitrary relations between any two objects in a container 2 – Given n objects, there are n– n possible relations 2 nn • If we allow symmetry, this reduces to 2 – For example, consider the networkData Structures and Algorithms 18 220.127.116.11 Arrays Suppose we allow arbitrary relations between any two objects in a container – We could represent this using a twodimensional array A B C D E F G H I J K L – In this case, the matrix is symmetric A × × × B × × × × × C × × × × × × D × × × E × × F × × G × × × H × × × I × × J × × × K × × × L × × ×Data Structures and Algorithms 19 18.104.22.168 Array of Linked Lists Suppose we allow arbitrary relations between any two objects in a container – Alternatively, we could use a hybrid: an array of linked lists A B C D E F G H I J K LData Structures and Algorithms 20 22.214.171.124 Linked Arrays Other hybrids are linked lists of arrays – Something like this is used for the C++ STL deque container For example, the alphabet could be stored either as: – An array of 26 entries, or – A linked list of arrays of 8 entriesData Structures and Algorithms 21 126.96.36.199 Hybrid data structures The Unix inode was used to store information about large files – The first twelve entries can reference the first twelve blocks (48 KiB)Data Structures and Algorithms 22 188.8.131.52 Hybrid data structures The Unix inode was used to store information about large files – The next entry is a pointer to an array that stores the next 1024 blocks This stores files up to 4 MiB on a 32bit computerData Structures and Algorithms 23 184.108.40.206 Hybrid data structures The Unix inode was used to store information about large files – The next entry has two levels of indirection for files up to 4 GiBData Structures and Algorithms 24 220.127.116.11 Hybrid data structures The Unix inode was used to store information about large files – The last entry has three levels of indirection for files up to 4 TiBData Structures and Algorithms 25 2.2.3 Algorithm run times Once we have chosen a data structure to store both the objects and the relationships, we must implement the queries or operations as algorithms – The Abstract Data Type will be implemented as a class – The data structure will be defined by the member variables – The member functions will implement the algorithms The question is, how do we determine the efficiency of the algorithmsData Structures and Algorithms 26 2.2.3 Operations We will us the following matrix to describe operations at the locations within the structure Arbitrary st th Front/1 Back/n Location Find Insert Erase Data Structures and Algorithms 27 18.104.22.168 Operations on Sorted Lists Given an sorted array, we have the following run times: Arbitrary st th Front/1 Back/n Location Find Good Okay Good Insert Bad Bad Good Bad Erase Bad Bad Good only if the array is not fullData Structures and Algorithms 28 22.214.171.124 Operations on Lists If the array is not sorted, only one operations changes: Arbitrary st th Front/1 Back/n Location Find Good Bad Good Insert Bad Bad Good Bad Erase Bad Bad Good only if the array is not fullData Structures and Algorithms 29 126.96.36.199 Operations on Lists However, for a singly linked list where we a head and tail pointer, we have: Arbitrary st th Front/1 Back/n Location Find Good Bad Good Insert Good Bad Good Erase Good Bad BadData Structures and Algorithms 30 188.8.131.52 Operations on Lists th If we have a pointer to the k entry, we can insert or erase at that location quite easily Arbitrary st th Front/1 Back/n Location Find Good Bad Good Insert Good Good Good Erase Good Good Bad – Note, this requires a little bit of trickery: we must modify the value th stored in the k node – This is a common coop interview questionData Structures and Algorithms 31 184.108.40.206 Operations on Lists For a doubly linked list, one operation becomes more efficient: Arbitrary st th Front/1 Back/n Location Find Good Bad Good Insert Good Good Good Erase Good Good GoodData Structures and Algorithms 32 Following Classes The next topic, asymptotic analysis, will provide the mathematics that will allow us to measure the efficiency of algorithms It will also allow us the measure the memory requirements of both the data structure and any additional memory required by the algorithmsData Structures and Algorithms 33 Following Classes Following our discussion on asymptotic and algorithm analysis, we will spend – 13 lectures looking at data structures for storing linearly ordered data – One week looking at data structures for relationfree data – Four lectures on sorting – One week on partial orderings and adjacency relations, and – Two weeks on algorithm design techniquesData Structures and Algorithms 34 Summary In this topic, we have introduced the concept of data structures – We discussed contiguous, linked, and indexed allocation – We looked at arrays and linked lists – We considered • Trees • Twodimensional arrays • Hybrid data structures – We considered the run time of the algorithms required to perform various queries and operations on specific data structures: • Arrays and linked listsData Structures and Algorithms 35 References Wikipedia, https://en.wikipedia.org/wiki/Datastructure These slides are provided for the ECE 250 Algorithms and Data Structures course. The material in it reflects Douglas W.Harder’s best judgment in light of the information available to him at the time of preparation. Any reliance on these course slides by any party for any other purpose are the responsibility of such parties. Douglas W. Harder accepts no responsibility for damages, if any, suffered by any party as a result of decisions made or actions based on these course slides for any other purpose than that for which it was intended.
Add To Cart
Data communications and Networking for beginners
Lecture notes for Advanced data structures and Algorithms
Data Structures and Algorithms PPT
Data Structures and Algorithms in Python
Lecture Notes on Data Structures and Algorithms for Big Databases
Lecture notes on Data structures and Algorithms and C
LECTURE NOTES ON DATA STRUCTURES USING C
Lecture notes on Data structure using C
Problem Solving with Algorithms and Data Structures
Data Structures Trees Basics
Lecture notes in Discrete Structures
Lecture notes on Graphs in Data Structures
THE FEDERAL BIG DATA RESEARCH AND DEVELOPMENT STRATEGIC PLAN
What are Qualitative Data Collection Techniques
Improvements in Oracle Database 11g
Study With Thesis Scientist
How to Sell
Tips and Tricks
Get To Know Us
© Copyright @ Thesis Scientist Pvt. Ltd.
Terms & Conditions
Tips & Tricks