尝试仅通过操作指针对链表进行排序答案

【问题标题】：Trying to Sort a Linked List only by Manipulating Pointers尝试仅通过操作指针对链表进行排序
【发布时间】：2013-10-24 21:48:04
【问题描述】：

我正在尝试使用选择排序对链接列表进行排序。我只能操作链表指针而不能更改键。我想我有功能逻辑，但是我只返回原始的未排序序列。

bool nodeSwap(Node* head){

  Node* next = head->next;
  if(next == NULL){ return head;}
  head->next = next->next;
  next->next = head;
  head = next;
  return next;
}
Node* sort_list(Node* head){

for(Node* n = head; n->next != NULL; n = n->next){
    for(Node* n1 = head->next; n1 != NULL; n1 = n1->next){
        if(n-> key > n1->key){
            nodeSwap(n);


            }
    }
}
return head;
}

编辑

好的，所以我经历并添加了更多和一些逻辑，这一次实际上有些意义，我的功能几乎可以工作......唯一的问题是它总是跳过对列表中前两个元素的排序并且没有排序后不返回。关于为什么会发生这种情况的任何想法？

Node* sort_list(Node* head){

Node* curr;
Node* prev;

  for(curr = head; curr->next != NULL; curr = curr->next){
      if(curr == head){
             head = curr->next;
             curr->next = head->next;
             head->next = curr;
             prev = head;
         }
     else if(curr->key > curr->next->key){
                  head = curr->next;
                  curr->next = head->next;
                  head->next = curr;
                  prev = head;
              } else if(curr -> next -> next != NULL){

                  prev->next = curr->next;
                  curr->next = prev->next->next;
                  prev->next->next = curr;

                  }else if(head != curr){
                        prev = prev->next;
                    }else{}
    }


 return head;
}

【问题讨论】：

你不能像那样交换两个节点。 next 指针指向您传递给nodeSwap 的head 的节点呢？
所以您正在尝试对链表进行冒泡排序，对吗？如果您认为这是直截了当的，您不妨多考虑一下。它可以制作出奇的简单，但你必须深入思考。你真正改变了什么？

标签： c++ sorting pointers linked-list selection

【解决方案1】：

尝试放置可编译的代码和/或提出特定问题。

第 3 行：return head;

在一个应该返回布尔值的函数中

【讨论】：

【解决方案2】：

似乎您正在按值传递 n。如果你需要在函数内部修改 n 的值，你需要将其设为全局（argh）或者传递 n 的地址：

bool nodeSwap(Node** head){
    [...]
}

【讨论】：

【解决方案3】：

单链表还是双链表？您提到仅交换数据，但您没有提供指针定义（仅键，还是键和数据指针？），

如果要交换两个节点的内容，需要在nodeSwap函数中提供两个节点的指针，

bool nodeSwap(Node* a, node* b)
{
    if(!a) return false;
    if(!b) return false;
    int temp = a->key;
    a->key = b->key
    b->key = temp;
    void* dtemp = a->data;
    a->data = b->data;
    b->data = dtemp;
    return true;
}

如果你想交换整个节点，那么你需要提供previous指针，或者去查找它们（下面假设一个双向链表，或者你看到'prev'你去找到它），

bool nodeSwap(Node* a, node* b, Node* head)
{
    if(!a) return false;
    if(!b) return false;
    Node* ap=NULL, *bp=NULL;
    //double linked list
    ap = a->prev;
    bp = b->prev;
    //single linked list, get ap (a.previous),
    if( a!=head )
        for( ap=head; ap!=a->next; )
            ap=np->next;
    //single linked list, get bp (b.previous)
    if( b!=head )
        for( bp=head; bp!=b->next; )
            bp=bp->next;
    Node* temp;
    temp = a;
    //fix a->prev->next, b->prev->next
    ap->next = b; //was a
    bp->next = a; //was b
    //swap a->next, b->next
    temp    = a->next;
    a->next = b->next;
    b->next = temp;
    //swap a->prev, b->prev for double-linked list
    temp    = a->prev; //double linked list
    a->prev = b->prev; //double linked list
    b->prev = temp;    //double linked list
    //swap keys, not needed, you moved the Node*
    return true;
}

这里是带有两个指针的nodeSwap，

Node* sort_list(Node* head){
    for(Node* n = head; n->next != NULL; n = n->next){
        for(Node* n1 = head->next; n1 != NULL; n1 = n1->next){
            if(n-> key > n1->key){
                nodeSwap(n,n1);
                //nodeSwap(n,n1,head);
            }
        }
    }
    return head;
}

【讨论】：