Question

下面是我对ASC链表的插入方法的实现，它根据优先级将PQueueItem对象插入到PQueueItem类型的链表中。

我基本上在优先级方面检查要插入的项目是否大于当前项目并且小于下一项目，如果是，则插入它。如果它等于下一个项目，请按字母顺序排列。如果它小于当前项目，请将其放在它之前。如果它大于当前项和下一项，则遍历该列表，直到它满足其他一项检查。

这是实现插入的适当/有效方式吗？如果你认为我的想法都是：

，非代码的想法会很棒

不正确
低效。

干杯！

public void insert(T data, int priority) {
        if(order == ORDER.ASC)
        {
            //current item
            PQueueItem<T> temp = head;

            while(temp.getNext() != null)
            {
                //is inserted item greater than current item
                if(priority > temp.getPriority())
                {
                    //is inserted item smaller than next item
                    if(priority < temp.getNext().getPriority())
                    {
                         //create and insert new item, reassign links in the list
                         PQueueItem<T> newPQ = new PQueueItem<T>(data, priority);
                         newPQ.setNext(temp.getNext());
                         temp.setNext(newPQ);

                    }
                    //check to see if priority equates to the next item's priority
                    else if(priority == temp.getNext().getPriority())
                    {
                        //is new item's data alphabetically greater than the next item's data
                        if(((String)data).compareToIgnoreCase((String)temp.getNext().getData()) > 0)
                        {
                             PQueueItem<T> nextPQ = temp.getNext();
                             PQueueItem<T> newPQ = new PQueueItem<T>(data, priority);
                             newPQ.setNext(nextPQ.getNext());
                             nextPQ.setNext(newPQ);
                        }
                        else
                        {
                            PQueueItem<T> newPQ = new PQueueItem<T>(data, priority);
                            newPQ.setNext(temp.getNext());
                            temp.setNext(newPQ);
                        }
                    }
                    else
                    {
                        //iterate current item
                        temp = head.getNext();
                    }
                } 
                //if item to be inserted is smaller than the current item
                else if(priority < temp.getPriority())
                {
                     PQueueItem<T> newPQ = new PQueueItem<T>(temp.getData(), temp.getPriority());
                     newPQ.setNext(temp.getNext());
                     temp.setData(data);
                     temp.setPriority(priority);
                }
            }
        }   
        else
        {
            //code for DESC             
        }
    }

Answer 1

引起注意的是：

有一个虚拟头节点。

首先，比较方法有效：

private int compare(T data, int priority, PQueueItem<T> pq) {
    return -1 or 0 or 1;
}

然后没有头部的虚拟节点：

    PQueueItem<T> prior = null;
    PQueueItem<T> current = head;

    // Walk to the insertion point:
    while (current != null) {
        int comparison = compare(data, priority, current);
        if (comparison >= 0) {
            if (comparison == 0) {
                return; // No insert?
            }
            break;
        }
        prior = current;
        current = current.getNext();
    }

    // Create the link:
    PQueueItem<T> newPQ = new PQueueItem<T>(data, priority);
    newPQ.setNext(current);

    if (prior == null) {
        head = newPQ;
    } else {
        prior.setNext(newPQ);
    }

Answer 2

已经有一段时间了，但有一些像对数搜索这样可以提高你的实现速度很快的时间（你现在用列表的大小线性缩放，对数刻度与列表的大小对数（理解）这意味着，在1000000000个元素上，log（1000000000）依旧是20，可怜的小。）

算法：你从整个列表开始，然后把它切成两半。要插入的元素恰好位于其中一半中。你选择了正确的一个，并把它切成两半。你继续这样做，直到你看到的列表部分最多有2个元素。然后你知道要插入元素的位置。实现通常是两个保存索引的变量，并且在每次迭代中将其中一个移动到您当前所看到的一半。

每个步骤都会使您的元素处理为半个，这意味着您最终会以最对数的复杂时间插入您的值。

另外，不要指望任何更好的解决方案，对数很难被击败。如果你想要“即时”插入，你需要一个不同的结构。

将新项目插入升序有序链表

2 个答案: