DSA HelpDesk

A technique to store and organize data efficiently in a computer.

Data is defined as facts, figures, or information that is stored in or used by a computer.

The processed form of data is known as information.

• Operating Systems
• Artificial Intelligence
• Computer Design
• Computer Graphics

A sequence of steps or instructions to solve a particular problem. Key properties: finiteness, simplicity, input, output, correctness, and generality.

Time Complexity measures how running time grows with input size. Space Complexity measures extra memory used by an algorithm.

Elements are arranged sequentially; each connects to its previous and next element.

Elements are arranged hierarchically, not in a straight sequence.

• Insertion — add a new element
• Traversing — visit every element
• Deletion — remove an element
• Searching — find an element
• Sorting — arrange in order

A collection of similar data elements stored in contiguous memory locations.

1D Array — list of elements in one row. 2D Array — elements arranged in rows and columns (matrix).

Adding a new element at a given location by shifting subsequent elements to the right.

Visiting each element of the array from start to end, typically using a loop.

Removing an element and shifting remaining elements to fill the gap.

Finding the location of a given element in a data structure.

Checks each element one by one from the beginning until the target is found or the list ends. Works on unsorted arrays.

Divides a sorted array repeatedly in half to locate a target. Much faster than linear search for large datasets.

Arranging elements in ascending or descending order.

Repeatedly swaps adjacent elements if they are in wrong order.

#include <stdio.h>
int main() {
  int a[100], n, i, j, temp;
  printf("Enter number of elements: ");
  scanf("%d", &n);
  for (i = 0; i < n; i++)
    scanf("%d", &a[i]);
  for (i = 0; i < n - 1; i++)
    for (j = 0; j < n - i - 1; j++)
      if (a[j] > a[j + 1]) {
        temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp;
      }
  printf("Sorted Array:n");
  for (i = 0; i < n; i++)
    printf("%d ", a[i]);
  return 0;
}

• Introduction to Data Structures, algorithms, types, and operations (insertion, deletion, traversing, searching, sorting)
• Space & time complexity — Big O, Big Omega, Big Theta; best, average, and worst case
• Arrays: 2D arrays, array of pointers, sparse matrix, row/column-major order; linear & binary search; bubble sort
• Linked List: singly, doubly, circular (singly & doubly), header linked list — all operations
• Stack: array & linked list implementation; infix to postfix; arithmetic expression notations
• Queue: array & linked list; circular queue; priority queue; round robin algorithm
• Recursion: factorial, Tower of Hanoi
• Trees: BST, heap tree, AVL rotations, heap sort, threaded binary tree; M-way, B-tree, B+ tree
• Graphs: array & linked list representation; BFS, DFS; shortest path; spanning tree
• Sorting: selection, insertion, quick, merge, radix sort
• Hashing: direct, division, and mid-square methods

• Fundamentals, algorithm writing, DS types, operations, and Big O notation
• Arrays: 2D arrays, array of pointers; insertion, traversing, deletion; linear & binary search; bubble sort
• Linked List: singly, doubly, circular, header linked list — all operations
• Stack & Queue: full implementations and applications
• Recursion: factorial, Tower of Hanoi
• Trees: BST, heap tree, AVL rotations, heap sort, threaded binary tree theory
• Graphs: introduction; array & linked list representation
• Sorting: selection, insertion, quick sort

• Introduction to data structures, algorithm writing, and DS types
• Operations: insertion, deletion, traversing, searching, sorting
• Arrays: insertion, traversing, deletion; linear & binary search; bubble sort
• Linked List: singly, doubly, circular — all operations
• Stack & Queue: array & linked list implementations
• Recursion: introduction and basics
• Trees: binary tree, BST, heap tree, AVL theory
• Sorting: selection and insertion sort