Data Structure using C by Dr. K Adisesha .ppsx

Data Structures using C
Prof. Dr. K ADISESHA

Please bring to class
each day
Introduction
Types of Data structures
Arrays
Stacks and Queues
Linked lists
2
Data Structures
Trees

Introduction
Prof. Dr. K. Adisesha
3
Data Structures:
Data
 Data is a collection of facts, numbers, letters or symbols that the computer process into
meaningful information.
Data structure
 Data structure is representation of the logical relationship existing between individual
elements of data.
 Data structure is a specialized format for organizing and storing data in memory that
considers not only the elements stored but also their relationship to each other.

Introduction
4
Why to Learn Data Structure:
As applications are getting complex and data rich, there are three common problems
that applications face now-a-days
 Data Search − Consider an inventory of 1 million(106) items of a store. If the
application is to search an item, it has to search an item in 1 million(106) items every
time slowing down the search. As data grows, search will become slower.
 Processor speed − Processor speed although being very high, falls limited if the data
grows to billion records.
 Multiple requests − As thousands of users can search data simultaneously on a web
server, even the fast server fails while searching the data..

Introduction
5
Data Structures:
Data structures are essential components that help organize and store data efficiently
in computer memory.
 They provide a way to manage and manipulate data effectively, enabling faster access,
insertion, and deletion operations.

Introduction
6
Data Type:
Data type is a way to classify various types of data which determines the values that can
be used with the corresponding type of data, the type of operations that can be
performed on the corresponding type of data.
There are two data types:
 Built-in Data Type: Those data types for which a language has built-in support are
known as Built-in Data type.
 Derived Data Type: Those data types which are implementation independent as they
can be implemented in one or the other way are known as derived data types.

Data Structures
7
Classification of Data Structure using C:
Data structure are normally divided into two broad categories:
 Primitive Data Structure
 Non-Primitive Data Structure
 Linear Data Structure
 Non-Linear Data Structure

Data Structures
Prof. K. Adisesha
8
Differences between Data Structure:
The most commonly used differences between on data structure are broadly categorized
into following types:
 A primitive data structure is generally a basic structure that is usually built into the
language, such as an integer, a float.
 A non-primitive data structure is built out of primitive data structures linked together
in meaningful ways, such as a or a linked-list, binary search tree, AVL Tree, graph etc.

Data Structures
9
Primitive Data Structure:
Data structures that are directly operated upon the machine-level instructions are
known as primitive data structures:
 There are basic structures and directly operated upon by the machine instructions.
 The Data structures that fall in this category are.
 Integer
 Floating-point number
 Character constants
 string constants
 pointers etc.,

Data Structures
10
Primitive Data Structure:
Data structures that are directly operated upon the machine-level instructions are
known as primitive data structures:
 The most commonly used operation on data structure are broadly categorized into
following types:
 Create
 Insertion
 Selection
 Updating
 Destroy or Delete

Data Structures
11
Non-Primitive Data Structure:
The Data structures that are derived from the primitive data structures are called Non-
primitive data structure:
 There are more sophisticated data structures
 The non-primitive data structures emphasize on structuring of a group of homogeneous
(same type) or heterogeneous (different type) data items:
 Linear Data structures
 Non-Linear Data structures

Data Structures
12
Linear Data structures
Linear Data structures are kind of data structure that has homogeneous elements.
 The data structure in which elements are in a sequence and form a liner series.
 Linear data structures are very easy to implement, since the memory of the computer is
also organized in a linear fashion.
 Some commonly used linear data structures are:
 Stack
 Queue
 Linked Lists

Data Structures
13
Non-Linear Data structures
A Non-Linear Data structures is a data structure in which data item is connected to
several other data items.
 Non-Linear data structure may exhibit either a hierarchical relationship or parent child
relationship.
 The data elements are not arranged in a sequential structure.
 Some commonly used non-linear data structures are:
 Trees
 Graphs

Data Structures
14
The most commonly used operation on data structure are broadly categorized into
following types:
 Traversal
 Insertion
 Selection
 Searching
 Sorting
 Merging
 Destroy or Delete

Memory Allocation
15
Memory Allocation in C:
Memory allocation is a process by which computer programs and services are assigned
with physical or virtual memory space.
 The Memory is divided into three sections.
 Heap Memory: It is a part of the main memory. It is unorganized and
treated as a resource when you require the use of it if not release.
 Stack Memory: It stores temporary variables created by a function. In
stack, variables are declared, stored, and initialized during runtime.
 Code Section: Whenever the program is executed it will be brought
into the main memory. This program will get stored under the code
section.

Memory Allocation
16
Memory Allocation in C:
Memory allocation is a process by which computer programs and services are assigned
with physical or virtual memory space.
 The memory allocation is done either before or at the time of program execution.
 There are two types of memory allocations:
 Compile-time or Static Memory Allocation: Memory is allocated for declared
variables by the compiler.
 Run-time or Dynamic Memory Allocation: Memory allocation done at the time of
execution(run time) is known as dynamic memory allocation.

Memory Allocation
17
Static Memory Allocation in C:
In static memory allocation the program executes fixes the size that the program is
going to take, and it can’t be changed further. So, the exact memory requirements must
be known before.
 Allocation and deallocation of memory will be done by the compiler automatically.
 Key Features:
 Allocation and deallocation are done by the compiler.
 It uses a data structures stack for static memory allocation.
 Variables get allocated permanently.
 Execution is faster than dynamic memory allocation.
 Memory is allocated before runtime.

Memory Allocation
18
Dynamic Memory Allocation in C:
In Dynamic memory allocation size initialization and allocation are done by the
programmer. It is managed and served with pointers that point to the newly allocated
memory space in an area which we call the heap.
 Heap memory is unorganized and it is treated as a resource when you require the use of
it if not release it.
 Key Features:
 Dynamic allocated at runtime
 We can also reallocate memory size if needed.
 Dynamic Allocation is done at run time.
 No memory wastage

Memory Allocation
19
Dynamic Memory Allocation in C:
There are some functions available in the stdlib.h header which will help to allocate
memory dynamically.
 malloc(): function allocates memory at runtime is called malloc() function returns a
pointer with the value NULL. Syntax: int *p = (int*)malloc(No of values*size(int));
 calloc(): function initializes the memory that is allocated so that all bytes are zero.
Syntax: int *p = (int*)calloc(Number of data items, sizeof(int));
 realloc(): The realloc() function enables you to reuse or extend the memory that you
previously allocated using malloc() or calloc().
Syntax: int *np = (type cast) realloc (pointer type, number of elements * sizeof(int));
 free(): When memory is allocated dynamically it should always be released when it is
no longer required. Syntax: free(pointer);

Data Structures
20
Algorithms and Applications of Data Structures:
Algorithm is a step-by-step procedure, which defines a set of instructions to be executed
in a certain order to get the desired output. Algorithms are generally created
independent of underlying languages.
 From the data structure point of view, following are some important categories of
algorithms.
 Insert − Algorithm to insert item in a data structure.
 Traverse − Algorithm to visit every item in a data structure.
 Update − Algorithm to update an existing item in a data structure.
 Search − Algorithm to search an item in a data structure.
 Sort − Algorithm to sort items in a certain order.
 Delete − Algorithm to delete an existing item from a data structure.

Algorithm
21
Characteristics of an Algorithm:
An algorithm should have the following characteristics −.
 Unambiguous − Algorithm should be clear and unambiguous. Each of its steps (or
phases), and their inputs/outputs should be clear and must lead to only one meaning.
 Input − An algorithm should have 0 or more well-defined inputs.
 Output − An algorithm should have 1 or more well-defined outputs, and should match
the desired output.
 Finiteness − Algorithms must terminate after a finite number of steps.
 Feasibility − Should be feasible with the available resources.
 Independent − An algorithm should have step-by-step directions, which should be
independent of any programming code.

Algorithm
22
Characteristics of a Data Structure:
Data Structure is a systematic way to organize data in order to use it efficiently.
Following terms are the Characteristics of a data structure.
 Correctness − Data structure implementation should implement its interface correctly.
 Time Complexity − Running time or the execution time of operations of data structure
must be as small as possible.
 Space Complexity − Memory usage of a data structure operation should be as little as
possible.

Algorithm
23
Algorithm Analysis:
Efficiency of an algorithm can be analyzed at two different stages, before implementation
and after implementation. They are the following .
 A Priori Analysis − This is a theoretical analysis of an algorithm. Efficiency of an
algorithm is measured by assuming factors, like processor speed, are constant and have
no effect on the implementation.
 A Posterior Analysis − This is an empirical analysis of an algorithm. The selected
algorithm is implemented using programming language. In this analysis, actual statistics
like running time and space required, are collected.

Algorithm
24
Algorithm Complexity:
The complexity of an algorithm represents the amount of memory space and time
required by the algorithm in its life cycle.
 Space complexity − Space complexity of an algorithm represents the amount of memory
space required by the algorithm in its life cycle..
 Time complexity − Time complexity of an algorithm represents the amount of time
required by the algorithm to run to completion.

Algorithm
 Calculate
 Lines 1 and 4 count for one unit each
 Line 3: executed N times, each time four units
 Line 2: (1 for initialization, N+1 for all the tests, N for all the increments) total 2N + 2
 total cost: 6N + 4  O(N)


N
i
i
1
3 1
2
3
4
1
2N+2
4N
1

Algorithm
26
Asymptotic Analysis of an algorithm:
Asymptotic analysis of an algorithm refers to Asymptotic analysis refers to computing the
running time of any operation in mathematical units of computation of its run-time
performance.
 The Asymptotic analysis of an algorithm falls under three types:
 Best Case − Minimum time required for program execution.
 Average Case − Average time required for program execution.
 Worst Case − Maximum time required for program execution.

Algorithm
27
Asymptotic Notations of an algorithm:
Following are the commonly used asymptotic notations to calculate the running time
complexity of an algorithm..
 The Asymptotic Notations of an algorithm falls under three types:
 Big Oh Notation, Ο− It measures the worst case time complexity.
 Omega Notation, Ω− It measures the best case time complexity.
 Theta Notation, θ− It measures the Average case time complexity.

Algorithm
28
Big Oh Notation, ( Ο )of an algorithm:
The notation Ο(n) is the formal way to express the upper bound of an algorithm's
running time.
 It measures the worst case time complexity or the longest amount of time an algorithm
can possibly take to complete.
 For example, for a function f(n)
 It is represented as follows
 Ο(f(n)) = { g(n) : there exists c > 0 and n0 such that f(n) ≤ c.g(n) for all n > n0. }

Algorithm
29
Omega Notation, Ω of an algorithm:
The notation Ω(n) is the formal way to express the lower bound of an algorithm's
running time. It measures the best case time complexity or the best amount of time an
algorithm can possibly take to complete
• For example, for a function f(n)
• It is represented as follows
• Ω(f(n)) ≥ { g(n) : there exists c > 0 and n0 such that g(n) ≤ c.f(n) for all n > n0. }

Algorithm
30
Theta Notation, θ of an algorithm:
The notation θ(n) is the formal way to express both the lower bound and the upper
bound of an algorithm's running time.
 For example, for a function f(n)
 It is represented as follows
 θ(f(n)) = { g(n) if and only if g(n) = Ο(f(n)) and g(n) = Ω(f(n)) for all n > n0. }

Algorithm
31
Common Asymptotic Notations:
Following is a list of some common asymptotic notations.
 constant − Ο(1)
 logarithmic− Ο(log n)
 linear − Ο(n)
 n log n − Ο(n log n)
 quadratic − Ο(n2)
 cubic − Ο(n3)
 polynomial − nΟ(1)
 exponential− 2Ο(n)

Recursion
32
Recursion:
Recursion is the process of repeating items in a self-similar way. In programming
languages, if a program allows you to call a function inside the same function, then it
is called a recursive call of the function.
 while using recursion, programmers need to be careful to define an exit condition from
the function, otherwise it will go into an infinite loop.
 Recursive functions are very useful to solve many
mathematical problems, such as calculating the
factorial of a number, generating Fibonacci series,
etc.

Recursion
33
Recursion:
Recursion is the process in which a function calls itself up to n-number of times. If a
program allows the user to call a function inside the same function recursively, the
procedure is called a recursive call of the function.
 Types of Recursion in C:
 Direct Recursion
 Indirect Recursion
 Tail Recursion
 No Tail/ Head Recursion
 Linear recursion
 Tree Recursion

Recursion
34
Types of the recursion:
Following are the types of the recursion in C programming language, as follows:
 Direct Recursion: When a function calls itself within the same function repeatedly, it
is called the direct recursion.
 Indirect Recursion: When a function is mutually called by another function in a
circular manner, the function is called an indirect recursion function.
Direct Recursion:
fun()
{
// write some code
fun();
// some code
}
Indirect Recursion:
fun1()
{
// write some code
fun2();
}
fun2()
{
// write some code
fun1();
// write some code
}

Recursion
35
Types of the recursion:
Following are the types of the recursion in C programming language, as follows:
 Tail Recursion: A recursive function is called the tail-recursive if the function makes
recursive calling itself, and that recursive call is the last statement executes by the
function. After that, there is no function or statement is left to call the recursive function.
 Head Recursion: A function is called the non-tail or head recursive if a function makes a
recursive call itself, the recursive call will be the first statement in the function.
 Linear recursion: A function is called the linear recursive if the function makes a single
call to itself at each time the function runs and grows linearly in proportion to the size of
the problem.
 Tree Recursion: A function is called the tree recursion, in which the function makes more
than one call to itself within the recursive function.

Recursion
36
Recursion:
The C programming language supports recursion, i.e., a function to call itself.
 The following example calculates the factorial of a given number using a recursive
function −
#include <stdio.h>
int factorial(int i) {
if(i <= 1) {
return 1;
}
return i * factorial(i - 1);
}
int main() {
int i = 12;
printf("Factorial of %d is %dn", i,
factorial(i));
return 0;
}

Recursion
37
Drawbacks of Recursion in Data Structure:
There are some potential drawbacks to using recursion in data structures, including:
 Memory usage: Recursive algorithms can use a lot of memory, particularly if the recursion
goes too deep or if the data structure is large. Each recursive call creates a new stack frame on
the call stack, which can quickly add up to a significant amount of memory usage.
 Stack overflow: If the recursion goes too deep, it can cause a stack overflow error, which can
crash the program.
 Performance: Recursive algorithms can be less efficient than iterative algorithms in some
cases, particularly if the data structure is large or if the recursion goes too deep.
 Debugging: Recursive algorithms can be more difficult to debug than iterative algorithms,
particularly if the recursion goes too deep or if the program is using multiple recursive calls.
 Code complexity: Recursive algorithms can be more complex than iterative algorithm.

Recursion
38
Difference between Recursion and Iteration:
Basis Recursion Iteration
Basis of
repetition
Recursion is based on the idea of a function
calling itself. The base case is the simplest
version of the problem that can be solved
without recursion.
Iteration, on the other hand, uses looping
constructs such as "for" and "while" to repeat
a process a certain number of times or until a
specific condition is met.
Control flow
Recursion relies on the call stack to keep track
of function calls and their parameters. Each
recursive call pushes a new function call onto
the call stack, and each return pops the function
call off the stack.
Iteration, on the other hand, does not rely on
the call stack and uses variables and control
structures to control the flow of execution.
Performance
Recursion can be more elegant and easier to
understand for certain types of problems
Iteration is often more efficient than recursion,
especially for large datasets or complex
algorithms.

Unit -2 Arrays
39
Arrays:
An array is defined as a set of finite number of homogeneous elements or same data
items:
 Following are the important terms to understand the concept of Array.
 Element − Each item stored in an array is called an element.
 Index − Each location of an element in an array has a numerical index, which is
used to identify the element.
 Declaration of array is as follows:
 Syntax: Datatype Array_Name [Size];
 Example: int arr[10];
 Where int specifies the data type or type of elements arrays stores.
 “arr” is the name of array & the number specified inside the square brackets is the number of
elements an array can store, this is also called sized or length of array.

Arrays
40
Arrays:
Represent a Linear Array in memory:
 The elements of linear array are stored in consecutive memory locations.
 It is shown below:
int A[5]={23, 4, 6, 15, 5, 7}

Arrays
41
Calculating the length of the array:
The elements of array will always be stored in the consecutive (continues) memory
location.
 The number of elements that can be stored in an array, that is the size of array or its length is
given by the following equation:
o A[n] is the array size or length of n elements.
o The length of the array can be calculated by:
L = UB – LB + 1
o To Calculate the address of any element in array:
Loc(A[P])=Base(A)+W(P-LB)
o Here, UB is the largest Index and LB is the smallest index
 Example: If an array A has values 10, 20, 30, 40, 50, stored in location 0,1, 2, 3, 4 the UB = 4
and LB=0 Size of the array L = 4 – 0 + 1 = 5

Arrays
42
Types of Arrays:
The elements of array will always be stored in the consecutive (continues) memory
location. The various types of Arrays are:
 Single Dimension Array:
 Array with one subscript
 Ex: int A[i];
 Two Dimension Array
 Array with two subscripts (Rows and Column)
 Ex: int A[i][j];
 Multi Dimension Array:
 Array with Multiple subscripts
 Ex: int A[i][j]..[n];

Arrays
43
Abstract Data Type:
ADTs or abstract data types are the ways of classifying data structures by providing a
minimal expected interface and some set of methods.
 Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a
set of values and a set of operations.
 Abstract data types (ADTs) are a way of encapsulating data and operations on that data
into a single unit.
 Array as ADT (Abstract Data Type) mean data structure array and the set of operations:
 Representation of Data.
 Set of Operations on the Data.

Arrays
44
Basic operations of Arrays:
Some common operation performed on array are:
 Traversing
 Insertion
 Deletion
 Searching
 Sorting
 Merging

Arrays
45
Traversing Arrays:
Traversing: It is used to access each data item exactly once so that it can be processed:
 We have linear array A as below:
1 2 3 4 5
10 20 30 40 50
 Here we will start from beginning and will go till last element and during this process
we will access value of each element exactly once as below:
A [0] = 10
A [1] = 20
A [2] = 30
A [3] = 40
A [4] = 50

Arrays
46
Traverse Operation:
Following program traverses and prints the elements of an array:

Arrays
47
Insertion into Array:
Insertion: It is used to add a new data item in the given collection of data items:
 We have linear array A as below:
1 2 3 4 5
10 20 50 30 15
 New element to be inserted is 100 and location for insertion is 3.
 So shift the elements from 5th location to 3rd location downwards by 1 place.
 And then insert 100 at 3rd location

Arrays
48
 Insertion 100 into Array
at Pos=3
A [0] = 10
A [1] = 20
A [2] = 50
A [3] = 30
A [4] = 15

Arrays
49
Insertion into Array: Add a new data item in the given array of data:
A [0] = 1
A [1] = 3
A [2] = 5
A [3] = 7
A [4] = 8

Arrays
50
Deletion from Array:
Deletion: It is used to delete an existing data item from the given collection of data
items:
 Deletion 30 from Array
at Pos 3
A [0] = 10
A [1] = 20
A [2] = 30
A [3] = 40
A [4] = 50

Arrays
51
Deletion from Array:
A [0] = 1
A [1] = 3
A [2] = 5
A [3] = 7
A [4] = 8

Arrays Searching
52
Searching in Arrays:
Searching: It is used to find out the location of the data item if it exists in the given
collection of data items:
 E.g. We have linear array A as below:
1 2 3 4 5
10 20 50 30 35
 Suppose item to be searched is 35. We will start from beginning and will compare 35
with each element.
 This process will continue until element is found or array is finished.
 Types of searching Algorithms:
 Linear searching
 Binary Searching

Arrays Searching
53
Linear search:
Linear Searching: Also called Sequential Searching.
 It is used to find out the location of the data item if it exists in the given collection of
data items.
 Example Searching element 33 from the array of elements:

Arrays Searching
54
Linear search:
Linear Searching: Also called Sequential Searching.

Arrays Searching
55
Binary Searching:
The binary search algorithm can be used with
only sorted list of elements.
 Binary Search first divides a large array into
two smaller sub-arrays and then recursively
operate the sub-arrays.
 Binary Search basically reduces the search
space to half at each step

Arrays Searching
56
Binary Searching:
The binary search algorithm can be used with only sorted list of elements.
 Example: Searching the element 57 from the array of elements

Arrays Searching
57
Binary Searching:
 Example:

Arrays Searching
58
Binary Searching:

Arrays Searching
59
Difference in Searching:

Arrays Searching
60
Difference in Searching:

Arrays Sorting
61
Sorting in Arrays:
A Sorting Algorithm is used to rearrange a given array or list elements according to a
comparison operator on the elements:
 The comparison operator is used to decide the new order of element in the respective
data structure.
 Types of Sorting Algorithms are:
 Bubble Sort
 Insertion Sort
 Selection Sort
 Merge Sort
 Quick Sort
 Heap Sort
 Radix Sort
 Bucket Sort
 Shell Sort

Arrays Sorting
62
Bubble Sort in Arrays:
Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the
adjacent elements if they are in wrong order.

Arrays Sorting
63
Bubble Sort in Arrays:
Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the
adjacent elements if they are in wrong order.
Algorithm
begin BubbleSort(arr)
for all array elements
if arr[i] > arr[i+1]
swap(arr[i], arr[i+1])
end if
end for
return arr
end BubbleSort

Arrays Sorting
64
Insertion Sorting:
Insertion sort is a simple sorting algorithm that builds the final sorted array (or list)
one item at a time.
 This is an in-place comparison-based sorting algorithm. Here, a sub-list is maintained
which is always sorted.

Arrays Sorting
65
Insertion Sorting:
This is an in-place comparison-based sorting algorithm. Here, a sub-list is maintained
 This is an in-place comparison-based sorting algorithm. Here, a sub-list is maintained

Arrays Sorting
66
Insertion Sorting:
 ALGORITHM: Insertion Sort (A, N) A is an array with N unsorted elements.
 Step 1: for I=1 to N-1
 Step 2: J = I
While(J >= 1)
if ( A[J] < A[J-1] ) then
Temp = A[J];
A[J] = A[J-1];
A[J-1] = Temp;
[End if]
J = J-1
[End of While loop]
[End of For loop]
 Step 3: Exit

Arrays Sorting
67
Selection Sort:
Selection sort is a simple and efficient sorting algorithm that works by repeatedly
selecting the smallest (or largest) element from the unsorted portion of the list and
moving it to the sorted portion of the list.
 To implement the Selection Sort algorithm, we need:
 An array with values to sort.
 An inner loop that goes through the array, finds the lowest value, and moves it to the front
of the array. This loop must loop through one less value each time it runs.
 An outer loop that controls how many times the inner loop must run. For an array with n
 values, this outer loop must run n−1 times.

Arrays Sorting
68
Selection Sort:

Arrays Sorting
69
Selection Sort:

Arrays Sorting
70
Merge Sort Algorithm:
Merge sort is a sorting technique based on divide and conquer technique. Merge sort
first divides the array into equal halves and then combines them in a sorted manner.
 Here’s a step-by-step explanation of how merge sort works:
 Divide: Divide the list or array recursively into two halves
until it can no more be divided.
 Conquer: Each subarray is sorted individually using the merge
sort algorithm.
 Merge: The sorted subarrays are merged back together in
sorted order. The process continues until all elements from both
subarrays have been merged.

Arrays Sorting
71
Merging from Array:
Merging: It is used to combine the data items of two sorted files into single file in the
sorted form.
 We have sorted linear array A as below:
1 2 3 4 5 6
10 40 50 80 95 100
 And sorted linear array B as below:
1 2 3 4
20 35 45 90
 After merging merged array C is as below:
1 2 3 4 5 6 7 8 9 10
10 20 35 40 45 50 80 90 95 100

Arrays Sorting
72
Quicksort:
Quicksort is one of the fastest sorting algorithms. This algorithm takes an array of
values, chooses one of the values as the 'pivot' element, and moves the other values so
that lower values are on the left and higher values are on the right of pivot element.
 The algorithm can be described like this:
 Choose a value in the array to be the pivot element.
 Order the rest of the array so that lower values than the pivot element are on the left, and
higher values are on the right.
 Swap the pivot element with the first element of the higher values so that the pivot element
lands in between the lower and higher values.
 Do the same operations (recursively) for the sub-arrays on the left and right side of the pivot
element.

Arrays Sorting
73
Quicksort Algorithms :

Arrays Sorting
74
Quicksort Algorithms :

Arrays Sorting
75
Complexity of Sorting Algorithms :

Arrays
76
Two dimensional array:
A two dimensional array is a collection of elements and each element is identified by a
pair of subscripts. ( A[3] [3] ).
 The elements are stored in continuous memory locations.
 The elements of two-dimensional array as rows and columns.
 The number of rows and columns in a matrix is called as the order of the matrix and
denoted as MxN.
 The number of elements can be obtained by multiplying number of rows and number of
columns. A[0] A[1] A[2]
A[0] 10 20 30
A[1] 40 50 60
A[2] 70 80 90

Arrays
77
Representation of Two Dimensional Array:
pair of subscripts. ( A[m] [n] )
 A is the array of order m x n. To store m*n number of elements, we need m*n memory
locations.
 The elements should be in contiguous memory locations.
 There are two methods:
 Row-major method
 Column-major method
A[0] A[1] A[2]
A[0] 10 20 30
A[1] 40 50 60
A[2] 70 80 90

Arrays
78
Representation of Two Dimensional Array:
Row-Major Method:
 All the first-row elements are stored in sequential
memory locations and then all the second-row
elements are stored and so on. Ex: A[Row][Col]
Column-Major Method:
 All the first column elements are stored in sequential
memory locations and then all the second-column
elements are stored and so on. Ex: A [Col][Row]
1000 10 A[0][0]
1002 20 A[0][1]
1004 30 A[0][2]
1006 40 A[1][0]
1008 50 A[1][1]
1010 60 A[1][2]
1012 70 A[2][0]
1014 80 A[2][1]
1016 90 A[2][2]
1000 10 A[0][0]
1002 40 A[1][0]
1004 70 A[2][0]
1006 20 A[0][1]
1008 50 A[1][1]
1010 80 A[2][1]
1012 30 A[0][2]
1014 60 A[1][2]
1016 90 A[2][2]
Row-Major Method
Col-Major Method

Arrays
79
Calculating the length of the 2D-Array
:
 The size of array or its length is given by the following equation:
A[i][j] is the array size or length of m*n elements.
 To Calculate the address of i*j th element in array:
 Row-Major Method: Loc(A[i][j])=Base(A)+W[n(i-LB)+(j-LB)]
 Col-Major Method: Loc(A[i][j])=Base(A)+W[(i-LB)+m(j-LB)]
Here, W is the number of words per memory location and LB is the smallest index

Arrays
80
Sparse matrix:
Sparse matrices are those matrices that have the majority of their elements equal to zero.
 In other words, the sparse matrix can be defined as the matrix that has a greater number
of zero elements than the non-zero elements.
 Representing a sparse matrix by a 2D array leads to the wastage of lots of memory. In
2D array representation of sparse matrix, there are three fields used that are named as -

Arrays
81
Advantages of Array
:
 It is used to represent multiple data items of same type by using single name.
 It can be used to implement other data structures like linked lists, stacks, queues, tree,
graphs etc.
 Two-dimensional arrays are used to represent matrices.
 Many databases include one-dimensional arrays whose elements are records.

Arrays
82
Disadvantages of Array:
 We must know in advance the how many elements are to be stored in array.
 Array is static structure. It means that array is of fixed size. The memory which is
allocated to array cannot be increased or decreased.
 Array is fixed size; if we allocate more memory than requirement then the memory
space will be wasted.
 The elements of array are stored in consecutive memory locations. So insertion and
deletion are very difficult and time consuming.

Unit 3 Linked List
83
Lists (linked list):
A lists (Linear linked list) can be defined as a collection of variable number of
data items called nodes.
 Lists are the most commonly used non-primitive data structures.
 Each nodes is divided into two parts:
 The first part contains the information of the element.
 The second part contains the memory address of the next node in the list.
Also called Link part.

Linked List
84
Lists (linked list):
Types of linked lists:
 Single linked list
 Doubly linked list
 Single circular linked list
 Doubly circular linked list

Linked List
85
Single linked list:
The link field of the last node contains the memory address of the first node,
such a linked list is called circular linked list:
 The information field contains the data of that node.
 The link field contains the memory address of the next node.
 The last link field contains the memory address as null ().
 There is only one link field in each node, the linked list is called singly linked
list.

Linked List
86
Single circular linked list:
A singly linked list contains two fields in each node - an information field and
the linked field:
 The information field contains the data of that node.
 The link field contains the memory address of the next node
 The last link field contains the memory address of the first node.
 In a circular linked list every node is accessible from a given node.

Linked List
87
Doubly linked list:
It is a linked list in which each node is points both to the next node and also
to the previous node:
 In doubly linked list each node contains three parts:
 FORW : It is a pointer field that contains the address of the next node
 BACK: It is a pointer field that contains the address of the previous node.
 INFO: It contains the actual data.
 In the first node, if BACK contains NULL, it indicated that it is the first node in
the list.
 The in which FORW contains, NULL indicates that the node is the last node.

Linked List
88
Doubly circular linked list:
It is a linked list in which each node is points both to the next node and also to
the previous node:
 In doubly linked list each node contains three parts:
 FORW : It is a pointer field that contains the address of the next node
 BACK: It is a pointer field that contains the address of the previous node.
 INFO: It contains the actual data.

Linked List
89
Operation on Linked List:
The operation that are performed on linked lists are:
 Creating a linked list
 Traversing a linked list
 Inserting an item into a linked list.
 Deleting an item from the linked list.
 Searching an item in the linked list
 Merging two or more linked lists.

Linked List
90
Creating a linked list:
The nodes of a linked list can be created by the following structure declaration:
struct Node
{
int information;
struct Node *link;
}*node1, *node2;
 Here info is the information field and link is the link field.
 The link field contains a pointer variable that refers the same node structure. Such a
reference is called as Self addressing pointer.

Linked List
91
Creating a linked list:

Linked List
92
Operator new and delete:
 Operators new allocate memory space
 Operators new [ ] allocates memory space for array.
 Operators delete deallocate memory space.
 Operators delete [ ] deallocate memory space for array.
struct Node
{
int information;
struct Node *link;
}*node1, *node2;

93
Traversing is the process of accessing each node of the linked list exactly once to
perform some operation.
ALGORITHM: TRAVERS (START, P)
START contains the address of the first node. Another pointer p is temporarily used to visit all the nodes
from the beginning to the end of the linked list.
Step 1: P = START
Step 2: while P != NULL
Step 3: PROCESS data (P) [Fetch the data]
Step 4: P = link(P) [Advance P to next node]
Step 5: End of while
Step 6: Return
Traversing a linked list
Code:
struct node *temp = head;
printf("nnList elements are - n");
while(temp != NULL) {
printf("%d --->",temp->data);
temp = temp->next;
}

94
 Inserting a node at the beginning of the linked list
 Inserting a node at the given position.
 Inserting a node at the end of the linked list.
Linked List
Inserting a node into the linked list:

95
Linked List
Inserting node at Front:
Inserting a node at the beginning of the linked list
1. Create a node.
2. Fill data into the data field of the new node.
3. Mark its pointer field as NULL
4. Attach this newly created node to START
5. Make the new node as the START node.

96
Linked List
ALGORITHM: INS_BEG (START, P) START contains the address of the first node.
Step 1: P new Node;
Step 2: data(P) num;
Step 3: link(P) START
Step 4: START P
Step 5: Return

97
Linked List
 Get the new node using getnode().
newnode = getnode();
 If the list is empty then start = newnode.
 If the list is not empty, follow the steps given below:
newnode -> next = start;
start = newnode;
void insert_at_beg()
{ node *newnode;
newnode = getnode();
if(start == NULL)
{ start = newnode; }
else
{ newnode -> next = start;
start = newnode;}
}

98
Linked List
Inserting node at End:
Inserting a node at the End of the linked list
1. Create a node.
2. Fill data into the data field of the new node.
3. Mark its pointer field as NULL
4. Attach this newly created node to Last
5. Make the new node as the Last node.

ALGORITHM: INS_END (START, P)
START contains the address of the first node.
Step 1: START
Step 2: P START [identify the last node]
while P!= null
P next (P)
End while
Step 3: N new Node;
Step 4: data(N) item;
Step 5: link(N) null
Step 6: link(P) N
Step 7: Return
99
Inserting node at End

Insert at the End
100
Inserting node at End
 Allocate memory for new node
 Store data
 Traverse to last node
 Change next of last node to recently created node
struct node *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = 4;
newNode->next = NULL;
struct node *temp = head;
while(temp->next != NULL){
temp = temp->next;
}
temp->next = newNode;

Data Structure using C by Dr. K Adisesha .ppsx

More Related Content

What's hot

Similar to Data Structure using C by Dr. K Adisesha .ppsx

More from Prof. Dr. K. Adisesha

Recently uploaded

Data Structure using C by Dr. K Adisesha .ppsx