升序排序 - 链表[关闭]

Question

我在理解这个功能如何工作以及我需要做什么方面遇到了一些麻烦。我有 int number 作为我的数据类型和 node* next 在我的节点类中。我也有节点指针头、电流和温度。我的问题是我将如何让我的整数列表有序？另外，升序和降序如何在单个链表中工作？

我的头文件：

#ifndef SDI_LL                      
#define SDI_LL                      

namespace SDI
{                                                       

    class LinkedList                                                                    
    {
        class Node                                      
        {
        public:
            int number;                                 //data element
            Node* next;                                 //pointer to next, node inside each node
        private:

        };

    private:

        Node *head;
        Node *current;                                  //head, current and temp node pointers
        Node *temp;

    public:
        LinkedList();                                   //constructor to access nodes from above
        ~LinkedList();                                  //destructor

        void insert(int add);                           
        void remove(int remove);                        //functions that access private data nodes above
        void display();
        void reverse();
        void search(int searchNum);
        void sortAscending();
        void sortDecending();
        void saveAll();
        void restoreAll();

    };

}
#endif

到目前为止，我的升序函数从头开始并在列表中搜索：

void LinkedList::sortAscending()
{
    current = head;
    for (current = head; current;)
    {
        temp = current;
        current = current->next;

    }
}

Answer 1

一般来说，您应该使用标准库中提供的容器，这些容器在适用的情况下提供了有效的排序方法。

也就是说，如果您想出于学习目的而这样做 - 正如您可能“应该至少一次”那样 - 那么实施起来并不太难。

for (current = head; current;)

这是一个有趣的 for 循环，我个人更喜欢：

current = head;
while(current)  // or current != nullptr to be more explicit

还请注意，您（当然，不必要地）将 head 分配给 current 两次 - 紧接在 for 循环之前，以及在它的初始化中。

一个简单的方案（但根本没有效率！）可能是在您遍历列表时只交换“乱序”元素，直到不需要交换：

bool changeMade;
do{
    changeMade = false;
    current = head;
    while( current ){
        temp = current;
        current = current->next;

        if( current && current->data < temp->data ){
            changeMade = true;
            swap( temp->data, current->data );
        }
    }
} while( changeMade );

这假设 data 字段是节点中唯一的另一个字段 - 因为它实际上并不交换节点，只是交换数据。 （做前者实际上并不困难 - 但如果没有看到您的节点类型声明，我会编造名称并冒着混淆问题的风险。）

Answer 2

我没有看到任何关于 current、head 和 temp 的声明，但我认为它们是指向节点的指针。你决定排序算法了吗？排序算法是否需要高效或具有冒泡排序的性能？使用类似于冒泡排序的逻辑，您可以重复地将具有最大值的节点移动到列表的末尾。或者为了节省一点时间，您可以从原始列表中删除具有最大值的节点并将其插入到新列表的前面，该列表将以排序顺序结束。更高效的算法使用基于归并排序的逻辑。

要删除或交换节点，使用指向指针的指针可以避免对列表的第一个节点（本例中为 pList 指向的节点）进行特殊处理：

NODE * SortList(NODE * pList)
{
NODE * pNew = NULL;                     /* sorted list */
NODE **ppNode;                          /* ptr to ptr to node */
NODE **ppLargest;                       /* ptr to ptr to largest node */
NODE * pLargest;                        /* ptr to largest node */
    while(pList != NULL){               /* while list not empty */
        ppLargest = &pList;             /*  find largest node */
        ppNode = &((*ppLargest)->next);
        while(NULL != *ppNode){
            if((*ppNode)->data > (*ppLargest)->data)
                ppLargest = ppNode;
            ppNode = &((*ppNode)->next);
        }
        pLargest = *ppLargest;          /* move node to new */
        *ppLargest = pLargest->next;
        pLargest->next = pNew;
        pNew = pLargest;
    }    
    return(pNew);
}