Unit 2 linear data structures

Linear Data Structures
By,
Dr. N .Senthil Murugan
SCOPE, VIT-AP University

Data Structures are classified into two categories

What is the Linear data structure?
• Data structure whose element(objects) are sequential and ordered in a way so
that:
 There is only one first element and has only one next element,
 There is only one last element and has only one previous element, while
 All other elements have a next and a previous element

Linear data structures (examples)
• Arrays
• Strings
• Stack
• Queue
• Lists

Arrays
• Array: a sequence of indexed components with the following properties:
– array size is fixed at the time of array’s construction
• int [] numbers = new int [10];
– array elements are placed contiguously in memory
• address of any element can be calculated directly as its offset from
the beginning of the array
– consequently, array components can be efficiently inspected or updated
in O(1) time, using their indices
• randomNumber = numbers[5];
• numbers[2] = 100;

Arrays in Java (java.util.Arrays)
• For an array of length n, the index bounds are 0 to n-1.
• Java arrays are homogeneous
– all array components must be of the same (object or primitive) type.
– but, an array of an object type can contain objects of any respective subtype
• An array is itself an object.
– it is allocated dynamically by means of new
– it is automatically deallocated when no longer referred to
• When an array is first created, all values are automatically initialized with
– 0, for an array of int [] or double [] type
– false, for a boolean [] array
– null, for an array of objects
• Example [ common error –unallocated arrays]
int [] numbers;
numbers[2] = 100;
Primitive Data Type: In Java, the primitive data
types are the predefined data types of Java. They specify
the size and type of any standard values. Java has
8 primitive data types namely byte, short, int, long,
float, double, char and boolean.

• The length of any array object can be accessed through its instance variable ‘length’.
– the cells of an array A are numbered: 0, 1, .., A.length-1
• ArrayIndexOutOfBoundsException
– thrown at an attempt to index into array A using a number larger than A.length-1.
– helps Java avoid ‘buffer overflow attacks’
• Example [ declaring, defining and determining the size of an array]
int[] A={12, 24, 37, 53, 67};
for (int i=0; i < A.length; i++) {
…}

• Since an array is an object, the name of the array is actually a reference (pointer)
to the place in memory where the array is stored.
– reference to an object holds the address of the actual object
• Example [ copying array references]
int[] A={12, 24, 37, 53, 67};
int[] B=A;
B[3]=5;
• Example [ cloning an array]
int[] A={12, 24, 37, 53, 67};
int[] B=A.clone();
B[3]=5;

Example of 2D Array
Example [ 2D array in Java = array of arrays]
int[][] nums = new int[5][4];
int[][] nums;
nums = new int[5][];
for (int i=0; i<5; i++)
{
nums[i] = new int[4];
}

Useful Built-In Methods in Java.util.Arrays
– equals(A,B)
• returns true if A and B have an equal number of elements and every
corresponding pair of elements in the two arrays are equal
– fill(A,x)
• store element x into every cell of array A
– sort(A)
• sort the array A in the natural ordering of its elements
– binarySearch([int] A, int key)
• search the specified array of sorted ints for the specified value using the binary
search algorithm

Example
What is printed?
int[] A={12, 24, 37, 53, 67};
int[] B=A.clone();
if (A==B) System.out.println(“ Superman ”);
if (A.equals(B)) System.out.println(“ Snow White ”);

Limitations of Arrays
• Static data structure
– size must be fixed at the time the program creates the array
– once set, array size cannot be changed
– if number of entered items > declared array size ⟹ out of memory
• fix 1: use array size > number of expected items ⟹ waste of memory
• fix 2: increase array size to fit the number of items ⟹ extra time
• Insertion / deletion in an array is time consuming
– all the elements following the inserted element must be shifted appropriately
• Example [ time complexity of “growing” an array]
if (numberOfItems > numbers.length) {
int[] newNumbers = new int[2*numbers.length];
System.arraycopy(numbers, 0, newNumbers, 0, numbers.length);
numbers = newNumbers;
}

Linked List
• Before understanding the linked list concept, we first look at why there is a need for a linked list.
• If we want to store the value in a memory, we need a memory manager that manages the memory for
every variable. For example, if we want to create a variable of integer type like:
int x;
• In the above example, we have created a variable 'x' of type integer. As we know that integer variable
occupies 4 bytes, so 'x' variable will occupy 4 bytes to store the value.
• Suppose we want to create an array of integer type like:
int x[3];
• In the above example, we have declared an array of size 3. As we know, that all the values of an array
are stored in a continuous manner, so all the three values of an array are stored in a sequential fashion.
The total memory space occupied by the array would be 3*4 = 12 bytes.

• There are two major drawbacks of using array:
We cannot insert more than 3 elements in the above example because only 3 spaces are
allocated for 3 elements.
In the case of an array, lots of wastage of memory can occur. For example, if we declare an
array of 50 size but we insert only 10 elements in an array. So, in this case, the memory
space for other 40 elements will get wasted and cannot be used by another variable as this
whole space is occupied by an array.
• In array, we are providing the fixed-size at the compile-time, due to which wastage of memory
occurs. The solution to this problem is to use the linked list.

What is Linked List?
• A linked list is also a collection of elements, but the elements are not stored in a consecutive location.
• A linked list can also be defined as the collection of the nodes in which one node is connected to
another node, and node consists of two parts, i.e., one is the data part and the second one is the address
part, as shown in the below figure:
• In the above figure, we can observe that each node contains the data and the address of the next node.
The last node of the linked list contains the NULL value in the address part.

Advantages of using a Linked list over Array
The following are the advantages of using a linked list over an array:
•Dynamic data structure:
 The size of the linked list is not fixed as it can vary according to our requirements.
•Insertion and Deletion:
 Insertion and deletion in linked list are easier than array as the elements in an array are stored in a
consecutive location. In contrast, in the case of a linked list, the elements are stored in a random location.
The complexity for insertion and deletion of elements from the beginning is O(1) in the linked list, while in
the case of an array, the complexity would be O(n). If we want to insert or delete the element in an array,
then we need to shift the elements for creating the space. On the other hand, in the linked list, we do not
have to shift the elements. In the linked list, we just need to update the address of the pointer in the node.
•Memory efficient
 Its memory consumption is efficient as the size of the linked list can grow or shrink according to our
requirements.
•Implementation
 Both the stacks and queues can be implemented using a linked list.

Disadvantages of Linked list
The following are the disadvantages of linked list:
• Memory usage
The node in a linked list occupies more memory than array as each node occupies two types of
variables, i.e., one is a simple variable, and another is a pointer variable that occupies 4 bytes in
the memory.
• Traversal
In a linked list, the traversal is not easy. If we want to access the element in a linked list, we
cannot access the element randomly, but in the case of an array, we can randomly access the
element by index. For example, if we want to access the 3rd node, then we need to traverse all
the nodes before it. So, the time required to access a particular node is large.
• Reverse traversing
In a linked list, backtracking or reverse traversing is difficult. In a doubly linked list, it is easier
but requires more memory to store the back pointer.

Applications of Linked List
The applications of the linked list are given below:
 With the help of a linked list, the polynomials can be represented as well as we can perform the
operations on the polynomial. We know that polynomial is a collection of terms in which each term
contains coefficient and power. The coefficients and power of each term are stored as node and link
pointer points to the next element in a linked list, so linked list can be used to create, delete and
display the polynomial.
 A sparse matrix is used in scientific computation and numerical analysis. So, a linked list is used to
represent the sparse matrix.
• The various operations like student's details, employee's details or product details can be
implemented using the linked list as the linked list uses the structure data type that can hold different
data types.
• Stack, Queue, tree and various other data structures can be implemented using a linked list.

Types of Linked List
• The following are the types of linked list:
Singly Linked list
Doubly Linked list
Circular Linked list
Doubly Circular Linked list

Singly Linked list
• It is the commonly used linked list in programs. If we are talking about the linked list, it means it is a
singly linked list. The singly linked list is a data structure that contains two parts, i.e., one is the data
part, and the other one is the address part, which contains the address of the next or the successor
node. The address part in a node is also known as a pointer.
• Suppose we have three nodes, and the addresses of these three nodes are 100, 200 and 300
respectively. The representation of three nodes as a linked list is shown in the below figure:
• We can observe in the above figure that there are three different nodes having address 100, 200 and
300 respectively. The first node contains the address of the next node, i.e., 200, the second node
contains the address of the last node, i.e., 300, and the third node contains the NULL value in its
address part as it does not point to any node. The pointer that holds the address of the initial node is
known as a head pointer.
• The linked list, which is shown in the above diagram, is known as a singly linked list as it contains
only a single link. In this list, only forward traversal is possible; we cannot traverse in the backward
direction as it has only one link in the list.

Doubly linked list
• As the name suggests, the doubly linked list contains two pointers. We can define the doubly linked list
as a linear data structure with three parts: the data part and the other two address part. In other words, a
doubly linked list is a list that has three parts in a single node, includes one data part, a pointer to its
previous node, and a pointer to the next node.
• Suppose we have three nodes, and the address of these nodes are 100, 200 and 300, respectively. The
representation of these nodes in a doubly-linked list is shown below:
• As we can observe in the above figure, the node in a doubly-linked list has two address parts; one part
stores the address of the next while the other part of the node stores the previous node's address. The
initial node in the doubly linked list has the NULL value in the address part, which provides the address
of the previous node.

Circular linked list
• A circular linked list is a variation of a singly linked list. The only difference between the singly linked
list and a circular linked list is that the last node does not point to any node in a singly linked list, so its
link part contains a NULL value. On the other hand, the circular linked list is a list in which the last node
connects to the first node, so the link part of the last node holds the first node's address. The circular
linked list has no starting and ending node. We can traverse in any direction, i.e., either backward or
forward. The diagrammatic representation of the circular linked list is shown below:
• A circular linked list is a sequence of elements in which each node has a link to the next node, and the
last node is having a link to the first node. The representation of the circular linked list will be similar to
the singly linked list, as shown below:

Doubly Circular linked list
• The doubly circular linked list has the features of both the circular linked list and doubly linked
list.
• The above figure shows the representation of the doubly circular linked list in which the last node
is attached to the first node and thus creates a circle. It is a doubly linked list also because each
node holds the address of the previous node also. The main difference between the doubly linked
list and doubly circular linked list is that the doubly circular linked list does not contain the NULL
value in the previous field of the node. As the doubly circular linked contains three parts, i.e., two
address parts and one data part so its representation is similar to the doubly linked list.

What is a Stack?
• A Stack is a linear data structure that follows the LIFO (Last-In-First-Out) principle. Stack has
one end, whereas the Queue has two ends (front and rear). It contains only one pointer top
pointer pointing to the topmost element of the stack. Whenever an element is added in the stack, it
is added on the top of the stack, and the element can be deleted only from the stack. In other words,
a stack can be defined as a container in which insertion and deletion can be done from the one
end known as the top of the stack.
• Some key points related to stack
 It is called as stack because it behaves like a real-world stack, piles of books, etc.
 A Stack is an abstract data type with a pre-defined capacity, which means that it can store the
elements of a limited size.
 It is a data structure that follows some order to insert and delete the elements, and that order
can be LIFO or FILO.

Working of Stack
• Stack works on the LIFO pattern. As we can observe in the below figure there are five memory blocks in
the stack; therefore, the size of the stack is 5. Suppose we want to store the elements in a stack and let's
assume that stack is empty. We have taken the stack of size 5 as shown below in which we are pushing the
elements one by one until the stack becomes full.

• Since our stack is full as the size of the stack is 5. In the above cases, we can
observe that it goes from the top to the bottom when we were entering the new
element in the stack. The stack gets filled up from the bottom to the top.
• When we perform the delete operation on the stack, there is only one way for
entry and exit as the other end is closed. It follows the LIFO pattern, which means
that the value entered first will be removed last. In the above case, the value 5 is
entered first, so it will be removed only after the deletion of all the other elements.

Standard Stack Operations
The following are some common operations implemented on the stack:
• push(): When we insert an element in a stack then the operation is known as a push. If the stack is full
then the overflow condition occurs.
• pop(): When we delete an element from the stack, the operation is known as a pop. If the stack is empty
means that no element exists in the stack, this state is known as an underflow state.
• isEmpty(): It determines whether the stack is empty or not.
• isFull(): It determines whether the stack is full or not.
• peek(): It returns the element at the given position.
• count(): It returns the total number of elements available in a stack.
• change(): It changes the element at the given position.
• display(): It prints all the elements available in the stack.

PUSH operation
The steps involved in the PUSH operation is given below:
• Before inserting an element in a stack, we check whether the stack is full.
• If we try to insert the element in a stack, and the stack is full, then the overflow condition occurs.
• When we initialize a stack, we set the value of top as -1 to check that the stack is empty.
• When the new element is pushed in a stack, first, the value of the top gets incremented,
i.e., top=top+1, and the element will be placed at the new position of the top.
• The elements will be inserted until we reach the max size of the stack.

POP operation
The steps involved In the POP operation is given below:
• Before deleting the element from the stack, we check whether the stack is empty.
• If we try to delete the element from the empty stack, then the underflow condition occurs.
• If the stack is not empty, we first access the element which is pointed by the top
• Once the pop operation is performed, the top is decremented by 1, i.e., top=top-1.

Applications of Stack
• String reversal: Stack is also used for reversing a string. For example, we want to reverse a "javaTpoint" string, so we can achieve this
with the help of a stack. First, we push all the characters of the string in a stack until we reach the null character. After pushing all the
characters, we start taking out the character one by one until we reach the bottom of the stack.
• UNDO/REDO: It can also be used for performing UNDO/REDO operations. For example, we have an editor in which we write 'a', then
'b', and then 'c'; therefore, the text written in an editor is abc. So, there are three states, a, ab, and abc, which are stored in a stack. There
would be two stacks in which one stack shows UNDO state, and the other shows REDO state. If we want to perform UNDO operation,
and want to achieve 'ab' state, then we implement pop operation.
• Recursion: The recursion means that the function is calling itself again. To maintain the previous states, the compiler creates a system
stack in which all the previous records of the function are maintained.
• DFS(Depth First Search): This search is implemented on a Graph, and Graph uses the stack data structure.
• Backtracking: Suppose we have to create a path to solve a maze problem. If we are moving in a particular path, and we realize that we
come on the wrong way. In order to come at the beginning of the path to create a new path, we have to use the stack data structure.
• Expression conversion: Stack can also be used for expression conversion. This is one of the most important applications of stack. The
list of the expression conversion is given below:Infix to prefix Infix to postfix Prefix to infix Prefix to postfix Postfix to infix
• Memory management: The stack manages the memory. The memory is assigned in the contiguous memory blocks. The memory is
known as stack memory as all the variables are assigned in a function call stack memory. The memory size assigned to the program is
known to the compiler. When the function is created, all its variables are assigned in the stack memory. When the function completed its
execution, all the variables assigned in the stack are released.

Queue
1. A queue can be defined as an ordered list which enables insert operations to be performed at one end
called REAR and delete operations to be performed at another end called FRONT.
2. Queue is referred to be as First In First Out list.
3. For example, people waiting in line for a rail ticket form a queue.

Applications of Queue
• Due to the fact that queue performs actions on first in first out basis which is quite fair
for the ordering of actions. There are various applications of queues discussed as below.
• Queues are widely used as waiting lists for a single shared resource like printer, disk,
CPU.
• Queues are used in asynchronous transfer of data (where data is not being transferred at
the same rate between two processes) for eg. pipes, file IO, sockets.
• Queues are used as buffers in most of the applications like MP3 media player, CD
player, etc.
• Queue are used to maintain the play list in media players in order to add and remove the
songs from the play-list.
• Queues are used in operating systems for handling interrupts.

Operations on Queue
There are two fundamental operations performed on a Queue:
• Enqueue: The enqueue operation is used to insert the element at the rear end of the queue. It
returns void.
• Dequeue: The dequeue operation performs the deletion from the front-end of the queue. It also
returns the element which has been removed from the front-end. It returns an integer value. The
dequeue operation can also be designed to void.
• Peek: This is the third operation that returns the element, which is pointed by the front pointer in
the queue but does not delete it.
• Queue overflow (isfull): When the Queue is completely full, then it shows the overflow condition.
• Queue underflow (isempty): When the Queue is empty, i.e., no elements are in the Queue then it
throws the underflow condition.

Implementation of Queue
There are two ways of implementing the Queue:
• Sequential allocation: The sequential allocation in a Queue can be implemented
using an array.
• Linked list allocation: The linked list allocation in a Queue can be implemented using
a linked list.

Types of Queue
There are four types of Queues:
• Linear Queue
In Linear Queue, an insertion takes place from one end while the deletion occurs from another
end. The end at which the insertion takes place is known as the rear end, and the end at which
the deletion takes place is known as front end. It strictly follows the FIFO rule. The linear
Queue can be represented, as shown in the below figure:
The above figure shows that the elements are inserted from the rear end, and if we insert more
elements in a Queue, then the rear value gets incremented on every insertion. If we want to
show the deletion, then it can be represented as:

In the above figure, we can observe that the front pointer points to the next element, and the
element which was previously pointed by the front pointer was deleted.
The major drawback of using a linear Queue is that insertion is done only from the rear end. If
the first three elements are deleted from the Queue, we cannot insert more elements even
though the space is available in a Linear Queue. In this case, the linear Queue shows
the overflow condition as the rear is pointing to the last element of the Queue.

Circular Queue
• In Circular Queue, all the nodes are represented as circular. It is similar to the linear Queue except
that the last element of the queue is connected to the first element. It is also known as Ring
Buffer as all the ends are connected to another end. The circular queue can be represented as:
• The drawback that occurs in a linear queue is overcome by using the circular queue. If the
empty space is available in a circular queue, the new element can be added in an empty
space by simply incrementing the value of rear.

Priority Queue
• A priority queue is another special type of Queue data structure in which each element has some
priority associated with it. Based on the priority of the element, the elements are arranged in a
priority queue. If the elements occur with the same priority, then they are served according to the
FIFO principle.
• In priority Queue, the insertion takes place based on the arrival while the deletion occurs based on
the priority. The priority Queue can be shown as:
• The previous figure shows that the highest priority element comes first and the elements of the
same priority are arranged based on FIFO structure.
Deque
• Both the Linear Queue and Deque are different as the linear queue follows the FIFO principle
whereas, deque does not follow the FIFO principle. In Deque, the insertion and deletion can
occur from both ends

Unit 2 linear data structures

Unit 2 linear data structures

More Related Content

What's hot (20)

Similar to Unit 2 linear data structures (20)

Recently uploaded (20)

Unit 2 linear data structures