OMVVIM

Subject Code : CS – 08
Subject Name : Data Structure Using
C Language

Unit-1
Algorithm Analysis & File Handling

Outline of the Chapter

Algorithm Analysis
1. Introduction to Data Structure
2. The Analysis of algorithm
3. Time & Space Complexity
4. Asymptotic notation
5. Classes of algorithm
6. Big‐Oh Notation
7. Big‐Omega Notation
File Handling
1. Concept of Data Files
2. File Handling
3. Use of File Handling Functions
4. I/O Operations
5. Command line Arguments
 Algorithm Analysis
Data: Meaningful Facts is known as Data.

Structure: Way of organizing information, so that it is easier to use.

Data Structure: A data structure is a particular way of organizing data in a computer so that it can
be used efficiently.

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.

A scheme for organizing related pieces of information & we can

manipulate it.

Introduction to Algorithm
To work with a computer, we have to use a computer program.

To write a computer we have to provide step by step command to

perform a task.

What is Algorithm?
An algorithm is just a detailed sequence of simple steps that are needed
to solve a problem.

Program = Algorithm + Data Structure

Analysis of Algorithm
 In computer science, the analysis of algorithms is the determination of the number of resources
necessary to execute them.
 Most algorithms are designed to work with inputs of undefined
length.
 Algorithm analysis is an important part of a wide computational complexity theory which provides
theoretical estimates for the resources needed by any algorithm which solves a given
computational problem.

There are two main complexity measures of the efficiency of an algorithm.

1. TIME Complexity
 A program executes number of instructions during the execution time is called as its Time
Complexity.
 Instead of measuring actual time required in executing each statement in the code, Time
Complexity considers how many times each statement executes.
 The time complexity of an algorithm is commonly expressed using big O notation, which
excludes coefficients and lower order terms.
 For Example: Operations, Comparisons, Loop, Function calls to outside.
Time Complexity Chart:

Sr. O Notation Complexity Rate of Growth

No.

1 O(1) Constant Fast

2 O(log n) Logarithmic

3 O(n) Linear Time

4 O(n^2) Quadratic

5 O(n^3) Cubic

6 O(n!) Factorial Slow

Real life Example for Understanding:

O(1): Going and asking each student individually is O(1).
O(n): You go and ask the first person in the class if he has the pen. Also, you ask this person about
the other 99 people in the classroom if they have that pen and so on. This is what we call O(n).
O(log n): Now I divide the class into two groups, then ask: “Is it on the left side, or the right side of
the classroom?” Then I take that group and divide it into two and ask again, and so on. Repeat the
process till you are left with one student who has your pen. This is what you mean by O(log n).

1. Constant Time (O(1))

The running time of the algorithm does not depend on the size of the input. Examples include
accessing an element in an array by index, or performing a simple arithmetic operation.
Example 1: O(1)
#include <stdio.h>
int main()
{
printf("Hello World");
return 0;
}
Output : Hello World
Time Complexity: In the above code “Hello World” is printed only once on the screen.
So, the time complexity is constant: O(1) i.e. every time a constant amount of time is required to
execute code, no matter which operating system or which machine configurations you are using.

2. Linear Time (O(n))

The running time increases linearly with the size of the input. Examples include iterating through
each element in an array once or performing a single pass through a linked list.
Example 2: O(n)
#include <stdio.h>
void main()
{
int i, n = 8;
for (i = 1; i <= n; i++)
{ printf("Hello World !!!\n");
}
}
Output:
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Time Complexity: In the above code “Hello World !!!” is printed only n times on the screen, as
the value of n can change.
So, the time complexity is linear: O(n) i.e. every time, a linear amount of time is required to
execute code.
3. Logarithmic Time (O(log n))
The running time grows logarithmically with the size of the input. Algorithms with logarithmic time
complexity often involve dividing the problem size in half at each step, such as binary search on a
sorted array.
Example 3: O(log(n))
#include <stdio.h>
void main()
{
int i, n = 8;
for (i = 1; i <= n; i=i*2)
{
printf("Hello World !!!\n");
}
}
Output:
Hello World !!!
Hello World !!!
Hello World !!!
Hello World !!!
Time Complexity: O(log(n))
This is similar to linear time complexity, except that the runtime does not depend on the input size
but rather on half the input size. When the input size decreases on each iteration or step, an
algorithm is said to have logarithmic time complexity.

4. Quadratic Time (O(n^2))

The running time is proportional to the square of the size of the input. Algorithms with quadratic
time complexity often involve nested iterations over the input data.
#include <stdio.h>
#include <math.h>
void main()
{
int i, n = 8;
 for (i = 2; i <= n; i=pow(i,2))
{
printf("Hello World !!!\n");
}
}
Output:
Hello World !!!
Hello World !!!

5. Cubic Time (O(n^3))

Similar to quadratic time complexity, but the running time is proportional to the cube of the size of
the input. This complexity is common in algorithms that involve three nested iterations over the
input data.

6. Factorial Time (O(n!))

The running time grows factorially with the size of the input. This is the worst time complexity and
is typically encountered in brute‐force algorithms that generate all permutations or combinations
of a set of elements.

2. Space Complexity
 Space Complexity of an algorithm is total space taken by the algorithm with respect to the input
size.
 Space complexity includes both Auxiliary space and space used by input.
 For Example: Variables, Allocations, Function call
Space Complexity = Auxiliary Space + Space used for input values
Auxiliary space is nothing but the space required by an algorithm/problem during the execution of
that algorithm/problem.
Type 1: A Fixed part:
It is independent of the input size. It includes memory for instructions (code), constants, variables,
etc.
Type 2: A Variable part:
It is dependent on the input size. It includes memory for recursion stack, referenced variables, etc.
For Example: dynamic memory allocation, recursion stack space, etc.

Example: 1
int main()
{
int a = 10;
float b = 20.5;
char c = 'A';
int d[10];
return 0;
}
To calculate the complexity of this algorithm, we need to determine the amount of memory used
by each of the variables. In this case:
a is an integer, which takes up 4 bytes of memory.
b is a float, which takes up 4 bytes of memory.
c is a character, which takes up 1 byte of memory.
d is an array of 10 integers, which takes up 40 bytes of memory (10 x 4).
So, the total amount of memory used by this algorithm is 4 + 4 + 1 + 40 = 49 bytes.
Example: 2
Example 1: Addition of Numbers
{
int a = x + y + z;
return (a);
}
So in the above example, there are 4 integer variables those are a, x, y, z so they will take 4
bytes(as given in the table above) space for each variable, and extra 4 ‐byte space will also be
added to the total space complexity for the return value that is a.
Hence, the total space complexity = 4*4 + 4 = 20 bytes

Difference between Time and Space Complexity:

Asymptotic Notations:
 Asymptotic notations are mathematical tools to represent time complexity of algorithms for
asymptotic analysis.
 We use three types of asymptotic notations to represent the growth of any algorithm, as input
increases:
1. Big Oh(O)
2. Big Omega (Ω)
3. Big Theta (Θ)

1. Big Oh(O)
 The Big O notation defines an upper bound of an algorithm’s running time.
 It measures the worst case time complexity or the longest amount of time possibly taken
 by the algorithm to complete.
 The running time complexity is always specified in the so called O‐notation.
 The O is the formal method of expressing the upper bound of an algorithm’s running time.
Worst case Time Complexity Example:
If we want to search the element which is present at the last of the list or not present at all
in the list then such cases are called the worst case efficiency.
let we have to find 105 in List =>25,31,42,71,105
Therefore, we have to make 5 (=n) comparisons to search the element
Cworst (n)=n
Now if we have to find 110
Since the element is not in the list even then we have to make 5 (=n) comparisons to
search the element
Cworst (n)=n

2. Big Omega (Ω)

 The Big Ω notation defines a Lower bound of an algorithm’s running time.
 It measures the best case time complexity or the best amount of time possibly taken by
the algorithm to complete.
 The Ω is the formal method of expressing the Lower bound of an algorithm’s running time.
Best case Time Complexity Example:
If we want to search the element which is present at the first of the list in the list then such
cases are called the best case efficiency.
let we have to find 25 in List =>25,31,42,71,105
s present at the first position
Since only single comparison is made to search the element so we say that it is best case
Efficiency.
CBest (n)=1
3. Big Theta (Θ)
 The Big Θ notation defines both the upper bound and the lower bound of an algorithm’s
running time.
 It measures the Average case time complexity possibly taken by the algorithm to complete.
 The Θ is the formal method of expressing the upper bound and Lower Bound of an
algorithm’s running time.
 Average case Time Complexity Example:
If we want to search the element which is not present at the first or the last position then
such cases are called the Average case time complexity.
Let we have to find 42 in List =>25,31,42,71,105
The element is present in middle of the list.
We know that probability of a successful search = p where 0<p<1.
And probability of unsuccessful search = 1‐p

Classes/Classification of algorithm

1. Array: An array is a collection of items of the same variable type that are stored at contiguous
memory locations. It’s one of the most popular and simple data structures and is often used
to implement other data structures. Each item in an array is indexed starting with 0.

2. Searching Algorithms: These algorithms are designed to find a particular element or set of
elements within a data structure.
 Examples include Linear Search, Binary Search, Depth‐First Search (DFS), and Breadth‐First
Search (BFS).

3. Sorting Algorithms: Sorting algorithms arrange the elements of a data structure in a specific
order. Common sorting algorithms include Bubble Sort, Insertion Sort, Selection Sort, Merge
Sort, Quick Sort, and Heap Sort.

4. Traversal Algorithms: These algorithms visit and process all the nodes or elements of a data
structure in a specific order without searching for any particular element.
Examples include Pre‐order, In‐order, Post‐order, and Level‐order traversal for trees.

5. Graph Algorithms: Graph algorithms which are collections of nodes (vertices) and edges
connecting these nodes.
Examples include DFS, BFS, Dijkstra's algorithm for shortest paths, Kruskal's algorithm for
minimum spanning trees, and Prim's algorithm.
6. Greedy Algorithms: Greedy algorithms make locally optimal choices at each step with the
hope of finding a global optimum.
Examples include Prim's algorithm and Kruskal's algorithm for minimum spanning trees, and
Dijkstra's algorithm for shortest paths.

7. Divide and Conquer Algorithms: These algorithms solve a problem by dividing it into smaller
subproblems, conquering the subproblems recursively, and combining their solutions to solve
the original problem.
Examples include Merge Sort and Quick Sort.

8. Linked List:

9. Stack:
10. Queue:

11. Tree:
 File Handling
What is Data Files?
A file structure is a combination of representations for data in files. It is also a collection of
operations for accessing the data. It enables applications to read, write, and modify data.

What is File Handling?

The process of file handling refers to how we store the available data or info in a file with the help
of a program.

The C language stores all the data available in a program into a file with the help of file handling in
C.

A file can be classified into two types based on the way the file stores the data.

1. Text Files
 A text file contains data in the form of ASCII characters and is generally used to store a stream of
characters.
 Each line in a text file ends with a new line character (‘\n’).
 It can be read or written by any text editor.
 They are generally stored with .txt file extension.
 Text files can also be used to store the source code.
2. Binary Files
 A binary file contains data in binary form (i.e. 0’s and 1’s) instead of ASCII characters. They
contain data that is stored in a similar manner to how it is stored in the main memory.
 The binary files can be created only from within a program and their contents can only be read
by a program.
 More secure as they are not easily readable.
 They are generally stored with .bin file extension.

File Modes

File Handling Functions

1. fopen()
fopen is a C library function used to open an existing file or create a new file.

Syntax:

FILE *Pointer_Variable_name;

Pointer_variable_name = fopen("filename.txt","mode");
2. fclose()
fclose() function is a C library function that releases the memory stream opened by the fopen()
function.

Syntax: fclose(Pointer_VariableName);

Example of fopen() and fclose():

#include <stdio.h>
//#include <stdlib.h> if required
#include <conio.h>
void main()
{
// file pointer
FILE* fptr;
clrscr();
// creating file using fopen() access mode "w"
fptr = fopen("file.txt", "w");

// checking if the file is created

if (fptr == NULL)
{
printf("The file is not opened. The program will exit now");
}
else
{
printf("The file is created Successfully.");
}
fclose(fptr);
getch();
}

3. fprintf()
C fprintf() function passes arguments according to the specified format to the file indicated by the
stream.

This function is implemented in file‐related programs for writing formatted data in any file.

Syntax: fprintf(pointer_variablename,%format,data);

Example: First Create File1.txt in your Program Location

#include<stdio.h>
#include<conio.h>
void main ()
{
FILE *fptr;
clrscr();
fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\file1.txt","w");
fprintf(fptr, "%s %s %d", "Welcome", "to", 2024);
if (fptr == NULL)
{
printf("The file is not opened. The program will exit now");
}
else
{
printf("Data is print Successfully.");
}
fclose(fptr);
getch();
}

Output:

4. fscanf()
fscanf() reads data from the file sequentially, converting it according to the format specifier, and
storing the results in the specified variables.

Syntax:

fscanf(Pointer_VariableName, format, ...)

 This format string contains conversion specifiers (like %d, %f, %s, etc.) that indicate the type and
format of the data to be read.
 The %s specifier reads a string of characters terminated by whitespace (space, tab, or newline).
 The %d format specifier expects an address (pointer) to an integer variable. By using &age, you
are passing the address of the age variable, allowing fscanf() to store the integer value it reads
from the file directly into the memory location associated with the age variable.

Example: 1 (Read String Data from File)

#include <stdio.h>
#include <conio.h>
// Driver Code
void main()
{
char str1[50], str2[50], str3[50], str4[50];
clrscr();
FILE *fptr;
fptr= fopen("Z:\\DS\\DS Practical\\Text_File\\file2.txt", "r");

fscanf(fptr, "%s", str1);

fscanf(fptr, "%s", str2);
fscanf(fptr, "%s", str3);
fscanf(fptr, "%s", str4);

// Output the read strings

printf("Read strings: %s %s %s %s\n", str1, str2, str3, str4);
getch();
}

Output:

Example: 2 (Read Numeric & String Data from File)

#include <stdio.h>
#include <conio.h>
// Driver Code
void main()
{
FILE *file;
char name[50];
int age;

clrscr();
// Open the file
file = fopen("Z:\\DS\\DS Practical\\Text_File\\data.txt", "r");

// Read name and age from the file

while (fscanf(file, "%s %d", name, &age) != EOF)
{
// Output the read data
printf("Name: %s, Age: %d\n", name, age);
}

// Close the file

fclose(file);
getch();
}
Output:

5. getw()
The getw() function reads an integer from a file using fscanf() and returns it.

Syntax:

int getw(FILE *Pointer_VariableName);

6. putw()
The putw() function writes an integer to a file using fprintf().

Syntax:

int putw(int w, FILE * Pointer_VariableName);

Example of getw() and putw():

#include <stdio.h>
#include <conio.h>

// Function to read an integer from a file

int getw(FILE *fptr)
{
int number;
if (fscanf(fptr, "%d", &number) != 1)
{
return 0; // Return 0 if unable to read the integer
}
return number; // Return the read integer
}

// Function to write an integer to a file

int putw(int number, FILE *fptr)
{
if (fprintf(fptr, "%d\n", number) < 0)
{
return 0; // Return 0 if unable to write the integer
}
return 1; // Return 1 to indicate success
}
void main()
{
FILE *fptr;
int number_written = 12345;
int number_read;
clrscr();

// Writing to file
fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\number.txt", "w");

putw(number_written, fptr);

fclose(fptr);

// Reading from file

fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\number.txt", "r");

number_read = getw(fptr);

printf("Read number: %d\n", number_read);

fclose(fptr);

getch();
}

Output:

7. fseek()
fseek() is a function in C used to move the file pointer associated with a given file stream to a
specified location.

It allows you to reposition the file pointer within a file, facilitating random access to different parts
of the file.

fseek(FILE *Pointer_VariableName, long offset, int whence);

Offset: The number of bytes you want to move the file pointer. It can be positive or negative.

Whence: Specifies the reference point for the offset. It can take one of the following values:

1. SEEK_SET: The beginning of the file.

2. SEEK_CUR: The current position of the file pointer.
 3. SEEK_END: The end of the file.

Example:

#include <stdio.h>
#include <conio.h>

void main()
{
FILE *fptr;
clrscr();
fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\file2.txt", "r");

if (fptr == NULL)
{
printf("Error opening the file.\n");
}

// Move the file pointer 10 bytes from the beginning of the file (Start with 0 index)
fseek(fptr, 10, SEEK_SET);

// Read and print the character at the current position

int ch = fgetc(fptr); // fgetc () function reads a character from file.
printf("Character at position 10: %c\n", ch);

fclose(fptr);
getch();
}

Output:

8. ftell()
ftell() is a function in C used to determine the current position of the file pointer within a file
associated with a given file stream. It returns the current file position indicator for the stream.

long ftell(FILE *Pointer_VariableName);

fseek() to move the file pointer to the end of the file.

ftell() to get the current position of the file pointer, which effectively gives us the size of the file in
bytes.

Example of ftell() as well as SEEK_SET, SEEK_CUR, SEEK_END:

#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fptr;
char ch;
long fileSize;
clrscr();

// Open the file in read mode

fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\test.txt", "r");

// Seek to the end of the file

fseek(fptr, 0, SEEK_END);

// Get the current position (which is the size of the file)

fileSize = ftell(fptr);
printf("File size: %ld bytes\n", fileSize);

// Seek to the middle of the file

fseek(fptr, fileSize / 2, SEEK_SET); //31/2 =15.5 so 15 + 16 =31

// Read and print characters from the middle to the end of the file
while ((ch = fgetc(fptr)) != EOF)
{
printf("%c", ch);
}

// Move the file pointer 10 bytes backward from the current position
fseek(fptr, ‐10, SEEK_CUR);

printf("\n\nLast 10 characters:\n");
// Read and print the last 10 characters of the file
while ((ch = fgetc(fptr)) != EOF)
{
printf("%c", ch);
}

// Close the file

fclose(fptr);
getch();
}
Output:

9. rewind()
The rewind() function sets the file pointer at the beginning of the stream. It is useful if you have to
use stream many times.

rewind(FILE *Pointer_VariableName);

Example:

#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fptr;
char c;
clrscr();
fptr=fopen("Z:\\DS\\DS Practical\\Text_File\\file2.txt","r");

while((c=fgetc(fptr))!=EOF)
{
printf("%c",c);
}

rewind(fptr);//moves the file pointer at beginning of the file

while((c=fgetc(fptr))!=EOF)
{
printf("%c",c);
}
fclose(fptr);
getch();
}

Output:
10. freopen()
freopen() is a function in C that is used to associate a new file with the specified stream, effectively
redirecting input and output. This function is useful when you want to change the file associated
with an existing stream (like stdin, stdout, or stderr) during runtime.

Syntax:

FILE *freopen(*Pointer_VariableName, File_Mode, FILE *stream);

Example of stdout:

#include <stdio.h>
#include <conio.h>

void main()
{
// Output will be redirected to "output.txt"
freopen("Z:\\DS\\DS Practical\\Text_File\\output.txt", "w", stdout);
clrscr();

printf("This will be written to output.txt\n");

fclose(stdout); // Close the file stream after finishing writing

getch();
}

Output:

Example of stdin:

#include <stdio.h>
#include <conio.h>

void main()
{
freopen("Z:\\DS\\DS Practical\\Text_File\\output.txt", "r", stdin);
clrscr();
char data[50];
// Read integers from the file and print them
while (scanf("%s", data) == 1)
{
printf("%s",data);
 }

fclose(stdin); // Close the file stream after finishing reading

getch();
}

Output:

11. remove()
Example:

#include <stdio.h>
#include <conio.h>

void main()
{
char filename[] = "Z:\\DS\\DS Practical\\Text_File\\data.txt";
clrscr();
if (remove(filename) == 0)
{
printf("%s file deleted successfully.\n", filename);
}
else
{
perror("Error deleting file");
}
getch();
}

This code snippet attempts to delete a file named "data.txt" in the current directory.
If successful, it prints a success message; otherwise, it prints an error message using perror().

12. rename()
This code snippet renames a file named "old_filename.txt" to "new_filename.txt".
If successful, it prints a success message; otherwise, it prints an error message using perror().

Example:

#include <stdio.h>
#include <conio.h>

void main()
{
char old_name[] = "Z:\\DS\\DS Practical\\Text_File\\example1.txt";
char new_name[] = "Z:\\DS\\DS Practical\\Text_File\\example.txt";

clrscr();
if (rename(old_name, new_name) == 0)
{
printf("File renamed successfully.\n");
}
else
{
perror("Error renaming file");
}
getch();
}

13. feof()
feof() is a function used to check if the end‐of‐file indicator has been set for a stream.

Example:

#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fptr;
char character;

// Open the file in read mode

fptr = fopen("Z:\\DS\\DS Practical\\Text_File\\example.txt", "r");

// Check if the file was opened successfully

if (fptr == NULL)
{
perror("Error opening file");
}

// Read characters until the end of file

 while (!feof(fptr))
{
character = fgetc(fptr);
printf("%c", character);
}

// Close the file

fclose(fptr);
getch();
}

Output:

I/O Operations
To handle files in C, file input/output functions available in the stdio library are:
Solve Practical Example for File Handling:
Write a program for writing data into student.txt file.

Input:

Om VVIM College
20
20.5

Output:

1. Read digit, String and float value from student.txt file.

2. Read VVIM from file.
3. Rename student.txt to Your_name.txt
4. Print Size of your file.
5. Remove File from Your Location
Command line Argument
Command‐line arguments in C refer to the parameters passed to a program when it is executed
from the command line or terminal. When you run a C program from the command line, you can
provide additional information to the program by passing arguments along with the command
used to execute the program.

In C, the main function can accept command‐line arguments.

int main(int argc, char *argv[])

argc stands for "argument count" and indicates the number of command ‐line arguments passed to
the program, including the name of the program itself.

argv stands for "argument vector" and is an array of strings (char*), where each element
represents one command‐line argument. argv[0] is always the name of the program itself.

Example:

#include <stdio.h>
#include <conio.h>

int main(int argc, char *argv[]) //argv represent 2D Array. * indicate array size not fix.
{
int i;
clrscr();
// argc is the number of arguments passed
printf("Number of arguments: %d\n", argc);//argc represent count number of argument

// argv[0] is the program's name itself

printf("Program name: %s\n", argv[0]);

// printing other arguments if present

for (i = 1; i < argc; i++)
{
printf("Argument %d: %s\n", i, argv[i]);
}

getch();
return 0;
}
Steps for run Command Line Argument Program:

1st Give Argument to Program

Go to Options Menu ‐> Click on Environment ‐> Give Argument of any data type.

Output: