Array ADT

Pasted image 20231214184822.png

#include <iostream>
using namespace std;

struct Array
{
    int *A;
    int size;
    int length;
};

void Display(struct Array arr2)
{
    for (int i = 0; i < arr2.length; i++)
        cout << arr2.A[i];
}

int main()
{
    struct Array arr;
    arr.size = 10;
    arr.A = new int[arr.size];
    arr.length = 4;

    for (int i = 0; i < arr.length; i++)
    {
        cin >> arr.A[i];
    }
    Display(arr);

    return 0;
}

1. Display :

Pasted image 20231214194130.png

2. Array :

Pasted image 20231214194511.png

3. Insert (index, x) :

Pasted image 20231214195145.png

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display (struct Array arr)
{
    for (int i=0; i<arr.length; i++)
        printf("%d ", arr.A[i]);
}

void Append(struct Array *arr, int x)
{
    if (arr->size > arr->length)
        arr->A[arr->length++] = x;
}

void Insert(struct Array *arr, int index, int x)
{
    if (index < arr->length && index >=0)
    {
        for(int i = arr->length; i>index; i--)
            arr->A[i] = arr->A[i-1];

        arr->A[index] =  x;
        arr->length++;
    }
}

int main()
{
    struct Array arr1 = {{2, 3, 4, 5, 6}, 10, 5};
    Append(&arr1, 10);
    Insert(&arr1, 0, 12);
    Display(arr1);
    return 0;
}

4. Delete (index) :

Pasted image 20231214222105.png

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for (int i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
    cout << endl;
}

void Append(struct Array *arr, int x)
{
    if (arr->size > arr->length)
        arr->A[arr->length++] = x;
}

void Insert(struct Array *arr, int index, int x)
{
    if (index < arr->length && index >= 0)
    {
        for (int i = arr->length; i > index; i--)
            arr->A[i] = arr->A[i - 1];

        arr->A[index] = x;
        arr->length++;
    }
}

void Delete(struct Array *arr, int index)
{
    if (index < arr->length && index >= 0)
    {
        for (int i =index; i < arr->length -1; i++)
            arr->A[i]=arr->A[i+1];
        arr->length--;
    }
}

int main()
{
    struct Array arr1 = {{2, 3, 4, 5, 6}, 10, 5};
    Append(&arr1, 10);
    Insert(&arr1, 0, 12);
        Display(arr1);
    Delete(&arr1, 1);
        Display(arr1);
    return 0;
}

5. Search :

Linear Search :

All the elements must be unique here
The value you are searching is called key, In linear search we search the key element one by one linearly
We search the element by comparing it with the key value

1. Transposition Method of Linear Searching :
Basically Jo item search me find ho jayega usko ham ek position pehle khiska denge. Therefore jo item ham "baar baar" search karege wo array me upar aa jayega and jaldi catch ho jayega.
Pasted image 20231214230835.png

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for (int i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
    cout << endl;
}

int Search(struct Array *arr, int x)
{
    for(int i =0; i<arr->length; i++)
    {
        if (x == arr->A[i])
        {
            swap(arr->A[i], arr->A[i-1]);
            return i-1;
        }
    }
    return -1;
}

int main()
{
    struct Array arr1 = {{2, 3, 4, 5, 6}, 10, 5};

    cout << Search(&arr1, 4) << endl;
    
    Display(arr1);
    return 0;
}

2. Move to Head / Front Method of Linear Searching :

Found element ko 0th index (yaani sabse aage) pe bhej denge.
Pasted image 20231214231252.png
Here found item to first position pe aa jayega but we wouldn't know where the element at 0th index will be thrown to. Which is a draw back.

Binary Search :

Sorted Array hona zaruri hai bhai.
Pasted image 20231215001829.png

Using Loop:

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for (int i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
    cout << endl;
}

int binarySearch(struct Array arr, int key)
{
    int l = 0;
    int h = arr.length - 1;
    int mid;
    while (l <= h)
    {
        mid = (l + h) / 2;
        if (key == arr.A[mid])
            return mid;
        else if (key < arr.A[mid])
            h = mid - 1;
        else
            l = mid + 1;
    }
    return -1;
}

int main()
{
    struct Array arr1 = {{1, 2, 3, 4, 5, 6, 7, 8, 9}, 10, 9};

    cout << binarySearch(arr1, 4) << endl;

    Display(arr1);
    return 0;
}

Using Recursion :

6. Get(index) :

to get an element at an index in an array
Pasted image 20231215181730.png

7. Set(index) :

to set an element at a given index in an array
Pasted image 20231215182709.png

8. Max() :

Pasted image 20231215182858.png

9. Min():

Same concept as Max().

10. Sum() :

Pasted image 20231215183839.png
Recursive Approach :
Pasted image 20231215184229.png

11. Average() :

Pasted image 20231215185444.png

12. Reverse :

Method 1 :

Ek array se dusre array me copy kardo ulta karke and then copy elements of 2nd array back to the first array.
Pasted image 20231215194212.png

Method 2 :

Swap kardo elements ko :
Pasted image 20231215194520.png

#include<iostream>
using namespace std;

void reverse(int arr[], int n)
{
    int temp;
    for (int i=0, j=n-1; i < j; i++, j--)
    {
        temp = arr[i];
        arr[i] = arr[j];
        arr[j]=temp;
    }
}

int main()
{

    int a[]={1,2,3,4,5};
    reverse(a, 5);
    
    for (int i = 0; i<5; i++)
        cout << a[i];

    return 0;
}

13. Left Shift / Rotate :

Shift :

Left side shift kardo (we'll lose the first element tho), last me zero aa jayega.

Rotation :

Jo element delete/lose hua hai usko laast me daal dege.

Pasted image 20231215195033.png

12. Inserting in a Sorted Array :

Pasted image 20231215213812.png

#include<iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for ( int i =0; i< arr.length; i++)
        printf("%d ", arr.A[i]);
}

void insertSorted(struct Array *arr, int x)
{
    int i = arr->length-1;
    while (x < arr->A[i])
    {
        arr->A[i+1] = arr->A[i];
        i--;
    }
    arr->A[i+1] = x;
    arr->length++;
}

int main()
{

    struct Array arr1 = {{1,2,3,4,5,7,8}, 10, 7};
    insertSorted(&arr1, 6);
    Display(arr1);
    return 0;
}

13. Check if a list is sorted or not :

Pasted image 20231215221646.png

#include<iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for ( int i =0; i< arr.length; i++)
        printf("%d ", arr.A[i]);
}

int isSorted(struct Array arr)
{
    for (int i = 0; i< arr.length-1; i++)
    {
        if (arr.A[i] > arr.A[i+1])
            return 0; //false
    }
    return 1; // true i.e sorted hai array
}

int main()
{

    struct Array arr1 = {{1,2,3,4,5,6,7}, 10, 7};
    cout << isSorted(arr1);
    Display(arr1);
    return 0;
}

14. Negative then Positive Elements :

Pasted image 20231215222121.png

#include<iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for ( int i =0; i< arr.length; i++)
        printf("%d ", arr.A[i]);
}

void rearrange(struct Array *arr)
{
    int i=0, j=arr->length-1;
    while (i<j)
    {
        while(arr->A[i]<0) {i++;}
        while(arr->A[j]>=0) {j--;}
        if(i<j)
        {
            swap(arr->A[i], arr->A[j]);  
        }
    }
}

int main()
{

    struct Array arr1 = {{-1,2,-3,4,5,-7,8}, 10, 7};
    rearrange(&arr1);
    Display(arr1);
    return 0;
}

Merging Arrays :

Pasted image 20231215232812.png

Appending : For e.g. first array me 2nd array jod di.
Concat : For e.g. first and 2nd array ko combine karke 3rd array banadi.

Merging :

Merging can only be done when both arrays are sorted and we NEED a 3rd array as well.
Pasted image 20231215234117.png

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for (int i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
}

struct Array *merge(struct Array *arr1, struct Array *arr2)
{
    int i, j, k;
    i = j = k = 0;

    // creating a struct in heap
    struct Array *arr3 = new struct Array;
    //or
    // struct Array *arr3 = (struct Array *)malloc(sizeof(struct Array));

    while (i < arr1->length && j < arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            arr3->A[k++] = arr1->A[i++];
        else
            arr3->A[k++] = arr2->A[j++];
    }
    for (; i < arr1->length; i++)
        arr3->A[k++] = arr1->A[i];
    for (; j < arr2->length; j++)
        arr3->A[k++] = arr2->A[j];
    arr3->length = arr1->length + arr2->length;
    arr3->size = 10;

    return arr3;
}

int main()
{

    struct Array arr1 = {{2, 6, 10, 15, 25}, 10, 5};
    struct Array arr2 = {{3, 4, 7, 18, 20}, 10, 5};
    struct Array *arr3;
    arr3 = merge(&arr1, &arr2);
    Display(*arr3);
    return 0;
}

Set Operators :

Union :

Unsorted vs Sorted List :
Pasted image 20231216163708.png

In sorted list we are essentially using merge process : The only difference is that if the elements are same then we'll copy only once and do i++ and j++.

Intersection :

We'll check if an element in the 1st array is present in the 2nd array then copy that element to the third array.
Unsorted vs Sorted :
Pasted image 20231216170529.png

Difference :

Pasted image 20231216170739.png

/* ------------------ for sorted array ------------------ */

#include <iostream>
using namespace std;

struct Array
{
    int A[10];
    int size;
    int length;
};

void Display(struct Array arr)
{
    for (int i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
    printf("\n");
}

struct Array *Union (struct Array *arr1, struct Array *arr2)
{
    int i,j,k;
    i=j=k=0;
    struct Array *arrX = new struct Array;

    while(i<arr1->length && j <arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            arrX->A[k++] = arr1->A[i++];
        else if (arr1->A[i] > arr2->A[j])
            arrX->A[k++] = arr2->A[j++];
        else
        {
            arrX->A[k++] = arr1->A[i++];
            j++;
        }
    }
    for(; i<arr1->length ; i++)
        arrX->A[k++] = arr1->A[i];
    for(; j<arr2->length; j++)
        arrX->A[k++] = arr2->A[j];
    arrX->length = k;
    arrX->size = 10;
    return arrX;
}

struct Array * Intersection (struct Array *arr1, struct Array *arr2)
{
    struct Array *arrX = new struct Array;

    int i,j,k;
    i=j=k=0;

    while (i<arr1->length && j < arr2->length)
    {
        if(arr1->A[i] < arr2->A[j])
            i++;
        else if (arr1->A[i] > arr2->A[j])
            j++;
        else if (arr1->A[i] == arr2->A[j])
        {
            arrX->A[k++] = arr2->A[i++];
            j++;
        }
    }
    arrX->length = k;
    arrX->size = 10;
    return arrX;
}

struct Array * Difference (struct Array *arr1, struct Array *arr2)
{
    int i,j,k;
    i=j=k=0;
    struct Array * arrX = new struct Array;

    while (i < arr1->length && j < arr2->length)
    {
        if ( arr1->A[i] < arr2->A[j])
            arrX->A[k++] = arr1->A[i++];
        else if (arr1->A[i] > arr2->A[j])
            j++;
        else 
        {
            i++;
            j++;
        }
    }
    for (; i<arr1->length; i++)
        arrX->A[k++] = arr1->A[i];
    arrX->length = k;
    arrX->size = 10;
    return arrX;
}

int main()
{
    struct Array arr1 = {{2, 9, 21, 28, 35}, 10, 5};
    struct Array arr2 = {{2, 3, 9, 18, 28}, 10, 5};
    struct Array *arr3;
    arr3 = Union(&arr1, &arr2);
    Display(*arr3);
    arr3 = Intersection(&arr1, &arr2);
    Display(*arr3);
    arr3 = Difference(&arr1, &arr2);
    Display(*arr3);
}

Menu driven program in C :

#include <stdio.h>
#include <stdlib.h>
struct Array
{
    int *A;
    int size;
    int length;
};


void Display(struct Array arr)
{
    int i;
    printf("\nElements are\n");
    for (i = 0; i < arr.length; i++)
        printf("%d ", arr.A[i]);
}
void Append(struct Array *arr, int x)
{
    if (arr->length < arr->size)
        arr->A[arr->length++] = x;
}
void Insert(struct Array *arr, int index, int x)
{
    int i;
    if (index >= 0 && index <= arr->length)
    {
        for (i = arr->length; i > index; i--)
            arr->A[i] = arr->A[i - 1];
        arr->A[index] = x;
        arr->length++;
    }
}
int Delete(struct Array *arr, int index)
{
    int x = 0;
    int i;
    if (index >= 0 && index < arr->length)
    {
        x = arr->A[index];
        for (i = index; i < arr->length - 1; i++)
            arr->A[i] = arr->A[i + 1];
        arr->length--;
        return x;
    }
    return 0;
}
void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}
int LinearSearch(struct Array *arr, int key)
{
    int i;
    for (i = 0; i < arr->length; i++)
    {
        if (key == arr->A[i])
        {
            swap(&arr->A[i], &arr->A[0]);
            return i;
        }
    }
    return -1;
}
int BinarySearch(struct Array arr, int key)
{
    int l, mid, h;
    l = 0;
    h = arr.length - 1;
    while (l <= h)
    {
        mid = (l + h) / 2;
        if (key == arr.A[mid])
            return mid;
        else if (key < arr.A[mid])
            h = mid - 1;
        else
            l = mid + 1;
    }
    return -1;
}
int RBinSearch(int a[], int l, int h, int key)
{
    int mid;
    if (l <= h)
    {
        mid = (l + h) / 2;
        if (key == a[mid])
            return mid;
        else if (key < a[mid])
            return RBinSearch(a, l, mid - 1, key);
        else
            return RBinSearch(a, mid + 1, h, key);
    }
    return -1;
}
int Get(struct Array arr, int index)
{
    if (index >= 0 && index < arr.length)
        return arr.A[index];
    return -1;
}
void Set(struct Array *arr, int index, int x)
{
    if (index >= 0 && index < arr->length)
        arr->A[index] = x;
}
int Max(struct Array arr)
{
    int max = arr.A[0];
    int i;
    for (i = 1; i < arr.length; i++)
    {
        if (arr.A[i] > max)
            max = arr.A[i];
    }
    return max;
}
int Min(struct Array arr)
{
    int min = arr.A[0];
    int i;
    for (i = 1; i < arr.length; i++)
    {
        if (arr.A[i] < min)
            min = arr.A[i];
    }
    return min;
}
int Sum(struct Array arr)
{
    int s = 0;
    int i;
    for (i = 0; i < arr.length; i++)
        s += arr.A[i];
    return s;
}
float Avg(struct Array arr)
{
    return (float)Sum(arr) / arr.length;
}
void Reverse(struct Array *arr)
{
    int *B;
    int i, j;
    B = (int *)malloc(arr->length * sizeof(int));
    for (i = arr->length - 1, j = 0; i >= 0; i--, j++)
        B[j] = arr->A[i];
    for (i = 0; i < arr->length; i++)
        arr->A[i] = B[i];
}
void Reverse2(struct Array *arr)
{
    int i, j;
    for (i = 0, j = arr->length - 1; i < j; i++, j--)
    {
        swap(&arr->A[i], &arr->A[j]);
    }
}
void InsertSort(struct Array *arr, int x)
{
    int i = arr->length - 1;
    if (arr->length == arr->size)
        return;
    while (i >= 0 && arr->A[i] > x)
    {
        arr->A[i + 1] = arr->A[i];
        i--;
    }
    arr->A[i + 1] = x;
    arr->length++;
}
int isSorted(struct Array arr)
{
    int i;
    for (i = 0; i < arr.length - 1; i++)
    {
        if (arr.A[i] > arr.A[i + 1])
            return 0;
    }
    return 1;
}
void Rearrange(struct Array *arr)
{
    int i, j;
    i = 0;
    j = arr->length - 1;
    while (i < j)
    {
        while (arr->A[i] < 0)
            i++;
        while (arr->A[j] >= 0)
            j--;
        if (i < j)
            swap(&arr->A[i], &arr->A[j]);
    }
}
struct Array *Merge(struct Array *arr1, struct Array
                                            *arr2)
{
    int i, j, k;
    i = j = k = 0;
    struct Array *arr3 = (struct Array
                              *)malloc(sizeof(struct Array));
    while (i < arr1->length && j < arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            arr3->A[k++] = arr1->A[i++];
        else
            arr3->A[k++] = arr2->A[j++];
    }
    for (; i < arr1->length; i++)
        arr3->A[k++] = arr1->A[i];
    for (; j < arr2->length; j++)
        arr3->A[k++] = arr2->A[j];
    arr3->length = arr1->length + arr2->length;
    arr3->size = 10;
    return arr3;
}
struct Array *Union(struct Array *arr1, struct Array
                                            *arr2)
{
    int i, j, k;
    i = j = k = 0;
    struct Array *arr3 = (struct Array
                              *)malloc(sizeof(struct Array));
    while (i < arr1->length && j < arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            arr3->A[k++] = arr1->A[i++];
        else if (arr2->A[j] < arr1->A[i])
            arr3->A[k++] = arr2->A[j++];
        else
        {
            arr3->A[k++] = arr1->A[i++];
            j++;
        }
    }
    for (; i < arr1->length; i++)
        arr3->A[k++] = arr1->A[i];
    for (; j < arr2->length; j++)
        arr3->A[k++] = arr2->A[j];
    arr3->length = k;
    arr3->size = 10;
    return arr3;
}
struct Array *Intersection(struct Array *arr1, struct
                           Array *arr2)
{
    int i, j, k;
    i = j = k = 0;
    struct Array *arr3 = (struct Array
                              *)malloc(sizeof(struct Array));
    while (i < arr1->length && j < arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            i++;
        else if (arr2->A[j] < arr1->A[i])
            j++;
        else if (arr1->A[i] == arr2->A[j])
        {
            arr3->A[k++] = arr1->A[i++];
            j++;
        }
    }
    arr3->length = k;
    arr3->size = 10;
    return arr3;
}
struct Array *Difference(struct Array *arr1, struct
                         Array *arr2)
{
    int i, j, k;
    i = j = k = 0;
    struct Array *arr3 = (struct Array
                              *)malloc(sizeof(struct Array));
    while (i < arr1->length && j < arr2->length)
    {
        if (arr1->A[i] < arr2->A[j])
            arr3->A[k++] = arr1->A[i++];
        else if (arr2->A[j] < arr1->A[i])
            j++;
        else
        {
            i++;
            j++;
        }
    }
    for (; i < arr1->length; i++)
        arr3->A[k++] = arr1->A[i];
    arr3->length = k;
    arr3->size = 10;
    return arr3;
}
int main()
{
    struct Array arr1;
    int ch;
    int x, index;
    printf("Enter Size of Array");
    scanf("%d", &arr1.size);
    arr1.A = (int *)malloc(arr1.size * sizeof(int));
    arr1.length = 0;
    do
    {
        printf("\n\nMenu\n");
        printf("1. Insert\n");
        printf("2. Delete\n");
        printf("3. Search\n");
        printf("4. Sum\n");
        printf("5. Display\n");
        printf("6.Exit\n");
        printf("enter you choice ");
        scanf("%d", &ch);
        switch (ch)
        {
        case 1: printf("Enter an element and index");
scanf("%d%d",&x,&index);
Insert(&arr1,index,x);
break;
case 2: printf("Enter index ");
scanf("%d",&index);
x=Delete(&arr1,index);
printf("Deleted Element is %d\n",x);
break;
case 3:printf("Enter element to search ");
scanf("%d",&x);
index=LinearSearch(&arr1,x);
printf("Element index %d",index);
break;
case 4:printf("Sum is %d\n",Sum(arr1));
break;
case 5:Display(arr1);
        }
    } while (ch < 6);
    return 0;
}

Menu Driven Program in C++ :

skipped

Finding Missing Elements :

Sorted Array :

Method 1: Elements are first "n" natural numbers :

Pasted image 20231216195358.png '

Here n = 12
Basically expected sum - sum of all elements in the array = missing element

Method 2 : Not first "n" natural numbers

Pasted image 20231216212913.png

Method 3 : Multiple Missing Elements :

Pasted image 20231216213446.png

Unsorted Array :

What to do for each element?
First element is three.
Go to index three and increment it.
Make it as one.
So it was zero, just make it as one.
Then next, seven, go to index seven and make it as one.
Increment it.
Four, go to index and then increment it.
Nine, go to index nine and increment it.
Go to index 12 and increment it.
and so on...
Pasted image 20231216214202.png
This is a faster method.
This is a simple implementation of Hash Table.
In the previous method the time complexity was O(n²) whereas here it is only O(n).
Pasted image 20231216214538.png

Finding Duplicate Elements in a List :

Finding Duplicates in a Sorted List :

Pasted image 20231216220241.png

#include<iostream>
using namespace std;

void Duplicate (int arr[], int length)
{
    int lastDuplicate=0;
    for (int i=0; i< length;i++)
    {
        if (arr[i] == arr[i+1] && arr[i]!=lastDuplicate)
        {
            printf("%d ", arr[i]);
            lastDuplicate = arr[i];
        }
    }
}

int main()
{

    int arr[] = {3,6,8,8,10,12,15,15,15,20};
    int length = 10;
    Duplicate(arr, length);

    return 0;
}

How to count the number of duplicates :

Pasted image 20231216221752.png

#include<iostream>
using namespace std;

void countDuplicate (int arr[], int length)
{
    int j;
    for(int i=0; i<length-1; i++)
    {
        if(arr[i] == arr[i+1])
        {
            j=i+1;
            while(arr[j]==arr[i]) {j++;}
            printf("%d : %d times\n", arr[i], j-i);
            i=j-1;
        }

    }
}

int main()
{

    int arr[] = {3,6,8,8,10,12,15,15,15,20};
    int length = 10;
    countDuplicate(arr, length);

    return 0;
}

Using Hash table :

Pasted image 20231216222933.png

#include<iostream>
using namespace std;

void countDuplicateHash (int arr[], int length, int largest)
{
    int h[largest+1] ={0};
    for (int i=0; i<length; i++)
    {
        h[arr[i]]++;
    }
    for (int i=0;i<largest+1;i++)
    {
        if(h[i] > 1)
        {
            printf("%d : %d times\n", i, h[i]);
        }
    }
}

int main()
{

    int arr[] = {3,6,8,8,10,12,15,15,15,20};
    int length = 10;
    countDuplicateHash(arr, length, 20);

    return 0;
}

Finding Duplicate Elements in an unsorted list :

Pasted image 20231216230232.png

#include<iostream>
using namespace std;

void countNum(int arr[], int length)
{
    int count;
    for (int i=0; i<length; i++)
    {
        count = 1;
        if(arr[i] != -1)
        {
            for (int j=i+1; j<length; j++)
            {
                if (arr[i] == arr[j])
                {
                    count++;
                    arr[j] = -1;
                }
            }
            if (count > 1) printf("%d : %d times\n", arr[i], count);
        }
    }
}

int main()
{
    int arr[] = {8,3,6,4,6,5,6,8,2,7};
    int length = 10;
    countNum(arr, length);

    return 0;
}

Using Hash Table / Bitmap :

#include <iostream>
using namespace std;

void countDuplicateHash(int arr[], int length, int largest)
{
    int h[largest + 1] = {0};
    for (int i = 0; i < length; i++)
    {
        h[arr[i]]++;
    }
    for (int i = 0; i < largest + 1; i++)
    {
        if (h[i] > 1)
        {
            printf("%d : %d times\n", i, h[i]);
        }
    }
}

int main()
{

    int arr[] = {3, 6, 8, 8, 10, 12, 15, 15, 20, 20};
    int length = 10;
    countDuplicateHash(arr, length, 20);

    return 0;
}

Finding a Pair of Elements with sum K :

Unsorted Array :

Pasted image 20231217000614.png

Using Hash table :

Pasted image 20231217002452.png

Sorted Array :

Using while loop :

Pasted image 20231217112226.png

Using while loop :

Pasted image 20231217112346.png