Data Structures Tutorial

Data Structures Tutorial Asymptotic Notation Structure and Union Array Data Structure Linked list Data Structure Type of Linked list Advantages and Disadvantages of linked list Queue Data Structure Implementation of Queue Stack Data Structure Implementation of Stack Sorting Insertion sort Quick sort Selection sort Heap sort Merge sort Bucket sort Count sort Radix sort Shell sort Tree Traversal of the binary tree Binary search tree Graph Spanning tree Linear Search Binary Search Hashing Collision Resolution Techniques

Misc Topic:

Priority Queue in Data Structure Deque in Data Structure Difference Between Linear And Non Linear Data Structures Queue Operations In Data Structure About Data Structures Data Structures Algorithms Types of Data Structures Big O Notations Introduction to Arrays Introduction to 1D-Arrays Operations on 1D-Arrays Introduction to 2D-Arrays Operations on 2D-Arrays Strings in Data Structures String Operations Application of 2D array Bubble Sort Insertion Sort Sorting Algorithms What is DFS Algorithm What Is Graph Data Structure What is the difference between Tree and Graph What is the difference between DFS and BFS Bucket Sort Dijkstra’s vs Bellman-Ford Algorithm Linear Queue Data Structure in C Stack Using Array Stack Using Linked List Recursion in Fibonacci Stack vs Array What is Skewed Binary Tree Primitive Data Structure in C Dynamic memory allocation of structure in C Application of Stack in Data Structures Binary Tree in Data Structures Heap Data Structure Recursion - Factorial and Fibonacci What is B tree what is B+ tree Huffman tree in Data Structures Insertion Sort vs Bubble Sort Adding one to the number represented an array of digits Bitwise Operators and their Important Tricks Blowfish algorithm Bubble Sort vs Selection Sort Hashing and its Applications Heap Sort vs Merge Sort Insertion Sort vs Selection Sort Merge Conflicts and ways to handle them Difference between Stack and Queue AVL tree in data structure c++ Bubble sort algorithm using Javascript Buffer overflow attack with examples Find out the area between two concentric circles Lowest common ancestor in a binary search tree Number of visible boxes putting one inside another Program to calculate the area of the circumcircle of an equilateral triangle Red-black Tree in Data Structures Strictly binary tree in Data Structures 2-3 Trees and Basic Operations on them Asynchronous advantage actor-critic (A3C) Algorithm Bubble Sort vs Heap Sort Digital Search Tree in Data Structures Minimum Spanning Tree Permutation Sort or Bogo Sort Quick Sort vs Merge Sort Boruvkas algorithm Bubble Sort vs Quick Sort Common Operations on various Data Structures Detect and Remove Loop in a Linked List How to Start Learning DSA Print kth least significant bit number Why is Binary Heap Preferred over BST for Priority Queue Bin Packing Problem Binary Tree Inorder Traversal Burning binary tree Equal Sum What is a Threaded Binary Tree? What is a full Binary Tree? Bubble Sort vs Merge Sort B+ Tree Program in Q language Deletion Operation from A B Tree Deletion Operation of the binary search tree in C++ language Does Overloading Work with Inheritance Balanced Binary Tree Binary tree deletion Binary tree insertion Cocktail Sort Comb Sort FIFO approach Operations of B Tree in C++ Language Recaman’s Sequence Tim Sort Understanding Data Processing Applications of trees in data structures Binary Tree Implementation Using Arrays Convert a Binary Tree into a Binary Search Tree Create a binary search tree Horizontal and Vertical Scaling Invert binary tree LCA of binary tree Linked List Representation of Binary Tree Optimal binary search tree in DSA Serialize and Deserialize a Binary Tree Tree terminology in Data structures Vertical Order Traversal of Binary Tree What is a Height-Balanced Tree in Data Structure Convert binary tree to a doubly linked list Fundamental of Algorithms Introduction and Implementation of Bloom Filter Optimal binary search tree using dynamic programming Right side view of binary tree Symmetric binary tree Trim a binary search tree What is a Sparse Matrix in Data Structure What is a Tree in Terms of a Graph What is the Use of Segment Trees in Data Structure What Should We Learn First Trees or Graphs in Data Structures All About Minimum Cost Spanning Trees in Data Structure Convert Binary Tree into a Threaded Binary Tree Difference between Structured and Object-Oriented Analysis FLEX (Fast Lexical Analyzer Generator) Object-Oriented Analysis and Design Sum of Nodes in a Binary Tree What are the types of Trees in Data Structure What is a 2-3 Tree in Data Structure What is a Spanning Tree in Data Structure What is an AVL Tree in Data Structure Given a Binary Tree, Check if it's balanced

FIFO approach

FIFO is first in first out approach.

It is done for the list of elements in data structures where first element will be deleted after another element ia added to it

Here, we treat the information components with a fair opportunity; the component which has entered first will get the chance to leave first.

 The other name we call First Come First Serve is executed utilizing the information structure named a line.

The best guide to comprehend the FIFO rule is the point at which we stand in a line and need to take a film ticket, and there are a many individuals remaining before us, and we have no other decision left as opposed to hanging tight for our opportunity.

In the event that we notice the above model, we can undoubtedly see that we will find the opportunity after individuals remaining before us and will be treated as the early bird gets the worm.

The FIFO standard has extraordinary significance in the different cycles booking calculation, which the working framework does to settle the timetable of a few cycles in a steady progression.

One of the calculations that CPU utilizes is FCFS, the early bird gets the worm to allow a fair opportunity to each cycle, and it is executed by utilizing the line information structure.

In one of the crude calculations of booking, we will utilize the cooperative calculation, and the roundabout line has its extraordinary significance; by utilizing the roundabout line, we will actually want to seize the cycle and allow a fair opportunity to each interaction utilizing a round line.

This calculation is utilized by cycle and organization schedulers in processing.

It is likewise utilized in PC controlled Traffic Signal Systems.

It is additionally utilized in CPU planning and memory the executives

The information structure, in view of the FIFO rule, is the line.

In the line information structure, we will play out the two fundamental tasks: first, Enqueue activity for embedding the information components into the line, and one more is Dequeue activity for eliminating the information components from the line.

In stack, we will chiefly utilize two tasks drive for driving the information components into the stack, and another is pop for eliminating the components from the stack.

The line contains two finishes, i.e., the front, and another is the back

Many projects depend on the idea of the FIFO rule.

A line is one of the significant direct information structures widely utilized in different PC applications, and furthermore it depends on the FIFO ( First In First Out ) standard.

 It follows a specific request of information execution for which tasks are performed. In this information structure, information enters from one end, i.e., the REAR end, and the following information enters the line after the past one.

Erasure activity is performed from another end, i.e., FRONT

As contrasted and stacks, stacks are likewise a direct information structure.

 In spite of the fact that, it depends on LIFO (Last In First Out) rule, which suggests that information enters individually from one end into the stack till it arrives at its end breaking point, and it jumped out the information component from the stack from that end itself.

In a stack, just a single pointer is required for playing out all tasks, which is top, while, in the line, there are two pointers required, back and front, for playing out all activities.

The methodology, as referenced prior, is known as the First-In-First-Out approach or FIFO.

Application of FIFO approach:

The line is a straight information structure in light of the FIFO approach, in which information components go into the line utilizing the backside, and from the front end, cancellation of components happens.

FIFO approach is for the most part utilized in network scaffolds, switches, and switches.

It is additionally sorted as straight line

1. Linear Queue:

A straight line is a direct information structure in light of FIFO (First in First Out) rule, in which information enters from the backside and is erased from the front end.

A direct line is supposed to be the basic line, and at whatever point we want to discuss the line, it is of course set that we are thinking about a straight line.

 We will talk about these finishes in more detail further.

Different models like:

Individuals are hanging tight for the transport.

The main individual remaining in the line will be quick to get on the transport.

Vehicles lined at a cost span. The main vehicle to arrive at the scaffold will be quick to leave.

Operations of Linear Queue:

There are sure essential activities has acted in the straight line are as per the following >

Enqueue

For the expansion of information components in the line, this activity is utilized.

By applying this activity, information is placed in the line as per the grouping after each other. Enqueue will be gone on till the line arrives at its end limit.

After it arrives at the endpoint, the information can't add to the line, and afterward such condition is supposed to be an Overflow condition.

En-line activity is finished from the backside.

Dequeue

This activity is utilized to erase an information component from the line.

Utilizing Dequeue activity, that information component is erased, which is enqueued first in the line, or the components are popped in similar request in which they are pushed.

This cycle will erase the information components from the line until the entire line becomes unfilled.

When every one of the components are erased, then the erasure activity can't execute, and afterward such condition is supposed to be an Underflow condition.

It is finished from the front end.

Peek

This activity is utilized to figure out the absolute first line component, which is to be served first without dequeuing it.

Two ends of linear queue:

Front end - It alludes to the underlying or beginning place of the line. The front end is primarily used to erase the information component from the line or play out a dequeue activity.

Rear end - alludes to the last or back position of the line. The backside is predominantly used to embed the line information components or play out the en-line activity.

Methods of implementation linear queue:

1.  using array

2. using stack

3. using linked list

Implementation of linear queue:

At first, we really want to make a variety of size 'n' whether statically or powerfully, contingent upon the client.

Announce two pointers named FRONT and REAR.

Introduce REAR = - 1 and FRONT = 0.

Make three capabilities named Enqueue for adding information components in the Queue,

Dequeue for cancellation of an information component from the line, and look for figuring out the principal component from the line without dequeuing it.

//C program code

#include<stdio.h>  
#include<stdlib.h>  
#define MAX 10               
int queue [ MAX ] ;            //Declaration of Array  
int front = -1 , rear = -1 ;  
void enqueue () ;  
int dequeue () ;  
int peek () ;  
void display () ;  
  
void main()  
{  
    int choice , data ;  
    while ( 1 )  
    {  
        printf ( " \n \n ***************** Main ******************** \n " ) ;  
        printf ( " 1. Inserting the element \n " ) ;  
        printf ( " 2. Deleting the element \n " ) ;  
        printf ( " 3. Peek value in the queue \n " ) ;  
        printf ( " 4. Display the Queue \n " ) ;  
        printf ( " 5. Exit from queue \n " ) ;  
        printf ( " Enter your choice of operation : " ) ;  
        scanf ( "%d" , &choice ) ;  
          
        switch ( choice )  
        {  
            case 1 :  
                enqueue () ;  
                break ;  
            case 2 :  
                data = dequeue () ;  
                if ( data != -1 )  
                printf ( " \n The data element popped out from queue is -> %d " , data ) ;  
                break ;  
            case 3 :  
                data = peek () ;  
                if ( data != -1 )  
                printf ( " \n The first value in queue is -> %d " , data ) ;  
                break ;  
            case 4 :  
                display () ;  
                break ;  
            case 5 :  
                exit ( 0 ) ;  
                break ;  
            default :  
                printf ( " \n Choice not available \n " ) ;       
        }     
    }  
}  
void enqueue ()  
{  
    int val ;  
    printf ( " Enter data to insert in queue -> " ) ;  
    scanf ( "%d" , &val ) ;  
    if ( rear == MAX - 1 )  
    {  
        printf ( " Overflow Condition " ) ;  
    }  
    else   
    {  
    if ( front == -1 )  
    {  
        front = 0 ;  
    }  
        rear = rear + 1 ;  
        queue [ rear ] = val ;  
          
    }  
}  
int dequeue ()  
{  
    int val ;  
    if ( front == -1 || rear < front )  
    {  
        printf ( " \n Underflow condition " ) ;  
        return -1 ;  
    }  
    else  
    {  
        val = queue [ front ] ;  
        front = front + 1 ;  
        if ( front > rear )  
        {  
            front = rear = -1 ;  
        }  
        return val ;  
    }  
}  
int peek ()  
{  
    if ( front == -1 || rear < front )  
    {  
        printf ( " \n Queue is empty " ) ;  
        return -1 ;  
    }  
    else  
    {  
        return queue [ front ] ;  
    }     
}  
void display()  
{  
    int i ;  
    printf ( " \n " ) ;  
    if ( front == -1 || front > rear )  
    {  
    printf ( " \n Queue is empty " ) ;  
    }  
    else  
    {  
        for ( i = front ; i <= rear ; i++ )  
        {  
            printf ( " %d \n " , queue [ i ] ) ;  
        }  
    }  
}  

Output:

FIFO approach



ADVERTISEMENT
ADVERTISEMENT