按值排序鏈表 -

Question

請耐心等待，我是 stackoverflow 的新手，所以讓我嘗試解釋我的問題，如果有任何我可以改進的問題，請務必發表評論，我會編輯問題

好的，所以我有一個鏈接列表，我想按列表中的值（恰好是價格）對其進行排序：

tmpPtr->item->price;

我遇到的問題是切換位置，這是代碼：

struct inventory *sort_list() {
        struct inventory *tmpPtr = pFirstNode;
        struct inventory *temp = NULL;
        struct inventory *tmpNxt = pFirstNode->next;
        int tmp;
        while(tmpNxt != NULL){
               while(tmpNxt != tmpPtr){
                        if(tmpNxt->item->price < tmpPtr->item->price){
                                // if next item price is smaller than current
                                // temp for the next item
                                // heres the problem....
                                temp = tmpNxt->next;
                                tmpNxt->next = tmpPtr;
                                tmpPtr->next = temp;
                        }
                        else{
                            // if not any smaller continue    
                            tmpPtr = tmpPtr->next;

                        }
                }
                tmpPtr = pFirstNode;
                tmpNxt = tmpNxt->next;
        }
        return tmpPtr; 
    }

這些值沒有按照我的邏輯進行排序，任何指針都會很棒編輯：

struct inventory *sort_list() {
        struct inventory *tmpPtr = pFirstNode;
        struct inventory *temp = NULL;
        struct inventory *tmpNxt = pFirstNode->next;
        while(tmpNxt != NULL){
               while(tmpNxt != tmpPtr){
                        if(tmpNxt->item->price < tmpPtr->item->price){
                                // if next item price is smaller than current
                                // temp for the next item
                                if(tmpPtr == pFirstNode){
                                    tmpPtr = pFirstNode->next; // tmpPtr is now second node
                                    pFirstNode->next = tmpPtr->next;
                                    tmpPtr->next = pFirstNode;
                                    pFirstNode = tmpPtr;
                                }

                                tmpNxt = tmpPtr->next;
                                tmpPtr->next = tmpNxt->next;
                                tmpNxt->next = tmpPtr;
                                temp->next = tmpNxt;
                        }

                }
                  temp = tmpPtr;
        }
        return tmpPtr; // Place holder
    }

Answer 1

當您處於內部 if 條件時，您具有以下狀態：

Node1 -> tmpPtr -> tmpNxt -> Node2

你想要達到的是：

Node1 -> tmpNxt -> tmpPtr -> Node2

然后你有以下代碼：

1. temp = tmpNxt->next; // 使temp = Node2
2. tmpNxt->next = tmpPtr; // 將列表更改為Node1 -> tmpPtr <-> tmpNxt ,
3. tmpPtr->next = temp; // 將列表更改為Node1 ->tmpPtr和tmpNxt -> tmpPtr -> Node2

如您所見，您缺少來自Node1 -> tmpNext的鏈接。 你可以這樣做並檢查你的結果。

Answer 2

要交換兩個相鄰的單鏈表成員，您需要三個相鄰的成員（在要交換的兩個成員后面的那個），除非其中一個是鏈表的頭部。

1. 表頭案例→交換list_head和list_head->next

    assert(list_head->next); next = list_head->next; list_head->next = next->next; next->next = list_head; list_head = next;

2. 其他情況 → 交換cur和cur->next

    assert(prev->next == cur && cur->next); next = cur->next; cur->next = next->next; next->next = cur; prev->next = next;

但是，如果將前一個節點重新定義為前一個節點的下一個成員的地址，則這兩種情況可以合並為一種情況。

void swap_cur_with_next (node **pnext, node *cur) {
    assert(*pnext == cur && cur->next);
    node *next = cur->next;
    cur->next = next->next;
    next->next = cur;
    *pnext = next;
}

/* swap list_head with list_head->next */
swap_cur_with_next(&list_head, list_head);

/* swap cur with cur->next */
swap_cur_with_next(&prev->next, cur);

使用正確的交換例程，可以更輕松地在列表上實現冒泡排序算法。 代碼結構可能如下所示：

void bubble_up(node **pnext, node *cur) {
    while (cur->next) {
        if (need_to_swap(cur)) {
            swap_cur_with_next(pnext, cur);
        }
        pnext = &(*pnext)->next;
        cur = *pnext;
    }
}

node **pnext = &list_head;
while (*pnext) {
    bubble_up(pnext, *pnext);
    pnext = &(*pnext)->next;
}

但是，如不同答案中所述，歸並排序是一種更自然、更有效的算法，可用於對列表進行排序。

至少，您可以將節點指針打包到一個數組中，並使用qsort()對節點指針進行排序，然后按排序順序將它們鏈接起來。