लिस्ट के एलिमेंट्स रोटेट करने के लिए Java प्रोग्राम

इस लेख में, हम समझेंगे कि लिस्ट के एलिमेंट्स को कैसे रोटेट करें। List इंटरफेस Collection को एक्सटेंड करता है और एलिमेंट्स के अनुक्रम को स्टोर करने वाले संग्रह के व्यवहार की घोषणा करता है। Collection एक फ्रेमवर्क है जो ऑब्जेक्ट्स के समूह को स्टोर और मैनिपुलेट करने के लिए आर्किटेक्चर प्रदान करता है। Java Collections वे सभी ऑपरेशन्स प्राप्त कर सकते हैं जो आप डेटा पर करते हैं जैसे खोज, सॉर्टिंग, इंसर्शन, मैनिपुलेशन, और डिलीशन।

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

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

इनपुट लिस्ट: [100, 150, 200, 250, 300]

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

एक रोटेशन के बाद लिस्ट: [150, 200, 250, 300, 100]

एल्गोरिदम

चरण 1 - शुरू
चरण 2 - एक लिस्ट घोषित करें जिसका नाम input_list हो
चरण 3 - मान परिभाषित करें
चरण 4 - लिस्ट के माध्यम से इटरेट करें, और विशिष्ट इंडेक्स पर एलिमेंट प्राप्त करने के लिए 'get' मेथड का उपयोग करें
चरण 5 - इस वेरिएबल को एक नए वेरिएबल 'temp' में असाइन करें
चरण 6 - अंत से लिस्ट के माध्यम से इटरेट करें, और विशिष्ट इंडेक्स पर एलिमेंट प्राप्त करें। 'set' मेथड का उपयोग करके 'temp' पर मान सेट करें
चरण 7 - परिणाम प्रदर्शित करें
चरण 8 - रुकें

उदाहरण 1: मैनुअल रोटेशन

यहाँ, हम सभी ऑपरेशन्स को 'main' फंक्शन के तहत बांधते हैं।

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        List input_list = new ArrayList<>();
        input_list.add(100);
        input_list.add(150);
        input_list.add(200);
        input_list.add(250);
        input_list.add(300);
        
        System.out.println("लिस्ट परिभाषित है: " + Arrays.toString(input_list.toArray()));
        
        for (int i = 0; i < 4; i++) {
            int temp = input_list.get(4);
            for (int j = 4; j > 0; j--) {
                input_list.set(j, input_list.get(j - 1));
            }
            input_list.set(0, temp);
        }
        
        System.out.println("एक रोटेशन के बाद लिस्ट: " + Arrays.toString(input_list.toArray()));
    }
}

आउटपुट

लिस्ट परिभाषित है: [100, 150, 200, 250, 300]
एक रोटेशन के बाद लिस्ट: [150, 200, 250, 300, 100]

उदाहरण 2: फंक्शन में एनकैप्सुलेटेड

यहाँ, हम ऑपरेशन्स को फंक्शन्स में एनकैप्सुलेट करते हैं जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रदर्शित करते हैं।

import java.util.*;

public class Demo {
    static void rotate(List input_list) {
        for (int i = 0; i < 4; i++) {
            int temp = input_list.get(4);
            for (int j = 4; j > 0; j--) {
                input_list.set(j, input_list.get(j - 1));
            }
            input_list.set(0, temp);
        }
        System.out.println("\nएक रोटेशन के बाद लिस्ट: " + Arrays.toString(input_list.toArray()));
    }
    
    public static void main(String[] args) {
        List input_list = new ArrayList<>();
        input_list.add(100);
        input_list.add(150);
        input_list.add(200);
        input_list.add(250);
        input_list.add(300);
        
        System.out.println("लिस्ट परिभाषित है: " + Arrays.toString(input_list.toArray()));
        rotate(input_list);
    }
}

आउटपुट

लिस्ट परिभाषित है: [100, 150, 200, 250, 300]
एक रोटेशन के बाद लिस्ट: [150, 200, 250, 300, 100]

बेहतर दृष्टिकोण: Collections.rotate()

import java.util.Collections;
import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List list = new ArrayList<>(Arrays.asList(100, 150, 200, 250, 300));
        System.out.println("मूल लिस्ट: " + list);
        
        // दाएं रोटेट (पॉजिटिव डिस्टेंस)
        Collections.rotate(list, 1);
        System.out.println("दाएं 1 रोटेट: " + list);  // [300, 100, 150, 200, 250]
        
        // बाएं रोटेट (नेगेटिव डिस्टेंस)
        Collections.rotate(list, -1);
        System.out.println("बाएं 1 रोटेट: " + list);   // [100, 150, 200, 250, 300]
        
        // एकाधिक पोजीशन
        Collections.rotate(list, 2);
        System.out.println("दाएं 2 रोटेट: " + list);   // [250, 300, 100, 150, 200]
    }
}

रोटेशन एल्गोरिदम तुलना

एल्गोरिदम	समय जटिलता	स्पेस	नोट्स
Collections.rotate()	O(n)	O(1)	बिल्ट-इन, ऑप्टिमाइज़्ड, रिवर्सल एल्गोरिदम
मैनुअल शिफ्ट (नेस्टेड लूप)	O(n×k)	O(1)	धीमा जब k बड़ा हो
रिवर्सल एल्गोरिदम	O(n)	O(1)	3 रिवर्स: पूरा, पहला k, बाकी
नई लिस्ट + सिस्टम.arraycopy	O(n)	O(n)	तेज़, अतिरिक्त मेमोरी
Deque (ArrayDeque)	O(k)	O(n)	बार-बार रोटेशन के लिए अच्छा

रिवर्सल एल्गोरिदम कार्यान्वयन

// O(n) समय, O(1) स्पेस - Collections.rotate जैसा
public static void rotate(List list, int k) {
    int n = list.size();
    if (n == 0) return;
    k = k % n;
    if (k < 0) k += n;
    if (k == 0) return;
    
    // 1. पूरी लिस्ट रिवर्स करें
    reverse(list, 0, n - 1);
    // 2. पहले k एलिमेंट्स रिवर्स करें
    reverse(list, 0, k - 1);
    // 3. बाकी एलिमेंट्स रिवर्स करें
    reverse(list, k, n - 1);
}

private static void reverse(List list, int start, int end) {
    while (start < end) {
        Collections.swap(list, start++, end--);
    }
}

सामान्य उपयोग के मामले

सर्कुलर बफर: फिक्स्ड-साइज़ विंडो प्रोसेसिंग
लोड बैलेंसिंग: राउंड-रॉबिन सर्वर चयन
गेम डेवलपमेंट: टर्न-बेस्ड प्लेयर ऑर्डर
क्रिप्टोग्राफी: सिफर ऑपरेशन्स
इमेज प्रोसेसिंग: पिक्सेल शिफ्टिंग