জাভাতে অ্যারে তালিকাটি সাজানো

Question 1

আমি অবাক হয়েছি যে আমি এর কোনও দ্রুত উত্তর পাই না। আমি মূলত জাভাতে একটি ডেটাস্ট্রাকচার খুঁজছি যা java.util.Listইন্টারফেসটি কার্যকর করে , তবে যা এর সদস্যদের সাজানো ক্রমে সঞ্চয় করে stores আমি জানি যে আপনি একটি সাধারণ ব্যবহার করতে পারেন ArrayListএবং Collections.sort()এটিতে ব্যবহার করতে পারেন , তবে আমার এমন একটি দৃশ্য রয়েছে যেখানে আমি মাঝে মধ্যে আমার তালিকা থেকে সদস্যদের যোগ করতে এবং পুনরুদ্ধার করি এবং আমি যখনই কোনও সদস্যের ক্ষেত্রে কোনও সদস্য পুনরুদ্ধার করি তখন আমি এটি বাছাই করতে চাই না a নতুন যুক্ত করা হয়েছে। জেডিকে বা তৃতীয় পক্ষের লাইব্রেরিগুলিতে যে কেউ বিদ্যমান তা আমাকে কীভাবে নির্দেশ করতে পারে?

সম্পাদনা : ডেটাস্ট্রাকচারের নকল সংরক্ষণ করতে হবে।

উত্তর এর সংক্ষিপ্তসার : আমি এই সব খুব আকর্ষণীয় এবং অনেক কিছু শিখেছি। আইয়ুব বিশেষভাবে আমার উপরে প্রয়োজনীয়তা অর্জনের চেষ্টা করার ক্ষেত্রে তাঁর অধ্যবসায়ের জন্য উল্লেখ করার দাবি রাখে (মূলত একটি সাজানো java.util.List বাস্তবায়ন যা সদৃশকে সমর্থন করে)। আমি যা বলেছিলাম তার সঠিক উত্তর হিসাবে আমি তার উত্তরকে স্বীকার করেছি এবং আমি যা চেয়েছিলাম তার সঠিক প্রভাব না থাকলেও আমি যা যা খুঁজছিলাম তার নিদর্শনগুলিতে সবচেয়ে বেশি চিন্তাভাবনা করেছিল।

আমি তালিকার ইন্টারফেসে এবং ইন্টারফেসে optionচ্ছিক পদ্ধতিগুলির ধারণার মধ্যে যা মিথ্যা চেয়েছি তার সমস্যা। জাভাডোকের উদ্ধৃতি দিতে:

এই ইন্টারফেসের ব্যবহারকারীর তালিকার প্রতিটি উপাদান সন্নিবেশ করা হয়েছে তার উপর যথাযথ নিয়ন্ত্রণ রয়েছে।

বাছাই করা তালিকায় সন্নিবেশকরণ পয়েন্টের উপরে সঠিক নিয়ন্ত্রণ নেই। তারপরে, আপনাকে ভাবতে হবে আপনি কীভাবে কয়েকটি পদ্ধতি পরিচালনা করবেন। addউদাহরণস্বরূপ নিন :

পাবলিক বুলিয়ান অ্যাড (অবজেক্ট ও)
 Appends the specified element to the end of this list (optional operation).

আপনি এখন উভয়েরই অস্বস্তিকর পরিস্থিতিতে রয়ে গেছেন 1) চুক্তি ভঙ্গ করা এবং অ্যাডের একটি সাজানো সংস্করণ বাস্তবায়ন 2) addতালিকার শেষে একটি উপাদান যুক্ত করা, আপনার সাজানো ক্রম ভঙ্গ করে 3) addছুড়ে ফেলে (তার বিকল্প হিসাবে) ফেলে দেওয়া একটি UnsupportedOperationExceptionএবং অন্য পদ্ধতি প্রয়োগ করে যা একটি সাজানো ক্রমে আইটেম যুক্ত করে।

অপশন 3 সম্ভবত সেরা, তবে আমি এটি ব্যবহার করতে পারছি না এমন একটি অ্যাড পদ্ধতি এবং ইন্টারফেসের মধ্যে নেই এমন আরও একটি সাজানো অ্যাডড পদ্ধতি থাকা অস্বচ্ছল বলে মনে করি।

অন্যান্য সম্পর্কিত সমাধান (কোনও নির্দিষ্ট ক্রমে):

java.util.PriorityQueue যা আমি যা চেয়েছিলাম তার চেয়ে সম্ভবত আমার যা প্রয়োজন তার চেয়ে নিকটতম। একটি সারি আমার ক্ষেত্রে অবজেক্টগুলির সংগ্রহের সর্বাধিক সুনির্দিষ্ট সংজ্ঞা নয়, তবে কার্যত এটি আমার যা প্রয়োজন তা কার্যত কার্যকর করে।
নেট.সোর্সফোর্জন.নাইট.ইটিল.সোর্টড লিস্ট । যাইহোক, এই বাস্তবায়ন add(Object obj)পদ্ধতিতে বাছাইয়ের মাধ্যমে তালিকার ইন্টারফেসের চুক্তি ভঙ্গ করে এবং উদ্ভটভাবে এর কোনও কার্যকর পদ্ধতি নেই add(int index, Object obj)। সাধারণ পরিস্থিতিতে sensক্যমত্য প্রস্তাব throw new UnsupportedOperationException()এই পরিস্থিতিতে একটি ভাল পছন্দ হতে পারে।
পেয়ারার ট্রিমলটিসেট সেট সেট বাস্তবায়ন যা সদৃশগুলিকে সমর্থন করে
ca.odell.glazedlists.SortList এই শ্রেণিটি তার জাভডোকে সতর্কতার সাথে আসে:Warning: This class breaks the contract required by List

Question 2

সংক্ষিপ্ত সমাধান

এখানে একটি "ন্যূনতম" সমাধান রয়েছে।

class SortedArrayList<T> extends ArrayList<T> {

    @SuppressWarnings("unchecked")
    public void insertSorted(T value) {
        add(value);
        Comparable<T> cmp = (Comparable<T>) value;
        for (int i = size()-1; i > 0 && cmp.compareTo(get(i-1)) < 0; i--)
            Collections.swap(this, i, i-1);
    }
}

সন্নিবেশটি রৈখিক সময়ে চলতে পারে তবে আপনি যেভাবেই কোনও অ্যারেলিস্ট ব্যবহার করতে পারবেন (সন্নিবেশকৃত উপাদানের ডানদিকে সমস্ত উপাদানকে অন্য কোনও উপায়ে স্থানান্তরিত করতে হবে)।

ক্লাসকাস্টএক্সসেপশনে তুলনামূলক অযোগ্য কিছু serোকানো। (এটি PriorityQueueএকইভাবে গৃহীত পদ্ধতি : প্রাকৃতিক অর্ডারের উপর নির্ভরশীল একটি অগ্রাধিকারের সারিও তুলনামূলক নয় এমন বস্তু সন্নিবেশের অনুমতি দেয় না (এটি করার ফলে ক্লাসকাস্টএক্সসেপশন হতে পারে) ))

ওভাররাইডিং `List.add`

নোট করুন যে বাছাই করা ফ্যাশনে উপাদান to োকাতে ওভাররাইডিং List.add(বা List.addAllসেই বিষয়ে) ইন্টারফেসের নির্দিষ্টকরণের সরাসরি লঙ্ঘন হবে । আপনি কি করতে পারেন, একটি নিক্ষেপ করার জন্য এই পদ্ধতিটি ওভাররাইড করা UnsupportedOperationException।

এর ডক্স থেকে List.add:

boolean add(E e)
এই তালিকার শেষে নির্দিষ্ট উপাদান যুক্ত করে (alচ্ছিক ক্রিয়াকলাপ)।

একই যুক্তি উভয় সংস্করণের জন্য প্রযোজ্য add, উভয় সংস্করণ addAllএবং set। (যার সবগুলি তালিকা ইন্টারফেস অনুযায়ী optionচ্ছিক ক্রিয়াকলাপ।)

কিছু পরীক্ষা

SortedArrayList<String> test = new SortedArrayList<String>();

test.insertSorted("ddd");    System.out.println(test);
test.insertSorted("aaa");    System.out.println(test);
test.insertSorted("ccc");    System.out.println(test);
test.insertSorted("bbb");    System.out.println(test);
test.insertSorted("eee");    System.out.println(test);

.... প্রিন্ট:

[ddd]
[aaa, ddd]
[aaa, ccc, ddd]
[aaa, bbb, ccc, ddd]
[aaa, bbb, ccc, ddd, eee]

Question 3

ব্যবহার java.util.PriorityQueue।

Question 4

সাজানো তালিকাতে একবার দেখুন

এই শ্রেণিটি একটি সাজানো তালিকা কার্যকর করে। এটি এমন একটি তুলনাকারী দিয়ে তৈরি করা হয়েছে যা দুটি অবজেক্টের তুলনা করতে পারে এবং সে অনুযায়ী বস্তু বাছাই করতে পারে। আপনি তালিকায় কোনও বস্তু যুক্ত করলে এটি সঠিক জায়গায় sertedোকানো হয়। তুলনাকারী অনুসারে সমান বস্তু, তারা এই তালিকায় যুক্ত হওয়া ক্রমে তালিকায় থাকবে। তুলনাকারী যে তুলনা করতে পারে কেবল সেগুলি যুক্ত করুন।

তালিকায় ইতিমধ্যে তুলনাকারী অনুসারে সমান বস্তু উপস্থিত থাকলে নতুন বস্তু এই অন্যান্য অবজেক্টের সাথে সাথেই inোকানো হবে।

Question 5

আপনি চেষ্টা করতে পারেন পেয়ারা এর TreeMultiSet ।

 Multiset<Integer> ms=TreeMultiset.create(Arrays.asList(1,2,3,1,1,-1,2,4,5,100));
 System.out.println(ms);

Question 6

আইওউবের পন্থা হ'ল উপায়। যদিও আমি তার সমাধানের তুলনায় নিম্নলিখিত উন্নতিটি বলতে চাই।

class SortedList<T> extends ArrayList<T> {

    public void insertSorted(T value) {
        int insertPoint = insertPoint(value);
        add(insertPoint, value);
    }

    /**
     * @return The insert point for a new value. If the value is found the insert point can be any
     * of the possible positions that keeps the collection sorted (.33 or 3.3 or 33.).
     */
    private int insertPoint(T key) {
        int low = 0;
        int high = size() - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            Comparable<? super T> midVal = (Comparable<T>) get(mid);
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else {
                return mid; // key found
            }
        }

        return low;  // key not found
    }
}

বড় তালিকাগুলি ব্যবহার করার সময় আইওবের সমাধান খুব ধীর হয়। তালিকাটি বাছাই করা হয়েছে তা ব্যবহার করে বাইনারি অনুসন্ধান ব্যবহার করে নতুন মানগুলির সন্নিবেশ বিন্দুটি আমাদের সন্ধান করতে দেয়।

আমি উত্তরাধিকারের উপরও রচনা ব্যবহার করবো, এর লাইনের পাশাপাশি কিছু

SortedList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Question 7

তালিকা সাধারণত আইটেম যোগ করা হয় যাতে ক্রম সংরক্ষণ করে। আপনার অবশ্যই একটি তালিকা প্রয়োজন , বা একটি সাজানো সেট (যেমন TreeSet<E>) আপনার জন্য ঠিক আছে? মূলত, আপনার কি সদৃশ সংরক্ষণের প্রয়োজন?

Question 8

এটি আপনার পক্ষে কিছুটা ভারী ওজন হতে পারে তবে গ্ল্যাজেডলিস্টগুলির একটি সোর্টার্ডলিস্ট রয়েছে যা কোনও টেবিল বা জে লিস্টের মডেল হিসাবে ব্যবহারের জন্য উপযুক্ত is

Question 9

আপনি অ্যারেলিস্ট সাবক্লাস করতে পারেন এবং কোনও উপাদান যুক্ত হওয়ার পরে কালেকশন.সোর্ট (এই) কল করতে পারেন - এটি করার জন্য আপনাকে দুটি সংস্করণ যুক্ত এবং দুটি অ্যাডএল এর দুটি ওভাররাইড করতে হবে।

পারফরম্যান্স একটি স্মার্ট বাস্তবায়ন হিসাবে ভাল হবে না যা উপাদানগুলিকে সঠিক জায়গায় sertedোকায়, তবে এটি কাজ করবে। তালিকার সংযোজন বিরল হলে তালিকার সমস্ত ক্রিয়াকলাপের তুলনায় ব্যয়টি স্বল্প পরিমাণে হওয়া উচিত।

Question 10

এই জাতীয় একটি নতুন ক্লাস করুন:

public class SortedList<T> extends ArrayList<T> {

private final Comparator<? super T> comparator;

public SortedList() {
    super();
    this.comparator = null;
}

public SortedList(Comparator<T> comparator) {
    super();
    this.comparator = comparator;
}

@Override
public boolean add(T item) {
    int index = comparator == null ? Collections.binarySearch((List<? extends Comparable<? super T>>)this, item) :
            Collections.binarySearch(this, item, comparator);
    if (index < 0) {
        index = index * -1 - 2;
    }
    super.add(index+1, item);
    return true;
}

@Override
public void add(int index, T item) {
    throw new UnsupportedOperationException("'add' with an index is not supported in SortedArrayList");
}

@Override
public boolean addAll(Collection<? extends T> items) {
    boolean allAdded = true;
    for (T item : items) {
        allAdded = allAdded && add(item);
    }
    return allAdded;
}

@Override
public boolean addAll(int index, Collection<? extends T> items) {
    throw new UnsupportedOperationException("'addAll' with an index is not supported in SortedArrayList");
}

}

আপনি এটি পরীক্ষা করতে পারেন:

    List<Integer> list = new SortedArrayList<>((Integer i1, Integer i2) -> i1.compareTo(i2));
    for (Integer i : Arrays.asList(4, 7, 3, 8, 9, 25, 20, 23, 52, 3)) {
        list.add(i);
    }
    System.out.println(list);

Question 11

আমি মনে করি সোর্টার্ড / তালিকা এবং 'সাধারণ' বাছাইযোগ্য সংগ্রহের মধ্যে পছন্দ নির্ভর করে, আপনার কেবল উপস্থাপনার উদ্দেশ্যে বা রানটাইমের সময় প্রায় প্রতিটি পয়েন্টে বাছাই করা দরকার কিনা। বাছাই করা সংগ্রহটি ব্যবহার করা আরও ব্যয়বহুল হতে পারে কারণ আপনি যখন কোনও উপাদান inোকান ততবার বাছাই করা হয়।

আপনি যদি জেডিকেতে কোনও সংগ্রহ বেছে নিতে না পারেন তবে আপনি অ্যাপাচি কমন্স সংগ্রহগুলি দেখুন

Question 12

যেহেতু বর্তমানে প্রস্তাবিত বাস্তবায়নগুলি সংগ্রহের এপিআই ভেঙে বাছাই করা তালিকার প্রয়োগ করে, একটি গাছের নিজস্ব বাস্তবায়ন বা এর অনুরূপ অন্য কিছু, তাই আমি কৌতূহল ছিল কীভাবে ট্রিম্যাপের উপর ভিত্তি করে একটি বাস্তবায়ন সম্পাদন করবে। (যেহেতু ট্রিসেটটি ট্রি ম্যাপকেও বেস করে তোলে)

কেউ যদি এতে আগ্রহী হয় তবে সেও সেটিকে নির্দ্বিধায় দেখতে পারে:

ট্রিলিস্ট

এটির মূল গ্রন্থাগারের অংশ , আপনি অবশ্যই এটি ম্যাভেন নির্ভরতার মাধ্যমে যুক্ত করতে পারেন। (অ্যাপাচি লাইসেন্স)

বর্তমানে বাস্তবায়নটি পেয়ারা सॉোর্টড মাল্টিটসেটের তুলনায় এবং অ্যাপাচি কমন্স লাইব্রেরির ট্রিলিস্টের সাথে একই স্তরের তুলনায় বেশ ভালভাবে তুলনা করেছে বলে মনে হচ্ছে।

তবে আমি খুশি হব যদি আমার চেয়ে বেশি কিছু বাস্তবায়ন পরীক্ষা করে দেখেন যে আমি গুরুত্বপূর্ণ কিছুটি হাতছাড়া করি নি।

শুভেচ্ছান্তে!

Question 13

আমারও একই সমস্যা ছিল। সুতরাং আমি java.util.TreeMap এর উত্স কোডটি নিয়েছি এবং ইনডেক্সডট্রিম্যাপ লিখেছি । এটি আমার নিজস্ব ইনডেক্সড নেভিগেইবলম্যাপটি প্রয়োগ করে :

public interface IndexedNavigableMap<K, V> extends NavigableMap<K, V> {
   K exactKey(int index);
   Entry<K, V> exactEntry(int index);
   int keyIndex(K k);
}

বাস্তবায়নটি লাল-কালো গাছের নোড ওজন আপডেট করার সময় পরিবর্তিত হয় changed ওজন হ'ল প্রদত্ত নোডের নীচে শিশু নোডের সংখ্যা, এবং এক - স্ব self উদাহরণস্বরূপ, যখন একটি গাছ বাম দিকে ঘোরানো হয়:

    private void rotateLeft(Entry<K, V> p) {
    if (p != null) {
        Entry<K, V> r = p.right;

        int delta = getWeight(r.left) - getWeight(p.right);
        p.right = r.left;
        p.updateWeight(delta);

        if (r.left != null) {
            r.left.parent = p;
        }

        r.parent = p.parent;


        if (p.parent == null) {
            root = r;
        } else if (p.parent.left == p) {
            delta = getWeight(r) - getWeight(p.parent.left);
            p.parent.left = r;
            p.parent.updateWeight(delta);
        } else {
            delta = getWeight(r) - getWeight(p.parent.right);
            p.parent.right = r;
            p.parent.updateWeight(delta);
        }

        delta = getWeight(p) - getWeight(r.left);
        r.left = p;
        r.updateWeight(delta);

        p.parent = r;
    }
  }

আপডেটওয়েট সহজভাবে ওজনকে মূল পর্যন্ত আপলোড করে:

   void updateWeight(int delta) {
        weight += delta;
        Entry<K, V> p = parent;
        while (p != null) {
            p.weight += delta;
            p = p.parent;
        }
    }

এবং যখন আমাদের সূচক অনুসারে উপাদানটি সন্ধান করতে হবে তা হল প্রয়োগগুলি যা ওজন ব্যবহার করে:

public K exactKey(int index) {
    if (index < 0 || index > size() - 1) {
        throw new ArrayIndexOutOfBoundsException();
    }
    return getExactKey(root, index);
}

private K getExactKey(Entry<K, V> e, int index) {
    if (e.left == null && index == 0) {
        return e.key;
    }
    if (e.left == null && e.right == null) {
        return e.key;
    }
    if (e.left != null && e.left.weight > index) {
        return getExactKey(e.left, index);
    }
    if (e.left != null && e.left.weight == index) {
        return e.key;
    }
    return getExactKey(e.right, index - (e.left == null ? 0 : e.left.weight) - 1);
}

একটি কী এর সূচকটি খুঁজে পাওয়া খুব কাজে আসে:

    public int keyIndex(K key) {
    if (key == null) {
        throw new NullPointerException();
    }
    Entry<K, V> e = getEntry(key);
    if (e == null) {
        throw new NullPointerException();
    }
    if (e == root) {
        return getWeight(e) - getWeight(e.right) - 1;//index to return
    }
    int index = 0;
    int cmp;
    index += getWeight(e.left);

    Entry<K, V> p = e.parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        while (p != null) {
            cmp = cpr.compare(key, p.key);
            if (cmp > 0) {
                index += getWeight(p.left) + 1;
            }
            p = p.parent;
        }
    } else {
        Comparable<? super K> k = (Comparable<? super K>) key;
        while (p != null) {
            if (k.compareTo(p.key) > 0) {
                index += getWeight(p.left) + 1;
            }
            p = p.parent;
        }
    }
    return index;
}

আপনি এই কাজের ফলাফলটি http://code.google.com/p/indexed-tree-map/ এ সন্ধান করতে পারেন

ট্রিসেট / ট্রিম্যাপ (সেইসাথে ইনডেক্সড-ট্রি-ম্যাপ প্রজেক্ট থেকে তাদের ইনডেক্সড কাউন্টারগুলি) নকল কীগুলিকে মঞ্জুরি দেয় না, আপনি মানগুলির একটি অ্যারেতে 1 কী ব্যবহার করতে পারেন। আপনার যদি ডুপ্লিকেট সহ একটি সাজানো সেট প্রয়োজন হয় তবে অ্যারে হিসাবে মান সহ ট্রি ম্যাপ ব্যবহার করুন। আমি হলে এটাই করতাম.

জাভাতে অ্যারে তালিকাটি সাজানো

সংক্ষিপ্ত সমাধান

ওভাররাইডিং List.add

কিছু পরীক্ষা

ওভাররাইডিং `List.add`