C++ 递归地从双链表中删除第n个位置的节点？（C+；+；）

我一直在尝试一些算法，在我的双链表代码中，我希望能够递归地删除第n个位置的节点。我自己也尝试过这样做，但我似乎找不到一种有效的递归方法。如果有人能帮我这么做，那就太好了。这是我到目前为止的代码

此外，我还知道我的delete函数的当前代码只适用于单链接列表。我自己发现了这一点，并将其作为占位符放在那里/与我在下面编写的代码混在一起

#include <cctype>

using namespace std;

struct Node{

  int data;
  Node* next;
  Node* prev;

};

Node* add(Node* head, int data);
void display(Node* head);
void displayReverse(Node* head);
Node* deleteNode(Node* head, int pos, Node* delNode);

int main(){


  Node* head = NULL;

  head = add(head, 1);
  head = add(head,2);
  head = add(head, 3);
  head = add(head, 4);
  head = add(head, 5);

  display(head);
  cout<<endl;
  displayReverse(head);

  cout<<endl;
  int del;
  cout<<"pos to delete: ";
  cin>>del;

  Node* delNode = NULL;
  head = deleteNode(head, del, delNode);
  display(head);
  return 0;
}

Node* add(Node* head, int data){

  if(head==NULL){ //if list is empty
    
    Node* newNode = new Node;
    newNode->data = data;
    newNode->next = NULL;
    newNode->prev = NULL;
    return newNode;
  }
  else if(head!=NULL && head->next == NULL){ //if the head points to a node that has a next that is not empty, but the node at the next is empty, then add to the end of list

    Node* newNode = new Node;
    head->next = newNode;
    newNode->data = data;
    newNode->next = NULL;
    newNode->prev = head;
  }
  else{ //if the head does not equal null, and the head next does not equal null either

    head->next = add(head->next, data);
  }
  return head;

}

void display(Node* head){

  if(head!=NULL){

    cout<<head->data<<" ";
    display(head->next);
    
  }
  return;
  

}

void displayReverse(Node* head){ //checks if the nodes are actually linked (this implementation works)

  while(head->next!=NULL){
    head = head->next;
  }

  while(head!=NULL){
    cout<<head->data<< " ";
    head = head->prev;

  }

}


Node* deleteNode(Node* head, int pos, Node* delNode){

  if(pos = 1){

    delNode = head->next;
    delete head;
    return delNode;

  }
  else{

    head->next = deleteNode(head->next, pos-1, delNode);
    return head;
  }


}

#包括
使用名称空间std；
结构节点{
int数据；
节点*下一步；
节点*prev；
};
节点*添加（节点*头，整数数据）；
无效显示（节点*头部）；
无效显示反向（节点*头部）；
节点*删除节点（节点*头部、内部位置、节点*删除节点）；
int main（）{
Node*head=NULL；
头=添加（头，1）；
头=添加（头，2）；
头=添加（头，3）；
头=添加（头，4）；
头部=增加（头部，5）；
显示器（头部）；
coutnext==NULL）{//如果头指向一个节点，该节点的下一个节点不是空的，但下一个节点是空的，则添加到列表的末尾
Node*newNode=新节点；
head->next=newNode；
新建节点->数据=数据；
newNode->next=NULL；
newNode->prev=头部；
}
else{//如果head不等于null，那么head next也不等于null
head->next=添加（head->next，数据）；
}
回流头；
}
无效显示（节点*头部）{
if（head！=NULL）{
coutnext；
}
while（head！=NULL）{
coutnext；
删除标题；
返回节点；
}
否则{
head->next=deleteNode（head->next，位置1，delNode）；
回流头；
}
}

从双链接列表中递归删除

n

th节点：

• 维持柜台
• 若计数器小于要删除的节点的位置，则
  • 递增计数器并递归调用delete函数，并传递列表中当前处理节点的下一个
  • 将delete函数的返回值赋给当前处理节点的下一个指针
  • 重置delete函数返回的节点的上一个指针
  • 返回当前处理节点
• 如果计数器等于表示要从列表中删除当前节点的位置
  • 记录当前处理节点的下一个节点
  • 将当前处理节点的下一个和上一个链接重置为

    NULL

  • 取消分配当前处理节点
  • 重置计数器，使

    （计数器==位置）

    条件在进一步迭代中失败
  • 返回记录的节点

实施：

Node* deleteNode (Node* head, int pos) {
    static int cnt;

    if (head == NULL) {
        return NULL;
    }

    if (++cnt < pos) {
        head->next = deleteNode (head->next, pos);
        if (head->next) {
            // reset the pointer
            head->next->prev = head;
        }
    }

    if (cnt == pos) {
        Node *tmp = head->next;
        head->prev = NULL;
        head->next = NULL;
        free (head);
        // reset counter
        cnt = 0;
        if (tmp) {
            tmp->prev = NULL;
        }
        return tmp;
    }

    return head;
}

对于无效位置：

# ./a.out
1 2 3 4 5 
5 4 3 2 1 
pos to delete: 8
1 2 3 4 5 

其他：

---

1） 。避免使用命名空间std添加

在您的程序中。检查。
为什么使用递归？马上就要进行测验，不允许迭代。我们只能使用LLs的递归实现函数（单、双、循环等）。我只是在准备。
# ./a.out
1 2 3 4 5 
5 4 3 2 1 
pos to delete: 8
1 2 3 4 5