Блог

Списки сортируются так, как они должны, но когда я пытаюсь объединить два списка вместе в моем makeUnion, он выводит пустой список. кто-нибудь может мне помочь и рассказать, почему? в основном, когда я пытаюсь SortedLinkedList merge = sortedNames1.makeUnion(sortedNames2) Я получаю «Пустой список».

     public class SortedLinkedList<T extends Comparable<? super T>>
                     extends LinkedList<T> 
    {
        private LinkedList<T> list;  //the sorted list

        //the constructor
        public SortedLinkedList(LinkedList<T> in)
        {
            if(in.isEmpty())
            {
               System.out.println("Empty list");
            }
            if(in.size() < 2)
            {
               return;
            }
            else
            {  
                list = new LinkedList<T>();
                for(int i = 1; i < in.size(); i  )
                {
                    T temp = in.get(i);
                    int j = i;
                    while(j > 0 amp;amp; in.get(j - 1).compareTo(temp) > 0)
                    {
                        in.set(j, in.get(j-1));
                        j--;
                    }
                    in.set(j, temp);
                }
                for(T elements : in)
                {
                    list.add(elements);  
                }
            }
        }

        //return the union of the sorted linked lists this and other
        public SortedLinkedList<T> makeUnion( SortedLinkedList<T> other)
        {
            SortedLinkedList<T> first = new SortedLinkedList<T>(other);
            SortedLinkedList<T> second = new SortedLinkedList<T>(list);
            SortedLinkedList<T> UnionList = null;

            int i = 0;
            int j = 0;
            while(i<first.size() amp;amp; j<second.size())
            {
                if(first.get(i).compareTo(second.get(j)) <= 0)
                {
                    UnionList.add(first.get(i));
                    i  ;
                }
                else
                {
                    UnionList.add(second.get(j));
                    j  ;
                }
            }

            if(i == first.size())
            {
                    for(int k = j; k<second.size(); k  )
                    {
                        UnionList.add(second.get(k));
                    }
            }
            else if(j == second.size())
            {
                    for(int x = i; x<first.size(); x  )
                    {
                        UnionList.add(first.get(x));
                    }
            }    

            return UnionList;      
        }


        //print the items int list
        public void print()
        {
            ListIterator itr = list.listIterator();
            while(itr.hasNext())
            {
                System.out.println(itr.next());
            }
        }
    }
  

         SortedLinkedList<T> UnionList = null;
  

Вы не можете вызвать UnionList.add() if UnionList is null . Вам нужно будет выделить новый список, прежде чем вы сможете добавлять в него что-либо.

На самом деле, я думаю, что ваша первоначальная проблема может заключаться в том, что SortedLinkedList оба расширяются LinkedList , а также содержат экземпляр a LinkedList . Вы должны выбрать один или другой, но не оба. Ваш код иногда обращается к одному списку, а иногда к другому, поэтому один список кажется пустым, потому что вы добавили элементы в другой список.

Вы не инициализируете UnionList перед началом его использования.

 SortedLinkedList<T> UnionList = null;
  

следует прочитать

 SortedLinkedList<T> UnionList = new SortedLinkedList<T>();
  

В качестве бонуса ListIterator должен быть ListIterator<T>, чтобы использовался правильный метод toString() . Как бы то ни было, вы будете вызывать Object.toString() .

Потому что вы использовали наследование вместо делегирования. Вы наследуете LinkedList, и единственное, что вы делаете, это определяете конструктор, который добавляет содержимое несортированного списка в новый в соответствующем порядке. Но вы не переопределяете size метод, поэтому этот метод наследуется от LinkedList , который не заботится о вашем внутреннем отсортированном списке и, следовательно, всегда возвращает 0.

Расширение коллекции в большинстве случаев является плохой идеей. В данном случае это особенно плохая идея, потому что невозможно иметь отсортированный LinkedList, который уважает LinkedList API. Предположим, ваш список содержит A, B и C, и вы вызываете addFirst("Z") его. Куда вы поместите Z, если в начале ваш список больше не отсортирован. Если в конце вы не соблюдаете контракт addFirst .

Просто используйте связанные списки (вместо их расширения) и сортируйте их. Вы могли бы просто сделать :

 LinkedList list = new LinkedList(someUnsortedList);
Collections.sort(list); // now the list is sorted
list.addAll(someOtherList);
Collections.sort(list); // now both lists are merged, and the resulting list is sorted.