# DATA STRUCTURES AND ALGORITHMS

**Introduction to Data Structures and Algorithms
**

Data structures and algorithms are fundamental concepts in computer science that help in organizing and managing data efficiently. This session introduces basic data structures and the importance of algorithms in developing efficient solutions to computational problems.

**Objectives of This Session**

– Understand what data structures are and why they are important.

– Learn about basic data structures such as arrays, linked lists, and stacks.

– Introduction to algorithm complexity and why it matters.

**1. What are Data Structures?
**

##### Definition:

A data structure is a particular way of organizing data in a computer so that it can be used effectively.

##### Examples:

Arrays, Linked Lists, Stacks, Queues, Trees, Graphs.

**2. Basic Data Structures
**

##### Arrays:

**– Description:** A collection of elements identified by index or key.

**– Usage:** Store data elements of the same type.

** – Example:** Storing a list of student names.

**– Linked Lists:**

** ****– Description:** A sequence of nodes where each node stores its own data and a reference (or link) to the next node in the sequence.

**– Types:** Singly linked lists, doubly linked lists.

** – Example:**

struct Node {

int data;

Node* next;

};

**– Stacks:**

**– Description:** An ordered collection of items where addition of new items and removal of existing items always takes place at the same end, called the “top.”

**– Operations:** push (add), pop (remove), peek (retrieve top without removing).

** **** – Example:**

#include <stack>

std::stack<int> s;

s.push(10); // Pushing 10 onto the stack

s.pop(); // Removing the top item

**3. Importance of Algorithms**

##### Definition:

An algorithm is a set of instructions designed to perform a specific task.

##### Example:

Sorting algorithms, searching algorithms.

##### Complexity Analysis:

** – Time Complexity:** How the runtime of an algorithm increases as the size of input increases.

** – Space Complexity:** Amount of memory space required by the algorithm as a function of input size.

** **** – Big O Notation: **A mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity, often used to describe the complexity of algorithms.

**4. Example of Algorithm: Bubble Sort
**

##### Description:

A simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order.

##### Implementation:

void bubbleSort(int arr[], int n) {

for (int i = 0; i < n-1; i++)

for (int j = 0; j < n-i-1; j++)

if (arr[j] > arr[j+1])

swap(&arr[j], &arr[j+1]);

}

##### Complexity:

O(n²) in the worst case.

**5. Practical Exercise
**

##### Task:

Implement a linked list in C++.

##### Challenge:

Add functions to insert, delete, and display elements of the linked list.

**6. Getting Started with Learning
**

##### Resources:

** –** [Code With Harry for learning DSA] (https://bit.ly/3Ut425d )

** –** [W3 Schools for learning DSA] (https://www.w3schools.com/dsa/index.php)

**Conclusion
**

Understanding and utilizing data structures and algorithms efficiently can greatly improve the performance of software applications. This session has introduced you to the foundational structures and concepts that will be built upon in future classes.