Definition: Data Structure
= is the process of keeping data into a computer system. It is eventually made from keeping data or finding data up to the process of storing. The first thing to do is to look for the data that you’re going to keep then after you have that data, the next thing to do is store it in the computer system. You must encode the data or information that is very important then save it into your computer. The purpose of data structure is how to preserve a data into the safest receptacle which is computer system. Personal Definition:
= in computer science is a way of storing data in a computer so that it can be used efficiently. http://en.wikipedia.org/wiki/Data_structure
= an organization of mathematical and logical concepts of data. Often a carefully chosen data structure will allow the most efficient algorithm to be used. -http://en.wiktionary.org/wiki/data_structure
= can be viewed as an interface between two functions or as an implementation of methods to access storage that is organized according to the associated data type. http://www.cplusplus.com/doc/tutorial/structures.html
= are implemented by a programming language as data types and the references and operations they provide. http://en.wikipedia.org/wiki/Data_structure
= a means of storing a collection of data. -http://www.cs.ucc.ie/~dgb/courses/swd/glossary.html
= allows a variety of critical operations to be performed, using as few resources, both execution time and memory space, as possible. http://en.wikipedia.org/wiki/Data_structure
= the study of methods for effectively using a computer to solve problems, or in other words, determining exactly the problem to be solved. http://www.cplusplus.com/doc/tutorial/structures.html
= are suited to different kinds of applications, and some are highly specialized to certain tasks. -http://www.itl.nist.gov/div897/sqg/dads/HTML/datastructur.html
= is a group of data elements grouped together under one name. These data elements, known as members, can have different types and different lengths. Data structures are declared in C++ using the following syntax. -http://en.wikipedia.org/wiki/Data_structure
B.)
1. Deque Data Structure
- n computer science theory, a deque (short for double-ended queue—usually pronounced deck) is an abstract list type data structure, also called a head-tail linked list, for which elements can only be added to or removed from the front (head) or back (tail).
Structure
Deque is sometimes written dequeue, but this use is generally deprecated in technical literature or technical writing because dequeue is also a verb meaning "to remove from a queue". Nevertheless, several libraries and some writers, such as Aho, Hopcroft, and Ullman in their textbook Data Structures and Algorithms, spell it dequeue. DEQ and DQ are also used.
Implementations
There are at least two common ways to efficiently implement a deque: with a modified dynamic array or with a doubly-linked list. For information about doubly-linked lists, see the linked list article.
Dynamic array implementation
Deques are often implemented using a variant of a dynamic array that can grow from both ends, sometimes called array deques. These array deques have all the properties of a dynamic array, such as constant time random access, good locality of reference, and inefficient insertion/removal in the middle, with the addition of amortized constant time insertion/removal at both ends, instead of just one end. Two common implementations include:
- Storing deque contents in a circular buffer, and only resizing when the buffer becomes completely full. This decreases the frequency of resizings, but requires an expensive branch instruction for indexing.
- Allocating deque contents from the center of the underlying array, and resizing the underlying array when either end is reached. This approach may require more frequent resizings and waste more space, particularly when elements are only inserted at one end.
Language support
C++'s Standard Template Library provides the templated classes std::deque and std::list, for the dynamic array and linked list implementations, respectively.
As of Java 6, Java's Collections Framework provides a new Deque interface that provides the functionality of insertion and removal at both ends. It is implemented by classes such as ArrayDeque (also new in Java 6) and LinkedList, providing the dynamic array and linked list implementations, respectively.
Python 2.4 introduced the collections module with support for deque objects.
2. Heap Data Structure
THE STRUCTURE
-In computer science, a heap is a specialized tree-based data structure that satisfies the heap property: if B is a child node of A, then key(A) ≥ key(B). This implies that an element with the greatest key is always in the root node, and so such a heap is sometimes called a max heap. (Alternatively, if the comparison is reversed, the smallest element is always in the root node, which results in a min heap.) This is why heaps are used to implement priority queues. The efficiency of heap operations is crucial in several graph algorithms.
OPERATION TO GET CONTENTS ON THE NODES:
The operations commonly performed with a heap are
- delete-max or delete-min: removing the root node of a max- or min-heap, respectively
- increase-key or decrease-key: updating a key within a max- or min-heap, respectively
- insert: adding a new key to the heap
- merge: joining two heaps to form a valid new heap containing all the elements of both.
The following complexities[1] are worst-case for binary and binomial heaps and amortized complexity for Fibonacci heap. O(f) gives asymptotic upper bound and Θ(f) is asymptotically tight bound (see Big O notation). Function names assume a min-heap.
| Operation | |||
| createHeap | Θ(1) | Θ(1) | Θ(1) |
| findMin | Θ(1) | Θ(lg n) or Θ(1) | Θ(1) |
| deleteMin | Θ(lg n) | Θlg n) | O(lg n) |
| insert | Θ(lg n) | O(lg n) | Θ(1) |
| decreaseKey | Θ(lg n) | Θ(lg n) | Θ(1) |
| merge | Θ(n) | O(lg n) | Θ(1) |
For pairing heaps the insert and merge operations are conjectured[citation needed] to be O(1) amortized complexity but this has not yet been proven. decreaseKey is not O(1) amortized complexity [1] [2]
HEAP RETRIEVAL
Heaps are a favorite data structures for many applications.
- Heapsort: One of the best sorting methods being in-place and with no quadratic worst-case scenarios.
- Selection algorithms: Finding the min, max or both of them, median or even any k-th element in sublinear time[citation needed] can be done dynamically with heaps.
- Graph algorithms: By using heaps as internal traversal data structures, run time will be reduced by an order of polynomial. Examples of such problems are Prim's minimal spanning tree algorithm and Dijkstra's shortest path problem.
Interestingly, full and almost full binary heaps may be represented using an array alone. The first (or last) element will contain the root. The next two elements of the array contain its children. The next four contain the four children of the two child nodes, etc. Thus the children of the node at position n would be at positions 2n and 2n+1 in a one-based array, or 2n+1 and 2n+2 in a zero-based array. Balancing a heap is done by swapping elements which are out of order. As we can build a heap from an array without requiring extra memory (for the nodes, for example), heapsort can be used to sort an array in-place.
One more advantage of heaps over trees in some applications is that construction of heaps can be done in linear time using Tarjan's algorithm.
HEAP IMPLEMENTATION
- The C++ Standard Template Library provides the make_heap, push_heap and pop_heap algorithms for binary heaps, which operate on arbitrary random access iterators. It treats the iterators as a reference to an array, and uses the array-to-heap conversion detailed above.
3. VLIST DATA STRUCTURES
In computer science, the VList is a persistent data structure designed by Phil Bagwell in 2002 that combines the fast indexing of arrays with the easy extension of cons-based (or singly-linked) linked lists.[1]
OPERATIONS TO ENTER ELEMENTS(DATA)
The primary operations of a VList are:
- Locate the kth element (O(1) average, O(log n) worst-case)
- Add an element to the front of the VList (O(1) average, with an occasional allocation)
- Obtain a new array beginning at the second element of an old array (O(1))
- Compute the length of the list (O(log n))
STRUCTURE
The underlying structure of a VList can be seen as a singly-linked list of arrays whose sizes decrease geometrically; in its simplest form, the first contains the first half of the elements in the list, the next the first half of the remainder, and so on. Each of these blocks stores some information such as its size and a pointer to the next.
The average constant-time indexing operation comes directly from this structure; given a random valid index, we simply observe the size of the blocks and follow pointers until we reach the one it should be in.
DATA RETRIEVAL
Because the lists are constructed incrementally, the first array in the array list may not contain twice as many values as the next one, although the rest do; this does not significantly impact indexing performance. We nevertheless allocate this much space for the first array, so that if we add more elements to the front of the list in the future we can simply add them to this list and update the size. If the array fills up, we create a new array, twice as large again as this one, and link it to the old first array.
No comments:
Post a Comment