स्थैतिक सरणी

ऐरे एक रैखिक डेटा संरचना है जहां सभी तत्व क्रमिक रूप से व्यवस्थित होते हैं। यह समान डेटा प्रकार के तत्वों का एक संग्रह है जो सन्निहित मेमोरी स्थानों पर संग्रहीत है।

प्रारंभ

public class Array {
    private T[] self;
    private int size;
    @SuppressWarnings("unchecked")
    public Array(int size) {
        if (size 



कोर ऐरे क्लास में, हम ऐरे के आकार और ऐरे आरंभीकरण के लिए एक सामान्य कंकाल को संग्रहीत करने जा रहे हैं। कंस्ट्रक्टर में, हम ऐरे का आकार पूछ रहे हैं और एक ऑब्जेक्ट बना रहे हैं और उसे अपने इच्छित ऐरे में टाइप कर रहे हैं।


  
  
  सेट विधि




public void set(T item, int index) {
        if (index >= this.size || index 



यह विधि किसी आइटम को ऐरे और इंडेक्स में संग्रहीत करने के लिए कह रही है कि किस आइटम को संग्रहीत किया जाना चाहिए।


  
  
  विधि प्राप्त करें




public T get(int index) {
        if (index >= this.size || index 



गेट मेथड एक इंडेक्स मांगता है और उस इंडेक्स से आइटम पुनर्प्राप्त करता है।


  
  
  मुद्रण विधि




public void print() {
        for (int i = 0; i 



प्रिंट विधि एक सरणी के सभी सदस्यों को एक ही पंक्ति में प्रिंट कर रही है, जिसमें प्रत्येक आइटम को उनके बीच अलग किया गया है।


  
  
  क्रमबद्ध सारणी


सरणी लेकिन तत्वों को स्वयं क्रमबद्ध करने की कार्यक्षमता है।


  
  
  प्रारंभ




public class SortedArray> {
    private T[] array;
    private int size;
    private final int maxSize;
    @SuppressWarnings("unchecked")
    public SortedArray(int maxSize) {
        if (maxSize 



सॉर्टेड ऐरे क्लास में, हम ऐरे के आकार को संग्रहीत करने जा रहे हैं और ऐरे के अधिकतम आकार और ऐरे आरंभीकरण के लिए एक सामान्य कंकाल भी मांग रहे हैं। कंस्ट्रक्टर में, हम ऐरे का अधिकतम आकार पूछ रहे हैं और एक ऑब्जेक्ट बना रहे हैं और उसे अपने इच्छित ऐरे में टाइप कर रहे हैं।


  
  
  टिककर खेल




public int length() {
        return this.size;
    }
 public int maxLength() {
        return this.maxSize;
    }
 public T get(int index) {
        if (index = this.size) {
            throw new IndexOutOfBoundsException("Index out of 
 bounds: "   index);
        }
        return this.array[index];
    }





  
  
  निवेशन विधि




private int findInsertionPosition(T item) {
        int left = 0;
        int right = size - 1;
        while (left = this.maxSize) {
            throw new IllegalStateException("The array is already full");
        }

        int position = findInsertionPosition(item);

        for (int i = size; i > position; i--) {
            this.array[i] = this.array[i - 1];
        }
        this.array[position] = item;
        size  ;
    }




इन्सर्ट मेथड आइटम को उसके स्थान पर क्रमबद्ध रूप में सम्मिलित करता है।


  
  
  हटाने की विधि




    public void delete(T item) {
        int index = binarySearch(item);
        if (index == -1) {
            throw new IllegalArgumentException("Unable to delete element "   item   ": the entry is not in the array");
        }

        for (int i = index; i 




  
  
  खोज के तरीके




private int binarySearch(T target) {
        int left = 0;
        int right = size - 1;
        while (left 




  
  
  ट्रैवर्स विधि




public void traverse(Callback callback) {
        for (int i = 0; i 




  
  
  कॉलबैक इंटरफ़ेस




public interface Callback {
        void call(T item);
    }





  
  
  ट्रैवर्सिंग में कॉलबैक इंटरफ़ेस का उपयोग




public class UppercaseCallback implements UnsortedArray.Callback {
    @Override
    public void call(String item) {
        System.out.println(item.toUpperCase());
    }
}





  
  
  अवर्गीकृत सारणी


यह ऊपर से लगभग समान है

आरंभीकरण और गेटर्स समान हैं।


  
  
  निवेशन विधि




public void insert(T item) {
        if (this.size >= this.maxSize) {
            throw new IllegalStateException("The array is already full");
        } else {
            this.self[this.size] = item;
            this.size  ;
        }
    }




हटाने का तरीका भी वही है


  
  
  खोज विधि




public Integer find(T target) {
        for (int i = 0; i 




  
  
  गतिशील सरणी


डायनेमिक ऐरे ऐरे सूचियों या सूचियों की तरह हैं।


  
  
  प्रारंभ




public class DynamicArray {
    private T[] array;
    private int size;
    private int capacity;

    @SuppressWarnings("unchecked")
    public DynamicArray(int initialCapacity) {
        if (initialCapacity 




  
  
  डालने की विधि




private void resize(int newCapacity) {
        @SuppressWarnings("unchecked")
        T[] newArray = (T[]) new Object[newCapacity];
        for (int i = 0; i = capacity) {
            resize(2 * capacity);
        }
        array[size  ] = item;
    }





  
  
  हटाएँ विधि




public void delete(T item) {
        int index = find(item);
        if (index == -1) {
            throw new IllegalArgumentException("Item not found: "   item);
        }

        for (int i = index; i  1 && size 



बाकी सब कुछ वैसा ही है।

आशा है कि इससे सरणियों के साथ काम करने में मदद मिलेगी। आपको कामयाबी मिले!