C++ 合并排序不会拆分列表的右侧

与标题状态一样，我的合并排序只拆分左侧。其他一切都很好，包括我的合并功能。我不明白为什么。我真的很感激你的帮助。在一个包括：7、4、10、2、6、1、3、7、11、5的列表中，它输出1、2、3、4、6、7、7、10、11、5

编辑：添加了我班的其余部分

#include <iostream>
#include <string>
using namespace std;

class linkedList
{
private:
    class node
    {
    public:
        int data;
        node * next;
        node * prev;


    node(int x)
    {
        data = x;
        next = NULL;
        prev = NULL;
    }
};

node * head;
node * tail;

node * split()
{
    node * finger = head;
    node * fast = head->next;
    while (fast != NULL)
    {
        fast = fast->next;
        if (fast != NULL)
        {
            fast = fast->next;
            finger = finger->next;
        }
    }
    tail = finger->next;
    node * splitB = tail;
    splitB->prev = NULL;
    finger->next = NULL;
    return splitB;
}

node * merge(node * a, node * b)
{
    linkedList m;

    while(a != NULL || b != NULL)
    {
        if(b == NULL)
        {
            if(m.head != NULL)
            {
                a->prev = m.tail;
                m.tail->next = a;
                m.tail = a;

            }
            else
            {
                m.head = a;
                m.tail = m.head;
            }
            a = a->next;
        }
        else if(a == NULL)
        {
            if(m.head != NULL)
            {               
                b->prev = m.tail;
                m.tail->next = b;
                m.tail = b;
            }
            else
            {
                m.head = b;
                m.tail = m.head;
            }
            b = b->next;
        }
        else if (a->data < b->data)
        {
            if(m.head == NULL)
            {
                m.head = a;
                m.tail = m.head;
            }
            else
            {
                a->prev = m.tail;
                m.tail->next = a;
                m.tail = a;
            }
            a = a->next;
        }
        else
        {
            if(m.head == NULL)
            {
                m.head = b;
                m.tail = m.head;
            }
            else
            {
                b->prev = m.tail;
                m.tail->next = b;
                m.tail = b;
            }
            b = b->next;
        }
    }
    return m.head;
}

node* mergeSort(node * a)
{
    if (head == NULL || head->next == NULL)
    {
        return a;
    }
    else
    {
        node * b = split();

        node* right = mergeSort(a);
        node* left = mergeSort(b);

        return merge(right, left);
    }
}



public:
    linkedList()
    {
        head = NULL;
        tail = NULL;
    }


void push_back(int x)
{
    node * baby = new node(x);

    if( head == NULL )
    {
        head=baby;
        tail=baby;
    }
    else
    {
        baby->prev = tail;
        tail->next = baby;
        tail = baby;
    }
}

void mergeSort()
{
    head = mergeSort(head);
}

bool empty()
{
    if (head == NULL)
        return true;
    else
        return false;
}

int pop()
{
    int popMe = head->data;
    node * deleteMe = head;
    if (head->next == NULL)
    {
        head = NULL;
        tail = NULL;
        delete deleteMe;
        return popMe;
    }
    else
    {
        head = head->next;
        head->prev = NULL;
        delete deleteMe;
        return popMe;
    }
}
//test
void display()
{
    node * finger = head;
    while(finger!=NULL)
    {
        cout << finger->data << endl;
        finger = finger->next;
    }
}

};

#包括
#包括
使用名称空间std；
类链接列表
{
私人：
类节点
{
公众：
int数据；
节点*下一步；
节点*prev；
节点（int x）
{
数据=x；
next=NULL；
prev=NULL；
}
};
节点*头；
节点*尾部；
节点*split（）
{
节点*手指=头部；
节点*fast=head->next；
while（快速！=NULL）
{
快速=快速->下一步；
如果（快速！=NULL）
{
快速=快速->下一步；
手指=手指->下一步；
}
}
尾巴=手指->下一步；
节点*splitB=尾部；
splitB->prev=NULL；
finger->next=NULL；
返回splitB；
}
节点*合并（节点*a、节点*b）
{
链接列表m；
而（a！=NULL | | b！=NULL）
{
如果（b==NULL）
{
如果（m.head！=NULL）
{
a->prev=m.tail；
m、 tail->next=a；
m、 尾=a；
}
其他的
{
m、 水头=a；
m、 尾=米头；
}
a=a->next；
}
else if（a==NULL）
{
如果（m.head！=NULL）
{               
b->prev=m.tail；
m、 tail->next=b；
m、 尾=b；
}
其他的
{
m、 水头=b；
m、 尾=米头；
}
b=b->next；
}
else if（a->datadata）
{
如果（m.head==NULL）
{
m、 水头=a；
m、 尾=米头；
}
其他的
{
a->prev=m.tail；
m、 tail->next=a；
m、 尾=a；
}
a=a->next；
}
其他的
{
如果（m.head==NULL）
{
m、 水头=b；
m、 尾=米头；
}
其他的
{
b->prev=m.tail；
m、 tail->next=b；
m、 尾=b；
}
b=b->next；
}
}
返回m.head；
}
节点*合并排序（节点*a）
{
if（head==NULL | | head->next==NULL）
{
返回a；
}
其他的
{
节点*b=split（）；
节点*右侧=合并排序（a）；
节点*左=合并排序（b）；
返回合并（右、左）；
}
}
公众：
linkedList（）
{
head=NULL；
tail=NULL；
}
无效推回（int x）
{
节点*baby=新节点（x）；
if（head==NULL）
{
头=婴儿；
尾巴=婴儿；
}
其他的
{
婴儿->上一个=尾巴；
尾巴->下一个=婴儿；
尾巴=婴儿；
}
}
void mergeSort（）
{
head=合并排序（head）；
}
bool empty（）
{
if（head==NULL）
返回true；
其他的
返回false；
}
int-pop（）
{
int popMe=头部->数据；
节点*deleteMe=头部；
if（head->next==NULL）
{
head=NULL；
tail=NULL；
删除删除我；
返回popMe；
}
其他的
{
头部=头部->下一步；
head->prev=NULL；
删除删除我；
返回popMe；
}
}
//试验
无效显示（）
{
节点*手指=头部；
while（finger！=NULL）
{
下一步是收集数据；
}
}
};

停止使用全局变量
删除函数前出现的所有变量声明。
仅依赖传递给函数的数据作为其参数

编辑

这里是对原始代码的（可能是最小的）修改，它不使用外部变量（除了无参数的

mergeSort（）

，如果您在一些

sortableList

类中实现代码，它应该是唯一的公共方法）。
代码也不使用

last

指针，也不使用

prev

链接，因为它们在

mergeSort

中不需要，并且在排序后可以很容易地重新构建（这里很容易指的是“在O（n）时间内”，只需沿着排序列表传递一次）

编辑2

您的

merge

例程似乎太长且过于复杂。请参阅下面的简短版本。它不是更可编辑吗

node * merge(node * a, node * b)
{
    // assert(a != NULL)
    // assert(b != NULL)

    node * head, * tail;

    if (a->data <= b->data)
        head = a, a = a->next;
    else
        head = b, b = b->next;
    tail = head;

    while (a != NULL && b != NULL)
    {
        if (a->data <= b->data)
            tail->next = a, a = a->next;
        else
            tail->next = b, b = b->next;
        tail = tail->next;
    }

    if (a != NULL)
        tail->next = a;
    else
        tail->next = b;

    return head;
}

这是如何在前向链接列表排序后恢复

prev

链接：

void restoreBacklinks()
{
    node * prev = NULL;

    for (node * p = head; p != NULL; p = p->next)
    {
        p->prev = prev;
        prev = p;
    }

    tail = prev;
}

void mergeSort()
{
    if (head != NULL)       // make sure list isn't empty
    {
        head = mergeSort(head);
        restoreBacklinks();
    }
}

---

要进行合并排序，必须将列表拆分。例如，总是头尾分开是没有意义的。它总是在整个列表上进行拆分，而不是列表中越来越小的部分。因此，您的拆分必须如下所示：

void split(node *& a, node *& b)
{
    node * finger = a;
    node * fast = a->next;
    while (fast != NULL)
    {
        fast = fast->next;
        if (fast != NULL)
        {
            fast = fast->next;
            finger = finger->next;
        }
    }
    b = finger->next;
    b->prev->next = NULL;
    b->prev = NULL; 
}

我建议将变量名

fast

和

finger

更改为更具描述性的名称

Merge和mergeSort将需要类似的修改

---

编辑岗位做C++的方式。很抱歉。

使用调试器逐行检查代码时，您观察到了哪些异常？还请提供一个复制您的问题的函数。

split（）

函数修改

tail

变量，但不声明它。变量在哪里定义？它可能是全球性的吗？在递归调用“<代码>合并”（或代码>）时，您是否考虑过重新分配值给全局<代码>尾部>代码>的结果？<代码>合并文件（）/代码>接收到要排序的列表的<代码> < < /代码>指针。但是，在函数中做出的第一个决定根本不取决于

a

！它基于某个外部变量

head

，它不需要与

a

有任何关系……我观察到

mergeSort

中的右侧或

b

变量没有被拆分，以此类推

void restoreBacklinks()
{
    node * prev = NULL;

    for (node * p = head; p != NULL; p = p->next)
    {
        p->prev = prev;
        prev = p;
    }

    tail = prev;
}

void mergeSort()
{
    if (head != NULL)       // make sure list isn't empty
    {
        head = mergeSort(head);
        restoreBacklinks();
    }
}

void split(node *& a, node *& b)
{
    node * finger = a;
    node * fast = a->next;
    while (fast != NULL)
    {
        fast = fast->next;
        if (fast != NULL)
        {
            fast = fast->next;
            finger = finger->next;
        }
    }
    b = finger->next;
    b->prev->next = NULL;
    b->prev = NULL; 
}