अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्ध गर्दै


कठिनाई तह सजिलो
बारम्बार सोधिन्छ बेलजाबार जीई हेल्थकेयर महिन्द्रा Comviva MAQ NVIDIA Qualcomm अब सेवा
लाम क्रमबद्ध

अतिरिक्त ठाउँ समस्या बिना एक लाम क्रमबद्ध गर्दा हामीले एक दिएका छौं लामअतिरिक्त ठाउँ बिना मानक प que्क्ति अपरेशनको प्रयोग गरेर क्रमबद्ध गर्नुहोस्।

उदाहरण

आगत
लाम = १० -> - -> २ -> - ->।
उत्पादन
लाम = १० -> - -> २ -> - ->।

आगत
लाम = ११ -> - - -> --१ -> --२ -> - 56 ->।
उत्पादन
पue्क्ति = १ -> १ - -> २ - -> - - -> - 1 ->। 18

आगत
लाम = १० -> - -> २ -> - ->।
उत्पादन
लाम = १० -> - -> २ -> - ->।

अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्धको लागि एल्गोरिथ्म

दुई भाग बाट बनेको लामलाई विचार गर्नुहोस्, एउटा क्रमबद्ध गरिएको छ र अर्को क्रमबद्ध छैन। प्रारम्भमा, सबै तत्वहरू क्रमबद्ध नभएको भागमा उपस्थित हुन्छन्।
प्रत्येक चरणमा, क्रमबद्ध पंक्तिबाट न्यूनतम तत्वको अनुक्रमणिका फेला पार्नुहोस् र यसलाई लामको अन्तमा सार्नुहोस्, क्रमबद्ध गरिएको भागमा।
क्रमबद्ध लाममा सबै तत्वहरू उपस्थित नभएसम्म यो चरण दोहोर्याउनुहोस्।

  1. I = 0 to n (समावेश नगरिएको) को लागी लूप चलाउनुहोस्, जहाँ n लामको आकार हो।
  2. प्रत्येक पुनरावृत्तिमा minIndex -1 को रूप मा सुरू गर्नुहोस् र minValue को -इन्फिनिटीको रूपमा।
  3. चर j सँग अर्को लूप चलाउनुहोस् जसले क्रमबद्ध क्रमबद्ध प from्क्तिबाट न्यूनतम तत्त्वको अनुक्रमणिका फेला पार्छ। क्रमबद्ध पue्क्ति अनुक्रमणिका ० देखि अनुक्रमणिका (n - i) को i को विशेष मानको लागि अवस्थित छ। प्रत्येक पुनरावृत्तिमा, यदि हालको तत्त्व minValue भन्दा कम छ भने, minValue लाई वर्तमान तत्वको रूपमा अपडेट गर्नुहोस् र minIndex j को रूपमा।
  4. लाममा ट्राभर्स गर्नुहोस् र एनिमेन्ट स्थिति मिन्डइन्डडेक्समा हटाउनुहोस् र लामको अन्तमा धकेल्नुहोस्।
  5. लाम क्रमबद्ध गरिएको छ, यसको तत्व प्रिन्ट गर्नुहोस्।

अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्धको लागि स्पष्टीकरण

एक उदाहरण विचार गर्नुहोस्,
लाम = १० -> - -> २ -> - ->।

प्रारम्भमा, सबै तत्वहरू क्रमबद्ध नभएको भागमा अवस्थित हुन्छन्, त्यो हो

अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्ध गर्दै

प्रत्येक चरणमा, क्रमबद्ध भागमा न्यूनतम तत्वको अनुक्रमणिका फेला पार्नुहोस् र यसलाई लामको अन्तमा सार्नुहोस्, जुन भाग गरिएको छ।

अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्ध गर्दै

सबै तत्वहरू क्रमबद्ध भागमा उपस्थित छन्, त्यसैले हामी रोक्दछौं।

जाभा कोड अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्धको लागि

import java.util.LinkedList;
import java.util.Queue;

public class SortingAQueueWithoutExtraSpace {
    private static void sortQueue(Queue<Integer> queue) {
        int n = queue.size();

        for (int i = 0; i < n; i++) {
            // Find the index of smallest element from the unsorted queue
            int minIndex = -1;
            int minValue = Integer.MAX_VALUE;
            for (int j = 0; j < n; j++) {
                int currValue = queue.poll();
                // Find the minimum value index only from unsorted queue
                if (currValue < minValue && j < (n - i)) {
                    minValue = currValue;
                    minIndex = j;
                }
                queue.add(currValue);
            }

            // Remove min value from queue
            for (int j = 0; j < n; j++) {
                int currValue = queue.poll();
                if (j != minIndex) {
                    queue.add(currValue);
                }
            }
            // Add min value to the end of the queue
            queue.add(minValue);
        }

        // Print the sorted queue
        for (Integer i : queue) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Example 1
        Queue<Integer> q1 = new LinkedList<>();
        q1.add(10);
        q1.add(7);
        q1.add(2);
        q1.add(8);
        q1.add(6);
        sortQueue(q1);

        // Example 2
        Queue<Integer> q2 = new LinkedList<>();
        q2.add(56);
        q2.add(66);
        q2.add(1);
        q2.add(18);
        q2.add(23);
        q2.add(39);
        sortQueue(q2);
    }
}
2 6 7 8 10 
1 18 23 39 56 66

C ++ अतिरिक्त स्पेस बिना एक पue्क्ति क्रमबद्धको लागि कोड

#include<bits/stdc++.h> 
using namespace std;

void sortQueue(queue<int> &queue) {
    int n = queue.size();
    
    for (int i = 0; i < n; i++) {
        // Find the index of smallest element from the unsorted queue
        int minIndex = -1;
        int minValue = INT_MAX;
        for (int j = 0; j < n; j++) {
            int currValue = queue.front();
            queue.pop();
            // Find the minimum value index only from unsorted queue
            if (currValue < minValue && j < (n - i)) {
                minValue = currValue;
                minIndex = j;
            }
            queue.push(currValue);
        }Nvidia
Belzabar
        
        // Remove min value from queue
        for (int j = 0; j < n; j++) {
            int currValue = queue.front();
            queue.pop();
            if (j != minIndex) {
                queue.push(currValue);
            }
        }
        // Add min value to the end of the queue
        queue.push(minValue);
    }
    
    // Print the sorted queue
    for (int i = 0; i < n; i++) {
        int curr = queue.front();
        queue.pop();
        cout<<curr<<" ";
        queue.push(curr);
    }
    cout<<endl;
}

int main() {
    // Example 1
    queue<int> q1;
    q1.push(10);
    q1.push(7);
    q1.push(2);
    q1.push(8);
    q1.push(6);
    sortQueue(q1);

    // Example 2
    queue<int> q2;
    q2.push(56);
    q2.push(66);
    q2.push(1);
    q2.push(18);
    q2.push(23);
    q2.push(39);
    sortQueue(q2);
}
2 6 7 8 10 
1 18 23 39 56 66

जटिलता विश्लेषण

समय जटिलता = O (n2)
ठाउँ जटिलता = O (१)
जहाँ n लाममा तत्वहरूको संख्या हो।

सन्दर्भ