Abstract Data Types

Key structure

LinAsm abstract data types can hold any kind of data you may need. Numbers, strings, structures, classes and another data types. Each LinAsm data type simply stores elements which are just regular "C" structures. All element structures have the two fields: key and data, both are just an unions that can hold numeric data and void pointers to another memory blocks.

Deque adt

Double-ended queue (deque) is an abstract data type that generalizes a queue, for which elements can be added to or removed from either the front (head) or back (tail). This differs from the queue abstract data type, where elements can only be added to one end and removed from the other. Deque data class has some additional forms:

• An input-restricted deque is one where deletion can be made from both ends, but insertion can be made at one end only.
• An output-restricted deque is one where insertion can be made at both ends, but deletion can be made from one end only.

List adt

Doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes. The two node links allow traversal of the list in either direction. While adding or removing a node in a doubly-linked list requires changing more links than the same operations on a singly linked list, the operations are simpler and potentially more efficient (for nodes other than first nodes) because there is no need to keep track of the previous node during traversal or no need to traverse the list to find the previous node, so that its link can be modified.

Max heap adt

Max heap is a specialized tree-based data structure that satisfies the heap property: either the keys of parent nodes are always greater than or equal to those of the children, and the highest key is in the root node. There is no implied ordering among siblings or cousins and no implied sequence for an in-order traversal. The heap relation mentioned above applies only among nodes and their immediate parents. The heap is one maximally efficient implementation of an abstract data type called a priority queue, and in fact priority queues are often called "heaps", regardless of how they may be implemented.

Min heap adt

Min heap is a specialized tree-based data structure that satisfies the heap property: either the keys of parent nodes are always less than or equal to those of the children, and the least key is in the root node. There is no implied ordering among siblings or cousins and no implied sequence for an in-order traversal. The heap relation mentioned above applies only among nodes and their immediate parents. The heap is one maximally efficient implementation of an abstract data type called a priority queue, and in fact priority queues are often called "heaps", regardless of how they may be implemented.

Multi hash adt

A hash table is a data structure used to implement an associative array, a structure that can map keys to values. It uses a hash function to compute an index into an array of buckets or slots, from which the correct value can be found. In a hash table, the average cost (number of instructions) for each lookup is independent of the number of elements stored in the table. Hash table also allows arbitrary insertions and deletions of key-value pairs, at constant average cost per operation.

Multi tree adt

Multi tree is a b-tree based data structure, which allows to store multiple instances of the same key. A tree data structure keeps data sorted and allows searches, insertions, and deletions in logarithmic time. The B-tree is a generalization of a binary search tree in that a node can have more than two children. Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems, where most operations to the main memory is too slow, and should be minimized. Modern systems have very fast cache memory and relatively slow RAM memory. In memory b-trees minimize cache misses and significantly improve main tree operations.

Ring adt

Circular doubly linked list is a linked data structure that consists of a set of circularly linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes. Nodes are wrapped in the ring, where last element is pointing to first element in the list and vice versa. The two node links allow traversal of the list in either direction. While adding or removing a node in a doubly-linked list requires changing more links than the same operations on a singly linked list, the operations are simpler and potentially more efficient (for nodes other than first nodes) because there is no need to keep track of the previous node during traversal or no need to traverse the list to find the previous node, so that its link can be modified.

Stack adt

Stack is a particular kind of abstract data type in which the operations on the elements are the addition, known as push and removal, known as pop. The relation between the push and pop operations is such that the stack is a LIFO data structure. In a LIFO data structure, the last element added to the structure must be the first one to be removed. This is equivalent to the requirement that, considered as a linear data structure, the push and pop operations occur only at one end of the structure, referred to as the top of the stack. A stack is a restricted data structure, because only a small number of operations are performed on it.

Unique hash adt

A hash table is a data structure used to implement an associative array, a structure that can map keys to values. It uses a hash function to compute an index into an array of buckets or slots, from which the correct value can be found. In a hash table, the average cost (number of instructions) for each lookup is independent of the number of elements stored in the table. Hash table also allows arbitrary insertions and deletions of key-value pairs, at constant average cost per operation.

Unique tree adt

Unique tree is a b-tree based data structure, which allows to store only one instance of each key. A tree data structure keeps data sorted and allows searches, insertions, and deletions in logarithmic time. The B-tree is a generalization of a binary search tree in that a node can have more than two children. Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems, where most operations to the main memory is too slow, and should be minimized. Modern systems have very fast cache memory and relatively slow RAM memory. In memory b-trees minimize cache misses and significantly improve main tree operations.

Vector adt

Vector is an abstract data type, which is differ from list in their access properties. A vector is a random access data structure, whereas lists are strictly sequential access. With a list of a thousand elements it takes longer to access the last element than the first, but with a vector the times are the same. Vector can be treated as an array of objects, where each object can be accessed by its index. Vector data type supports all the standard operations as array, such as accessing elements by index value, key searching, counting and sorting elements.