C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Learn essential array operations in C including linear search, binary search, bubble sort, selection sort, insertion, and deletion with step-by-step examples.
Working with arrays goes far beyond simply storing and retrieving values. The real power comes from the operations you perform on them — searching for elements, sorting them into order, inserting new values, and removing unwanted ones. These operations form the foundation of almost every algorithm you'll encounter in computer science.
Searching Operations
Linear Search (Sequential Search)
The simplest search technique — examine each element one by one until you find the target or reach the end.
Time Complexity: O(n) — worst case checks every element.
Example
#include <stdio.h>
int linearSearch(int arr[], int size, int target) {
for (int i = 0; i < size; i++) {
if (arr[i] == target) {
return i; // Found at index i
}
}
return -1; // Not found
}
int main() {
int arr[] = {45, 23, 78, 12, 96, 34, 67};
int n = sizeof(arr) / sizeof(arr[0]);
int target = 96;
int result = linearSearch(arr, n, target);
if (result != -1)
printf("%d found at index %d\n", target, result);
else
printf("%d not found in array\n", target);
return 0;
}
Output
96 found at index 4
Binary Search (Requires Sorted Array)
A much faster algorithm that repeatedly divides the search space in half. The array must be sorted first.
Time Complexity: O(log n) — dramatically faster for large arrays.
Example
#include <stdio.h>
int binarySearch(int arr[], int size, int target) {
int low = 0, high = size - 1;
while (low <= high) {
int mid = low + (high - low) / 2; // Avoids overflow
if (arr[mid] == target)
return mid;
else if (arr[mid] < target)
low = mid + 1;
else
high = mid - 1;
}
return -1; // Not found
}
int main() {
int arr[] = {12, 23, 34, 45, 56, 67, 78, 89, 96};
int n = sizeof(arr) / sizeof(arr[0]);
int target = 67;
int result = binarySearch(arr, n, target);
if (result != -1)
printf("%d found at index %d\n", target, result);
else
printf("%d not found\n", target);
return 0;
}
Output
67 found at index 5
How Binary Search Works:
| Array | [12, 23, 34, 45, 56, 67, 78, 89, 96] |
| Target | 67 |
| Step 1: low=0, high=8, mid=4 | arr[4]=56 < 67 → low=5 |
| Step 2: low=5, high=8, mid=6 | arr[6]=78 > 67 → high=5 |
| Step 3: low=5, high=5, mid=5 | arr[5]=67 == 67 → FOUND at index 5! |
Search Comparison Table
| Feature | Linear Search | Binary Search |
|---|---|---|
| Time Complexity | O(n) | O(log n) |
| Requires Sorted? | No | Yes |
| Best for | Small/unsorted arrays | Large sorted arrays |
| Space Complexity | O(1) | O(1) iterative |
Sorting Operations
Bubble Sort
Repeatedly swap adjacent elements if they're in the wrong order. Simple but inefficient for large arrays.
Time Complexity: O(n²)
Example
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int swapped = 0;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}
if (!swapped) break; // Optimization: already sorted
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Before: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
bubbleSort(arr, n);
printf("\nAfter: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
printf("\n");
return 0;
}
Output
Before: 64 34 25 12 22 11 90 After: 11 12 22 25 34 64 90
Selection Sort
Find the minimum element and place it at the beginning, then repeat for the remaining portion.
Time Complexity: O(n²)
Example
#include <stdio.h>
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx])
minIdx = j;
}
// Swap minimum with current position
if (minIdx != i) {
int temp = arr[i];
arr[i] = arr[minIdx];
arr[minIdx] = temp;
}
}
}
int main() {
int arr[] = {29, 10, 14, 37, 13};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("Sorted: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
printf("\n");
return 0;
}
Output
Sorted: 10 13 14 29 37
Insertion Sort
Build the sorted portion one element at a time by inserting each new element into its correct position.
Time Complexity: O(n²) worst case, O(n) best case (nearly sorted data)
Example
#include <stdio.h>
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("Sorted: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
printf("\n");
return 0;
}
Output
Sorted: 5 6 11 12 13
Insertion into an Array
To insert an element at a specific position, shift existing elements to make room:
Example
#include <stdio.h>
int insertElement(int arr[], int *size, int pos, int value, int capacity) {
if (*size >= capacity) {
printf("Array is full!\n");
return 0;
}
if (pos < 0 || pos > *size) {
printf("Invalid position!\n");
return 0;
}
// Shift elements to the right
for (int i = *size; i > pos; i--) {
arr[i] = arr[i - 1];
}
arr[pos] = value;
(*size)++;
return 1;
}
int main() {
int arr[10] = {10, 20, 30, 40, 50};
int size = 5;
printf("Before insertion: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
insertElement(arr, &size, 2, 25, 10); // Insert 25 at index 2
printf("\nAfter inserting 25 at index 2: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\n");
return 0;
}
Output
Before insertion: 10 20 30 40 50 After inserting 25 at index 2: 10 20 25 30 40 50
| Before | [10][20][30][40][50][ ][ ][ ][ ][ ] |
| Step 1 | Shift right from end |
| Step 2 | Place value |
Deletion from an Array
To delete an element, shift subsequent elements to fill the gap:
Example
#include <stdio.h>
int deleteElement(int arr[], int *size, int pos) {
if (pos < 0 || pos >= *size) {
printf("Invalid position!\n");
return 0;
}
// Shift elements to the left
for (int i = pos; i < *size - 1; i++) {
arr[i] = arr[i + 1];
}
(*size)--;
return 1;
}
int main() {
int arr[] = {10, 20, 30, 40, 50};
int size = 5;
printf("Before deletion: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
deleteElement(arr, &size, 2); // Delete element at index 2
printf("\nAfter deleting index 2: ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\n");
return 0;
}
Output
Before deletion: 10 20 30 40 50 After deleting index 2: 10 20 40 50
Operation Complexity Summary
| Operation | Time Complexity | Notes |
|---|---|---|
| Access by index | O(1) | Direct address calculation |
| Linear search | O(n) | Must check each element |
| Binary search | O(log n) | Requires sorted array |
| Insertion at end | O(1) | No shifting needed |
| Insertion at position | O(n) | Shift elements right |
| Deletion at end | O(1) | Just decrease size |
| Deletion at position | O(n) | Shift elements left |
| Bubble/Selection sort | O(n²) | Simple but slow |
Interview Questions
Q1: When is linear search preferred over binary search?
Linear search is preferred when: the array is unsorted, the array is very small (overhead of sorting outweighs benefit), you're searching only once, or the data structure doesn't support random access.
Q2: Why do we use mid = low + (high - low) / 2 instead of mid = (low + high) / 2?
To prevent integer overflow. If low and high are both large values near INT_MAX, their sum can overflow. The subtraction form avoids this by first computing the difference.
Q3: What is the best-case time complexity of bubble sort with the optimization flag?
O(n) — if the array is already sorted, the inner loop makes one pass without any swaps, the swapped flag remains 0, and the algorithm exits early.
Q4: How would you delete all occurrences of a value from an array?
Use a two-pointer technique: one pointer reads each element, the other writes only non-matching elements. This achieves O(n) time with O(1) extra space.
Summary
- Linear search is simple O(n); binary search is O(log n) but requires sorted data
- Bubble, selection, and insertion sorts are O(n²) but easy to implement
- Array insertion requires shifting elements right — O(n) worst case
- Array deletion requires shifting elements left — O(n) worst case
- Always pass array capacity to prevent buffer overflow during insertion
- Binary search uses the divide-and-conquer strategy for efficient lookup
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Array Operations in C - Searching, Sorting, Insert and Delete.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, arrays, array, operations, array operations in c - searching, sorting, insert and delete
Related C Programming Topics
Continue learning this concept
ArraysArray Programs in C - Reverse, Rotate, Duplicates, MergePractice essential array programs in C including reversing arrays, rotating elements, finding duplicates, merging sorted arrays, and more coding problems with solutions.ArraysIntroduction to Arrays in C ProgrammingLearn what arrays are in C, why we need them, how to declare and initialize arrays, and understand memory layout with practical examples.ArraysMultidimensional Arrays in C ProgrammingLearn about multidimensional arrays (3D and beyond) in C programming with practical examples, memory layout explanations, and real-world use cases.ArraysOne Dimensional Arrays in C ProgrammingMaster one-dimensional arrays in C with detailed examples covering declaration, initialization, traversal, input/output operations, and common array algorithms.ArraysPassing Arrays to Functions in CUnderstand how arrays are passed to functions in C, array decay to pointers, why size information is lost, and best practices for writing array-handling functions.ArraysTwo Dimensional Arrays in C ProgrammingComplete guide to 2D arrays in C including declaration, initialization, matrix operations, row-column access patterns, and practical examples with memory diagrams.