सरणियों (Arrays)

जावा में सारणियों की प्रकृति:

An Array हीप पर सन्निहित मेमोरी ब्लॉक में आवंटित समान डेटा प्रकार (सजातीय) के तत्वों का एक अनुक्रमित संग्रह है। जावा में, ऐरे वास्तविक ऑब्जेक्ट हैं, जिन्हें new ऑपरेटर का उपयोग करके त्वरित किया जाता है।

सरणी निर्माण के तीन चरण:

1. घोषणा: int[] arr; (स्टैक पर एक संदर्भ चर बनाता है; वर्तमान में null).
2. तात्कालिकता: arr = नया int[5]; (0 में प्रारंभ किए गए 5 पूर्णांकों के लिए सन्निहित हीप मेमोरी आवंटित करता है)।
3. प्रारंभीकरण: मूल्यों को व्यक्तिगत रूप से पॉप्युलेट करना (arr[0] = 10;) या इनलाइन सरणी शाब्दिक के माध्यम से (int[] arr = {10, 20, 30, 40, 50};).

अनुक्रमिक स्कैनिंग तर्क:

रैखिक खोज सूचकांक $0$ से $N - 1$ तक सरणी में प्रत्येक तत्व के विरुद्ध लक्ष्य खोज कुंजी की क्रमिक रूप से तुलना करता है। इसके लिए किसी पूर्व शर्त की आवश्यकता नहीं है (सरणी को पूरी तरह से अवर्गीकृत किया जा सकता है)।

पब्लिक स्टेटिक इंट लीनियर सर्च(इंट[] एआरआर, इंट कुंजी) {
    के लिए (int i = 0; i < arr.length; i++) {
        if (arr[i] == key) {
            return i; // Target found at index i!
        }
    }
    return -1; // Target not present in array
}

एल्गोरिदमिक जटिलता:

• सर्वश्रेष्ठ मामला: $O(1)$ (पहली तुलना में कुंजी सूचकांक 0 पर मिली)।
• सबसे खराब मामला: $O(n)$ (कुंजी अंतिम सूचकांक पर स्थित है या सरणी से अनुपस्थित है)।

विभाजित डेटा पर फूट डालो और जीतो खोज:

बाइनरी सर्च एक असाधारण तेज़ खोज एल्गोरिदम है जो मौलिक पूर्व शर्त पर काम करता है कि सरणी जरूर क्रमबद्ध होना चाहिए (या तो आरोही या अवरोही क्रम में)। प्रत्येक पुनरावृत्ति में, यह लक्ष्य कुंजी की तुलना मध्य तत्व ($mid = (low + high) / 2$):

• यदि कुंजी == गिरफ्तार[मध्य]: खोज सफलतापूर्वक समाप्त हो गई।
• यदि कुंजी < गिरफ्तारी[मध्य]: खोज स्थान बाएं आधे भाग तक सीमित है (उच्च = मध्य - 1).
• यदि कुंजी > गिरफ्तारी[मध्य]: खोज स्थान दाहिने आधे भाग तक सीमित है (निम्न = मध्य + 1).

पब्लिक स्टैटिक इंट बाइनरी सर्च(इंट[] एआरआर, इंट कुंजी) {
    int निम्न = 0, उच्च = arr.length - 1;
    जबकि (कम <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == key) return mid;
        else if (key < arr[mid]) high = mid - 1;
        else low = mid + 1;
    }
    return -1; // Not found
}

दक्षता: समय जटिलता $O(\log_2 n)$ है। $1,000,000$ तत्वों की एक श्रृंखला में, बाइनरी खोज के लिए अधिकतम $20$ तुलनाओं की आवश्यकता होती है, जबकि रैखिक खोज के लिए $1,000,000$ तक की आवश्यकता होती है!

बबल सॉर्ट सिद्धांत:

बबल सॉर्ट में, सरणी को कई बार ट्रैवर्स किया जाता है। प्रत्येक पास में, आसन्न तत्वों की तुलना की जाती है ($arr[j]$ और $arr[j+1]$); यदि वे क्रम से बाहर हैं ($arr[j] > arr[j+1]$), तो उनकी अदला-बदली कर दी जाती है। परिणामस्वरूप, अवर्गीकृत खंड में सबसे बड़ा तत्व सरणी के अंत में अपनी अंतिम स्थिति में "बुलबुला" उठता है।

सार्वजनिक स्थैतिक शून्य बबलसॉर्ट(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {           // Outer loop: n - 1 passes
        for (int j = 0; j < n - 1 - i; j++) {   // Inner loop: comparisons
            if (arr[j] > arr[j + 1]) {
                //आसन्न तत्वों को स्वैप करें
                int temp = arr[j];
                गिरफ्तारी[जे] = गिरफ्तारी[जे + 1];
                गिरफ्तारी[जे + 1] = तापमान;
            }
        }
    }
}

चयन क्रमबद्ध सिद्धांत:

Selection Sort में, एल्गोरिदम सरणी को एक क्रमबद्ध उपसर्ग और एक अवर्गीकृत प्रत्यय में विभाजित करता है। प्रत्येक पास $i$ में, यह न्यूनतम तत्व के सूचकांक को खोजने के लिए अवर्गीकृत खंड को स्कैन करता है और इसे स्थिति $i$.

सार्वजनिक स्थैतिक शून्य चयनसॉर्ट(int[] गिरफ्तार) {
    int n = arr.length;
    के लिए (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // Update index of minimum
            }
        }
        // Swap minimum element with element at index i
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

जावा में मैट्रिक्स संरचना:

A 2D सरणी, $M$ पंक्तियों और $N$ स्तंभों के साथ एक ग्रिड का प्रतिनिधित्व करने वाली सरणियों की एक सरणी है:

int[][] मैट्रिक्स = नया int[4][4]; // 4x4 मैट्रिक्स

वर्ग मैट्रिक्स के लिए ज्यामितीय सूचकांक सूत्र ($N \times N$):

मॉडल प्रोग्राम 1: 15 छात्रों के अंकों पर इनपुट, बबल सॉर्ट और बाइनरी सर्च

आयात java.util.Scanner;

पब्लिक क्लास स्टूडेंटमार्क्सअरे {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर एससी = नया स्कैनर (System.in);
        int[] अंक = नया int[15];

        System.out.println ("15 छात्रों के लिए अंक दर्ज करें:");
        (int i = 0; i < marks.length; i++) {
            System.out.print("Student " + (i + 1) + ": ");
            marks[i] = sc.nextInt();
        }

        // 1. Sort using Bubble Sort
        for (int i = 0; i < marks.length - 1; i++) {
            for (int j = 0; j < marks.length - 1 - i; j++) {
                if (marks[j] > अंक[j + 1]) के लिए {
                    पूर्णांक अस्थायी = अंक[जे];
                    अंक[जे] = अंक[जे + 1];
                    मार्क्स[जे + 1] = तापमान;
                }
            }
        }

        System.out.println("
क्रमबद्ध अंक (आरोही क्रम):");
        (int m : मार्क्स) के लिए {
            System.out.print(m + " ");
        }
        System.out.println();

        // 2. बाइनरी सर्च का उपयोग करके खोजें
        System.out.print("
खोजने के लिए चिह्न दर्ज करें: ");
        int searchKey = sc.nextInt();

        पूर्णांक निम्न = 0, उच्च = अंक.लंबाई - 1, फाउंडइंडेक्स = -1;
        जबकि (कम <= high) {
            int mid = (low + high) / 2;
            if (marks[mid] == searchKey) {
                foundIndex = mid;
                break;
            } else if (searchKey < marks[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        if (foundIndex != -1) {
            System.out.println("Search Successful! Mark " + searchKey + " found at sorted position " + (foundIndex + 1));
        } else {
            System.out.println("Search Unsuccessful: Mark " + searchKey + " is not present.");
        }
    }
}

मॉडल प्रोग्राम 2: 4x4 मैट्रिक्स विकर्ण सारांश और ट्रांसपोज़ डिस्प्ले

आयात java.util.Scanner;

सार्वजनिक वर्ग मैट्रिक्स विश्लेषण {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        int[][] a = नया int[4][4];

        System.out.println('4x4 मैट्रिक्स के लिए तत्व दर्ज करें:');
        के लिए (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                a[i][j] = in.nextInt();
            }
        }

        int leftDiagonalSum = 0;
        int rightDiagonalSum = 0;

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (i == j) leftDiagonalSum += a[i][j];
                if (i + j == 3) rightDiagonalSum += a[i][j];
            }
        }

        System.out.println("
Original Matrix:");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(a[i][j] + "	");
            }
            System.out.println();
        }

        System.out.println("
Left Diagonal Sum : " + leftDiagonalSum);
        System.out.println("Right Diagonal Sum: " + rightDiagonalSum);

        System.out.println("
Transpose of Matrix (Rows swapped with Columns):");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(a[j][i] + "	"); // Row-column transposed!
            }
            System.out.println();
        }
    }
}