Professional Documents
Culture Documents
-- Data processing often involves in processing huge volumes of data. Many Companies handle million records of data stored in database. Many ways are formulated to handle data efficiently. -- An User-defined data type is a combination of different primary data types, which represents a complex entity. -- An Abstract Data Type ( A D T ) not only represents a set of complex data objects, but also includes a set of operations to be performed on these objects, defines that how the data objects are organized. -- The group of methods implements a set rules, which defines a logical way of handling data. -- The complex entity along with its group of methods is called Abstract Data Type ( A D T ) . -- Data structure is described as an instance of Abstract Data Type ( ADT ). -- We can define that Data structure is a kind of representation of logical relationship between related data elements. In data structure, decision on the operations such as storage, retrieval and access must be carried out between the logically related data elements.
Data Structure Linear Linear Lists Stacks Queues Non-Linear Trees Graphs
Some Common Operations on Data structures Insertion : adding a new element to the collection. Deletion : removing an element from a collection. Traversal : access and examine each element in collection. Search : find whether an element is present or not. Sorting : rearranging elements in a particular order. Merging : combining two collections into one collection.
Some Data structures Arrays Strings Lists Stacks Queues Trees Graphs Dictionaries Maps Hash Tables Sets Lattice Neural-Nets
2)
What is a Linked List The elements of a linked list are not constrained to be stored in adjacent locations. The individual elements are stored somewhere in memory, rather like a family dispersed, but still bound together. The order of the elements is maintained by explicit links between them.
3)
4)
5)
The Linked List is a collection of elements called nodes, each node of which stores two items of information, i.e., data part and link field. -- The data part of each node consists the data record of an entity. -- The link field is a pointer and contains the address of next node. -- The beginning of the linked list is stored in a pointer termed as head which points to the first node. -- The head pointer will be passed as a parameter to any method, to perform an operation. -- First node contains a pointer to second node, second node contains a pointer to the third node and so on. -- The last node in the list has its next field set to NULL to mark the end of the list.
struct node { int rollno; struct node *next; }; int main() { struct node *head,*n1,*n2,*n3,*n4; /* creating a new node */ n1=(struct node *) malloc(sizeof(struct node)); n1->rollno=101; n1->next = NULL; /* referencing the first node to head pointer */ head = n1; /* creating a new node */ n2=(struct node *)malloc(sizeof(struct node)); n2->rollno=102; n2->next = NULL; /* linking the second node after first node */ n1->next = n2; /* creating a new node * / n3=(struct node *)malloc(sizeof(struct node)); n3->rollno=104; n3->next=NULL; /* linking the third node after second node */ n2->next = n3; /* creating a new node */ n4=(struct node *)malloc (sizeof (struct node)); n4->rollno=103; n4->next=NULL; /* inserting the new node between second node and third node */ n2->next = n4; n4->next = n3;
150
head
101 150
NULL
n1-node 102
NULL
150
101
720
150 n1-node
720 n2-node
102 910 104 NULL 910 n3-node 104 NULL 103 910 910 n3-node
150
101
720
150 n1-node
150
head
101
400
102
150 n1-node
400 n2-node
720 n4-node
150
head
101 150
720
103
Algorithm for adding two polynomials in linked lists Add_Polynomial( list p, list q ) set p, q to point to the two first nodes (no headers) initialize a linked list r for a zero polynomial while p != null and q != null if p.exp > q.exp create a node storing p.coeff and p.exp insert at the end of list r advance p else if q.exp > p.exp create a node storing q.coeff and q.exp insert at the end of list r advance q else if p.exp == q.exp if p.coeff + q.coeff != 0 create a node storing p.coeff + q.coeff and p.exp insert at the end of list r advance p, q end while if p != null copy the remaining terms of p to end of r else if q != null copy the remaining terms of q to end of r
head
tail
A
/* a node in doubly linked list */ struct node { struct node *prev; int data ; struct node *next; }
C
B A C D
A p A
B q B
C
p
D
101
400
102
720
103
910
910
tail
150 n1-node
400 n2-node
720 n3-node
-- Singly Linked List has a major drawback. From a specified node, it is not possible to reach any of the preceding nodes in the list. To overcome the drawback, a small change is made to the SLL so that the next field of the last node is pointing to the first node rather than NULL. Such a linked list is called a circular linked list. -- Because it is a circular linked list, it is possible to reach any node in the list from a particular node. -- There is no natural first node or last node because by virtue of the list is circular. -- Therefore, one convention is to let the external pointer of the circular linked list, tail, point to the last node and to allow the following node to be the first node. -- If the tail pointer refers to NULL, means the circular linked list is empty.
-- A Circular Doubly Linked List ( CDL ) is a doubly linked list with first node linked to last node and viceversa. -- The prev link of first node contains the address of last node and next link of last node contains the address of first node. -- Traversal through Circular Singly Linked List is possible only in one direction. -- The main advantage of Circular Doubly Linked List ( CDL ) is that, a node can be inserted into list without searching the complete list for finding the address of previous node. -- We can also traversed through CDL in both directions, from first node to last node and vice-versa.
Data structures are classified in several ways : Linear : Elements are arranged in sequential fashion. Ex : Array, Linear list, stack, queue Non-Linear : Elements are not arranged in sequence. Ex : trees, graphs Homogenous : All Elements are belongs to same data type. Ex : Arrays Non-Homogenous : Different types of Elements are grouped and form a data structure. Ex: classes Dynamic : Memory allocation of each element in the data structure is done before their usage using D.M.A functions Ex : Linked Lists Static : All elements of a data structure are created at the beginning of the program. They cannot be resized. Ex : Arrays
Stacks
-- Stack is an ordered collection of data elements into which new elements may be inserted and from which elements may be deleted at one end called the TOP of stack. -- A stack is a last-in-first-out ( LIFO ) structure. -- Insertion operation is referred as PUSH and deletion operation is referred as POP. -- The most accessible element in the stack is the element at the position TOP. -- Stack must be created as empty. -- Whenever an element is pushed into stack, it must be checked whether the stack is full or not. -- Whenever an element is popped form stack, it must be checked whether the stack is empty or not. -- We can implement the stack ADT either with array or linked list. Stack ADT struct stackNode { int data; struct stackNode *next; }; init_stack( ) push ( ) pop ( ) isEmpty ( ) display ( ) peek ( )
Applications of stack Reversing Data series Conversion decimal to binary Parsing into tokens Backtracking the operations Undo operations in Text Editor Page visited History in web browser Tracking of Function calls Maintaining scope and lifetime of local variables in functions Infix to postfix conversion Evaluating postfix expression
Pop( )
Pop( )
Pop( )
Pop( )
e c b b b d b d b d b b
Operations on Stack Operation 1. Init_stack( ) 2. Push( a ) 3. Push( b ) 4. Push( c ) 5. Pop( ) 6. Push( d ) 7. Push( e ) 8. Pop( ) 9. Pop( ) 10. Pop( ) 11. Pop( ) Stacks contents <empty> a ab abc ab abd abde abd ab a <empty>
TOP value
-1 0 1 2 1 2 3 2 1 0 -1
Output
Queues
-- Queue is a linear data structure that permits insertion of new element at one end and deletion of an element at the other end. -- The end at which insertion of a new element can take place is called rear and the end at which deletion of an element take place is called front . -- The first element that gets added into queue is the first one to get removed from the list, Hence Queue is also referred to as First-In-First-Out ( FIFO ) list. -- Queue must be created as empty. -- Whenever an element is inserted into queue, it must be checked whether the queue is full or not. -- Whenever an element is deleted form queue, it must be checked whether the queue is empty or not. -- We can implement the queue ADT either with array or linked list.
rear
front
3
addq (4)
5
delq ( )
7
Applications of Queues
Execution of Threads Job Scheduling Event queuing Message Queueing
Queue ADT struct queueNode { int data; struct queueNode *next; }; init_queue( ) addq ( ) delq ( ) isEmpty ( ) printQueue ( ) Types of Queues circular queues priority queues double-ended queues
--Arithmetic Expressions are represented using three notations infix, prefix and postfix. The prefixes pre, post, and in refer to position of operators with respect to two operands. -- In infix notation, the operator is placed between the two operands. Ex: A + B A*B+C (A * B) + (C * D) -- In Prefix notation, the operator is placed before the two operands. Ex: +AB *A+BC +*AB*CD -- In Postfix notation, the operator is placed after the two operands. Ex: AB+ ABC+* AB*CD*+
www.jntuworld.com
For More Materials, Text Books, Previous Papers & Mobile updates of B.TECH, B.PHARMACY, MBA, MCA of JNTU-HYD,JNTUKAKINADA & JNTU-ANANTAPUR visit www.jntuworld.com