Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Java

जावा प्रोग्राम से एलिमेंट्स को लेक्सिकोग्राफिकल ऑर्डर (डिक्शनरी ऑर्डर) में सॉर्ट करना


इस लेख में हम समझेंगे कि जावा में किसी ऐरे के एलिमेंट्स को लेक्सिकोग्राफिकल ऑर्डर में कैसे सॉर्ट किया जाता है। लेक्सिकोग्राफिकल ऑर्डर डिक्शनरी के वर्णमाला क्रम का सामान्यीकरण है।

नीचे इसका प्रदर्शन दिया गया है:

इनपुट

मान लीजिए हमारा इनपुट है:

Aplha Beta Gamma Delta

आउटपुट

वांछित आउटपुट होगा:

Aplha Beta Delta Gamma

एल्गोरिदम

चरण 1 - प्रारंभ
चरण 2 - तीन पूर्णांक घोषित करें: i, j, array_length
चरण 3 - एक स्ट्रिंग ऐरे घोषित करें
चरण 4 - उपयोगकर्ता से array_length मान दर्ज करने के लिए प्रॉम्प्ट करें / array_length परिभाषित करें
चरण 5 - उपयोगकर्ता से स्ट्रिंग ऐरे के शब्द दर्ज करने के लिए प्रॉम्प्ट करें / स्ट्रिंग ऐरे परिभाषित करें
चरण 6 - मान पढ़ें
चरण 7 - for-लूप चलाएं, स्वैप मेथड का उपयोग करके, compareTo फ़ंक्शन का उपयोग करके शब्दों को व्यवस्थित करें। मान संग्रहीत करें।
चरण 8 - परिणाम प्रदर्शित करें
चरण 9 - रुकें

उदाहरण 1

public class Main {
    public static void main(String[] args) {
        String[] my_input = {"Aplha", "Beta", "Gamma", "Delta"};
        int i, j, array_length;
        array_length = 4;
        System.out.println("स्ट्रिंग का ऐरे परिभाषित है");
        for (i = 0; i < array_length; i++) {
            System.out.println(my_input[i]);
        }
        for (i = 0; i < array_length - 1; ++i) {
            for (j = i + 1; j < array_length; ++j) {
                if (my_input[i].compareTo(my_input[j]) > 0) {
                    String temp = my_input[i];
                    my_input[i] = my_input[j];
                    my_input[j] = temp;
                }
            }
        }
        System.out.println("शब्द लेक्सिकोग्राफिकल ऑर्डर में हैं:");
        for (i = 0; i < 4; i++) {
            System.out.println(my_input[i]);
        }
    }
}

आउटपुट

स्ट्रिंग का ऐरे परिभाषित है
Aplha
Beta
Gamma
Delta
शब्द लेक्सिकोग्राफिकल ऑर्डर में हैं:
Aplha
Beta
Delta
Gamma

उदाहरण 2

import java.io.*;
public class LexicographicalOrder {
    public static void sortData(String my_array[]) {
        for (int i = 0; i < my_array.length; i++) {
            for (int j = i + 1; j < my_array.length; j++) {
                if (my_array[i].compareToIgnoreCase(my_array[j]) < 0) {
                    String my_temp = my_array[i];
                    my_array[i] = my_array[j];
                    my_array[j] = my_temp;
                }
            }
        }
    }
    public static void printData(String my_array[]) {
        for (String my_string : my_array)
            System.out.print(my_string + " ");
        System.out.println();
    }
    public static void main(String[] args) {
        String my_array[] = {"Aplha", "Beta", "Gamma", "Delta"};
        System.out.println("आवश्यक पैकेज आयात किए गए हैं");
        System.out.println("लेक्सिकोग्राफिकल ऑर्डर डेटा है");
        sortData(my_array);
        printData(my_array);
    }
}

आउटपुट

आवश्यक पैकेज आयात किए गए हैं
लेक्सिकोग्राफिकल ऑर्डर डेटा है
Aplha Beta Delta Gamma

  1. - Java प्रोग्राम: कॉम्ब सॉर्ट (Comb Sort)

    Java में कॉम्ब सॉर्ट सूची के अंत में स्थित छोटे मानों को हटा देता है और इनवर्जन को एक-एक करके हटा दिया जाता है। आइए एक उदाहरण देखें:उदाहरण 1){ len_gap = (int)(len_gap / shrink_val); } swap = false; for (int i = 0; len_gap + i nums[i + len_gap]){ swap(nums, i, i + len_gap); swap = true; } } } } priv

  1. - काउंटिंग सॉर्ट के लिए जावा प्रोग्राम

    काउंटिंग सॉर्ट विशिष्ट कुंजी मानों वाली वस्तुओं की संख्या गिनता है। आइए एक उदाहरण देखें: नोट - नीचे दिया गया कोड नेगेटिव नंबरों के साथ भी उपयोग किया जा सकता है। उदाहरण import java.util.*; public class Demo{ static void count_sort(int[] arr){ int max_val = Arrays.stream(arr).max().ge

  1. - कॉकटेल सॉर्ट के लिए जावा प्रोग्राम

    कॉकटेल सॉर्ट बबल सॉर्ट के विपरीत काम करता है, जिसमें एलिमेंट्स को बाएं से दाएं पुनरावृति किया जाता है, और सबसे बड़ा एलिमेंट पहले अपनी सही स्थिति में लाया जाता है और इसी तरह। कॉकटेल सॉर्ट में, एलिमेंट्स को वैकल्पिक क्रम में दोनों दिशाओं (बाएं और दाएं) में पुनरावृति किया जाता है। कॉकटेल सॉर्ट के लिए