如何删除C 圆形列表中最高发现元素旁边的元素

在提议的算法中，小错误做错了结果。

错误1 - 最大的，在最后一个loop中，tmp2未初始化。

初始化tmp2 = head而不是tmp3 = head;。

tmp2 = head; // initialize tmp2
while (position<index - 1)
{
    tmp2 = tmp2->next;
    position++;
}
tmp3 = tmp2->next;

错误2 - 从position等于1开始会太早停止循环。

使用第一个 position = 1与while条件(position < index - 1)将循环减少2个步骤。

int position = 0;

错字错误 - 在if (index == 0)条件下，缺失的半列。

行代码head = head->next不会以;结束。

在if (index == 0)的条件下，return退出该功能，或通过将最后一部分插入else { ... }条件。

if (index == 0)
{
    tmp2 = head;
    head = head->next;
    delete tmp2;
    // EXIT by return
}

添加n°1>>>>

错误3 - 案例if (index == 0)是不可能的

尝试删除圆形链接列表的第一个节点 最大值放在最后一个节点中。

• 仅当if (counter == index)时，值index = 0;才有可能。但是在do-while中，在将最大值的位置存储在index = counter;中后，counter是递增的counter++;。

修改如下：

if (counter == (index+1)) // detecting the last position
    index = 0;    //if last element is the maximum, first one will be deleted
else
    index++; // incrementing to get index of the next element after maximum

• 但是要删除第一个节点，if (index == 0)的提议算法不起作用，因为必须存储以前的节点。

解决方案 - 最好的解决方案是强迫最后一个loop通过执行以下更改，以便再继续一步：

if (index == 0)
{
    index = counter;
}

然后允许(index == counter)与：

if ((index>0) && (index<=counter)) // allow for the last
{
    tmp2 = head;
    while (position<index - 1)

以及删除tmp3节点之前，请在tmp3 == head时修改head：

    tmp3 = tmp2->next;
    tmp2->next = tmp3->next;
    if (head==tmp3) { // when the node to delete is the head
        head = head->next; // shift head to the next node
    }
    delete tmp3;

添加n°2>>>>

output - 使用建议的值列表时获得的结果。

第一个元素6是已删除（最后一个元素的下一个元素 18在圆形链接列表中）。

[ 6, 9, 13, 12, 1, 10, 15, 4, 6, 18, ].
Biggest value on the list: 18
[ 9, 13, 12, 1, 10, 15, 4, 6, 18, ].

添加n°3>>>>

这是函数Delete_After_Max()的完整源代码：

void Delete_After_Max(node* & head)
{
    node * tmp = head;
    int counter = 0, index = 0;
    double maximum = -1;
    if (tmp) // checking if the list is not empty
    {
        do
        {
            if (tmp->data>maximum)
            {
                maximum = tmp->data;
                index = counter;
            }
            counter++;
            tmp = tmp->next;
        } while (tmp != head);
    }
    std::cout << "Biggest value on the list: " << maximum << "n";
    if (counter == (index+1))
        index = 0;    //if last element is the maximum, first one will be deleted
    else
        index++; // incrementing to get index of the next element after maximum
    node *tmp2 = NULL;
    //checking if the highest element was last(then we delete first one)
    if (index == 0)
    {
        tmp2 = head;
        std::cout << tmp2->data << ", ";
        index = counter;
        //head = head->next;
        //delete tmp2;
        // EXIT
    }
    // checking if the highest element was somewhere else
    node *tmp3 = NULL;
    int position = 0; // ERROR 1;
    // if ((index>0) && (index<counter))
    if ((index>0) && (index<=counter))
    {
        // ERROR tmp3 = head;
        tmp2 = head;
        while (position<index - 1)
        {
            tmp2 = tmp2->next;
            position++;
        }
        tmp3 = tmp2->next;
        tmp2->next = tmp3->next;
        if (head==tmp3) {
            head = head->next;
        }
        delete tmp3;
    }
}

添加N°4>>>>

在更新的函数中 Delete_After_Max()显示了bellow逻辑以删除节点的最大值是错误的。

bool Delete_After_Max(node* & head)
{
    node *maxi=Find_Maximum(head);
    std::cout << "Biggest value on the list: " << maxi->data << "n";
    if(!Is_Empty) // !Is_Empty because this function is not working properly so i had to negate it until i find out why ;)
    {
        cout<<"the list is empty";
        return false;
    }
    else
    {
        node *tmp3=NULL;
        node *tmp2=maxi->next;
        tmp3=tmp2->next;
        tmp2->next=tmp3->next;
        if (head==tmp3) {
            head = head->next;
        }
        delete tmp3;
        cout<<"one element deleted";
        return true;
    }
}

1. 如果maxi指向具有最大值的节点，则要删除的节点为maxi->next（而不是调用tmp2，我们将其称为node_to_delete）。
2. 在删除node_to_delete之前，有必要将节点maxi与node_to_delete之后的节点连接（而不是调用tmp3，我们将其称为node_after_delete）。
3. 如果node_to_delete是head，则有必要在删除之前使用其下一个节点更新head。

然后，函数的新删除部分变为：

// Step 1
node *node_to_delete = maxi->next;
// Step 2
node *node_after_delete = node_to_delete->next;
maxi->next = node_after_delete;
// Step 3
if (node_to_delete == head) {
    head = head->next;
}
delete node_to_delete;

因此，功能Delete_After_Max()中的逻辑错误是：

1. 节点maxi与节点node_after_delete（tmp3）==> maxi->next=tmp3;而不是tmp2->next=tmp3->next;，
之间的不良连接
2. 节点node_to_delete（tmp2）==> if (head==tmp2)和delete tmp2;而不是if (head==tmp3)和delete tmp3;