One-Dimensional Array Operations

Traversal, searching, insertion, deletion and sorting of array elements.

One-Dimensional Array Operations

One-Dimensional Array एक ऐसा array है जिसमें elements को एक single index (एकल सूचकांक) की सहायता से access किया जाता है। C++ में array के elements पर विभिन्न operations जैसे traversal, insertion, deletion, searching, updating और sorting किए जा सकते हैं।

Common Array Operations: Traversal → Insertion → Deletion → Searching → Updating → Sorting

Review of One-Dimensional Array

One-dimensional array में एक ही प्रकार के कई values को contiguous memory locations में store किया जाता है। Array का पहला element index 0 पर होता है और अंतिम element का index size - 1 होता है।

int marks[5] = {75, 80, 65, 90, 85};

इस array में पाँच elements हैं:

Index Value
0 75
1 80
2 65
3 90
4 85

1. Traversal of an Array

Traversal का अर्थ array के प्रत्येक element को एक-एक करके access करना है। Array traversal के लिए सामान्यतः for loop का उपयोग किया जाता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};

    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 30 40 50
याद रखें: Array traversal में index सामान्यतः 0 से size-1 तक चलता है।

2. Reading Array Elements

Array में user से values input लेने के लिए loop का उपयोग किया जा सकता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5];

    cout << "Enter 5 numbers: ";

    for (int i = 0; i < 5; i++)
    {
        cin >> arr[i];
    }

    cout << "Array elements: ";

    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Sample Output:
Enter 5 numbers: 10 20 30 40 50
Array elements: 10 20 30 40 50

3. Updating an Array Element

Updating का अर्थ array के किसी existing element की value को बदलना है। Index की सहायता से किसी specific element को update किया जा सकता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};

    arr[2] = 100;

    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 100 40 50

यहाँ arr[2] की value 30 से बदलकर 100 कर दी गई है।

4. Insertion in an Array

Insertion का अर्थ array में किसी specified position पर नया element जोड़ना है। Static array में नया element जोड़ने के लिए elements को एक position आगे shift करना पड़ सकता है।

उदाहरण के लिए, यदि array है:

10 20 30 40

और 25 को index 2 पर insert करना है, तो 30 और 40 को right side में shift किया जाएगा:

10 20 25 30 40

Program to Insert an Element

#include <iostream>
using namespace std;

int main()
{
    int arr[10] = {10, 20, 30, 40, 50};
    int n = 5;
    int position = 2;
    int value = 25;

    for (int i = n; i > position; i--)
    {
        arr[i] = arr[i - 1];
    }

    arr[position] = value;
    n++;

    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 25 30 40 50

यहाँ position 2 पर 25 insert किया गया है और उसके बाद के elements को एक position right shift किया गया है।

Important: Array में insertion के लिए पर्याप्त space होना आवश्यक है।

5. Deletion from an Array

Deletion का अर्थ array से किसी element को हटाना है। किसी element को delete करने के बाद उसके बाद आने वाले elements को एक position left shift किया जाता है।

उदाहरण के लिए:

10 20 30 40 50

यदि 30 को delete किया जाए, तो result होगा:

10 20 40 50

Program to Delete an Element

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;
    int position = 2;

    for (int i = position; i < n - 1; i++)
    {
        arr[i] = arr[i + 1];
    }

    n--;

    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 40 50

यहाँ index 2 पर मौजूद 30 को हटाया गया और उसके बाद के elements को left shift किया गया।

6. Searching in an Array

Searching का अर्थ array में किसी particular value को ढूँढना है। One-dimensional array में सबसे सरल searching method Linear Search है।

Linear Search

Linear search में array के elements को शुरुआत से एक-एक करके target value से compare किया जाता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 25, 30, 45, 50};
    int key = 30;
    int position = -1;

    for (int i = 0; i < 5; i++)
    {
        if (arr[i] == key)
        {
            position = i;
            break;
        }
    }

    if (position != -1)
        cout << "Element found at index " << position;
    else
        cout << "Element not found";

    return 0;
}
Output:
Element found at index 2
याद रखें: Linear Search में elements को sequentially (क्रम से) check किया जाता है।

7. Finding the Largest Element

Array में सबसे बड़ी value खोजने के लिए पहले element को maximum मानकर बाकी elements से compare किया जा सकता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {25, 80, 45, 90, 60};

    int maximum = arr[0];

    for (int i = 1; i < 5; i++)
    {
        if (arr[i] > maximum)
        {
            maximum = arr[i];
        }
    }

    cout << "Largest element: " << maximum;

    return 0;
}
Output:
Largest element: 90

8. Finding the Smallest Element

इसी प्रकार array में smallest element भी खोजा जा सकता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {25, 80, 45, 10, 60};

    int minimum = arr[0];

    for (int i = 1; i < 5; i++)
    {
        if (arr[i] < minimum)
        {
            minimum = arr[i];
        }
    }

    cout << "Smallest element: " << minimum;

    return 0;
}
Output:
Smallest element: 10

9. Calculating Sum of Array Elements

Array के सभी elements का sum निकालने के लिए एक variable में values को लगातार add किया जा सकता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int sum = 0;

    for (int i = 0; i < 5; i++)
    {
        sum += arr[i];
    }

    cout << "Sum = " << sum;

    return 0;
}
Output:
Sum = 150

10. Calculating Average

Array elements का average निकालने के लिए पहले सभी elements का sum निकाला जाता है और फिर उसे total number of elements से divide किया जाता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int sum = 0;

    for (int i = 0; i < 5; i++)
    {
        sum += arr[i];
    }

    float average = (float)sum / 5;

    cout << "Average = " << average;

    return 0;
}
Output:
Average = 30

11. Counting Even and Odd Elements

Array में even और odd numbers की संख्या जानने के लिए modulus operator % का उपयोग किया जा सकता है। यदि किसी number को 2 से divide करने पर remainder 0 आता है, तो वह even number है।

#include <iostream>
using namespace std;

int main()
{
    int arr[6] = {10, 15, 20, 25, 30, 35};

    int even = 0;
    int odd = 0;

    for (int i = 0; i < 6; i++)
    {
        if (arr[i] % 2 == 0)
            even++;
        else
            odd++;
    }

    cout << "Even elements: " << even << endl;
    cout << "Odd elements: " << odd;

    return 0;
}
Output:
Even elements: 3
Odd elements: 3

12. Reversing an Array

Reversing का अर्थ array के elements का order उलट देना है। उदाहरण के लिए 10, 20, 30, 40 को reverse करने पर 40, 30, 20, 10 प्राप्त होगा।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};

    for (int i = 4; i >= 0; i--)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
50 40 30 20 10

ऊपर के program में original array को modify नहीं किया गया है; elements को reverse order में display किया गया है।

13. Sorting an Array

Sorting का अर्थ elements को किसी particular order में arrange करना है। सामान्यतः array को ascending order या descending order में sort किया जाता है।

Bubble Sort

Bubble Sort एक simple sorting technique है जिसमें adjacent elements की तुलना की जाती है और आवश्यकता होने पर उन्हें swap किया जाता है।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {50, 20, 40, 10, 30};

    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    cout << "Sorted array: ";

    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
Sorted array: 10 20 30 40 50

14. Copying an Array

एक array के elements को दूसरे array में copy किया जा सकता है। इसके लिए loop का उपयोग किया जाता है।

#include <iostream>
using namespace std;

int main()
{
    int arr1[5] = {10, 20, 30, 40, 50};
    int arr2[5];

    for (int i = 0; i < 5; i++)
    {
        arr2[i] = arr1[i];
    }

    cout << "Copied array: ";

    for (int i = 0; i < 5; i++)
    {
        cout << arr2[i] << " ";
    }

    return 0;
}
Output:
Copied array: 10 20 30 40 50

15. Merging Two Arrays

Merging का अर्थ दो arrays के elements को एक नए array में combine करना है।

#include <iostream>
using namespace std;

int main()
{
    int a[3] = {10, 20, 30};
    int b[3] = {40, 50, 60};
    int c[6];

    for (int i = 0; i < 3; i++)
    {
        c[i] = a[i];
    }

    for (int i = 0; i < 3; i++)
    {
        c[i + 3] = b[i];
    }

    cout << "Merged array: ";

    for (int i = 0; i < 6; i++)
    {
        cout << c[i] << " ";
    }

    return 0;
}
Output:
Merged array: 10 20 30 40 50 60

Array Operations Summary

Operation Meaning Common Technique
Traversal सभी elements को access करना Loop
Insertion नया element जोड़ना Elements को right shift करना
Deletion Element हटाना Elements को left shift करना
Searching Element को ढूँढना Linear Search
Updating Existing value बदलना Index का उपयोग
Sorting Elements को order में arrange करना Bubble Sort आदि
Reversing Order को उलटना Reverse traversal
Merging दो arrays को combine करना Copying elements

Time Complexity of Common Array Operations

Array operations की efficiency operation और implementation पर निर्भर करती है। Basic operations के लिए सामान्य time complexity इस प्रकार समझी जा सकती है:

Operation Typical Time Complexity
Access by index O(1)
Traversal O(n)
Linear Search O(n)
Insertion at beginning O(n)
Deletion from beginning O(n)
Bubble Sort O(n²)

यहाँ n array में elements की संख्या को दर्शाता है।

Important Points

  • One-dimensional array में elements को एक index की सहायता से access किया जाता है।
  • Array का पहला index 0 होता है।
  • Traversal में array के प्रत्येक element को access किया जाता है।
  • Insertion में elements को right shift करना पड़ सकता है।
  • Deletion में elements को left shift करना पड़ सकता है।
  • Linear Search में elements को क्रम से check किया जाता है।
  • Updating के लिए element के index का उपयोग किया जा सकता है।
  • Sorting में elements को ascending या descending order में arrange किया जाता है।
  • Bubble Sort में adjacent elements की तुलना करके swapping की जाती है।
  • Array का element index द्वारा direct access किया जा सकता है।
  • Array traversal और searching के लिए loops का व्यापक उपयोग होता है।

Board Focus

Exam के लिए याद रखें:
Traversal → सभी elements को access करना
Insertion → नया element जोड़ना
Deletion → element हटाना
Searching → element ढूँढना
Updating → value बदलना
Sorting → elements को क्रम में arrange करना
Reversing → elements का order उलटना
Merging → दो arrays को combine करना
Linear Search → Sequential searching
Bubble Sort → Adjacent elements की comparison और swapping

Board Important Questions

Very Short Answer Questions

Q1. Array traversal क्या है?

Answer: Array के प्रत्येक element को एक-एक करके access करना array traversal कहलाता है।

Q2. Array का पहला index क्या होता है?

Answer: Array का पहला index 0 होता है।

Q3. Array में insertion क्या है?

Answer: Array में किसी specified position पर नया element जोड़ना insertion कहलाता है।

Q4. Array में deletion क्या है?

Answer: Array से किसी existing element को हटाना deletion कहलाता है।

Q5. Linear Search क्या है?

Answer: Linear Search में array के elements को शुरुआत से एक-एक करके target value से compare किया जाता है।

Q6. Bubble Sort क्या है?

Answer: Bubble Sort एक sorting technique है जिसमें adjacent elements की तुलना करके आवश्यकता के अनुसार उन्हें swap किया जाता है।

Q7. Array में element update करने का क्या अर्थ है?

Answer: Array के किसी existing element की value को बदलना updating कहलाता है।

Short Answer Questions

Q8. Array में insertion और deletion में अंतर बताइए।

Insertion Deletion
नया element जोड़ा जाता है। Existing element हटाया जाता है।
आवश्यकता होने पर elements को right shift किया जाता है। आवश्यकता होने पर elements को left shift किया जाता है।
Array का logical size बढ़ता है। Array का logical size घटता है।

Q9. Linear Search को उदाहरण सहित समझाइए।

Answer: Linear Search एक searching technique है जिसमें array के elements को beginning से sequentially check किया जाता है। Target element मिलने पर उसकी position प्राप्त की जा सकती है।

Q10. Array में sorting का क्या महत्व है?

Answer: Sorting elements को किसी निश्चित order, जैसे ascending या descending order में arrange करती है। Sorted data को पढ़ना और कई operations करना आसान हो जाता है।

Q11. Array में insertion के समय shifting क्यों की जाती है?

Answer: किसी existing element के बीच में नया element रखने के लिए उसके बाद आने वाले elements को एक position आगे shift करना पड़ता है, ताकि नई value के लिए जगह बन सके।

Q12. Array में deletion के समय left shifting क्यों की जाती है?

Answer: किसी element को हटाने के बाद खाली position को भरने के लिए उसके बाद आने वाले elements को एक position left shift किया जाता है।

Long Answer Questions

Q13. One-dimensional array के विभिन्न operations समझाइए।

Answer: One-dimensional array पर traversal, insertion, deletion, searching, updating, sorting, reversing और merging जैसे operations किए जा सकते हैं। Traversal में सभी elements को access किया जाता है। Insertion में नया element जोड़ा जाता है और आवश्यकता होने पर elements को right shift किया जाता है। Deletion में element हटाकर बाद के elements को left shift किया जाता है। Searching में किसी value को खोजा जाता है। Updating में existing value बदली जाती है। Sorting में elements को ascending या descending order में arrange किया जाता है।

Q14. Array में element insert करने का C++ program लिखिए।

#include <iostream>
using namespace std;

int main()
{
    int arr[10] = {10, 20, 30, 40};
    int n = 4;
    int position = 2;
    int value = 25;

    for (int i = n; i > position; i--)
    {
        arr[i] = arr[i - 1];
    }

    arr[position] = value;
    n++;

    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 25 30 40

Q15. Array से element delete करने का C++ program लिखिए।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;
    int position = 1;

    for (int i = position; i < n - 1; i++)
    {
        arr[i] = arr[i + 1];
    }

    n--;

    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 30 40 50

Q16. Linear Search का C++ program लिखिए।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {15, 25, 35, 45, 55};
    int key = 45;
    int position = -1;

    for (int i = 0; i < 5; i++)
    {
        if (arr[i] == key)
        {
            position = i;
            break;
        }
    }

    if (position != -1)
        cout << "Element found at index " << position;
    else
        cout << "Element not found";

    return 0;
}
Output:
Element found at index 3

Q17. Array को ascending order में sort करने का C++ program लिखिए।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {40, 10, 50, 20, 30};

    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    for (int i = 0; i < 5; i++)
    {
        cout << arr[i] << " ";
    }

    return 0;
}
Output:
10 20 30 40 50

Q18. Array में largest और smallest element खोजने का program लिखिए।

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {45, 12, 78, 23, 56};

    int largest = arr[0];
    int smallest = arr[0];

    for (int i = 1; i < 5; i++)
    {
        if (arr[i] > largest)
            largest = arr[i];

        if (arr[i] < smallest)
            smallest = arr[i];
    }

    cout << "Largest: " << largest << endl;
    cout << "Smallest: " << smallest;

    return 0;
}
Output:
Largest: 78
Smallest: 12

Quick Revision

  • Traversal: सभी elements को access करना
  • Insertion: नया element जोड़ना
  • Deletion: element हटाना
  • Searching: element को ढूँढना
  • Updating: existing value बदलना
  • Sorting: elements को order में arrange करना
  • Reversing: elements का order उलटना
  • Merging: दो arrays को combine करना
  • Linear Search: Sequentially elements को check करना
  • Bubble Sort: Adjacent elements को compare और swap करना
One-Line Revision: One-dimensional array में elements को index की सहायता से access किया जाता है और traversal, insertion, deletion, searching, updating, sorting, reversing तथा merging जैसे operations किए जा सकते हैं।

Practice Questions

  1. One-dimensional array क्या है?
  2. Array traversal क्या है?
  3. Array में insertion क्या है?
  4. Array में deletion क्या है?
  5. Array में updating से क्या समझते हैं?
  6. Linear Search क्या है?
  7. Bubble Sort क्या है?
  8. Array में insertion और deletion की प्रक्रिया समझाइए।
  9. Linear Search का program लिखिए।
  10. Array को ascending order में sort करने का program लिखिए।
  11. Array के largest और smallest elements को खोजने का program लिखिए।
  12. Array के elements का sum और average निकालने का program लिखिए।
  13. Array में even और odd elements की संख्या ज्ञात करने का program लिखिए।
  14. Array के elements को reverse order में display करने का program लिखिए।
  15. दो arrays को merge करने का program लिखिए।
Lesson 16 of 37
On This Page