单链表删除头结点c++

可以使用以下代码删除单链表的头结点：

if (head == NULL) {
    return NULL;
}
ListNode* newHead = head->next;
delete head;
return newHead;

其中，head 是指向头结点的指针，newHead 是指向新的头结点的指针。如果链表为空，则直接返回 NULL。否则，将 newHead 指向原头结点的下一个节点，然后删除原头结点，最后返回新的头结点。

相关问题

删除单链表（带头结点，头插入法建立单链表）的第i个结点，代码

以下是删除单链表的第i个结点的代码实现。其中，head为头结点指针，i为待删除结点的位置。

void deleteNode(ListNode* head, int i) {
    ListNode* p = head->next;
    ListNode* pre = head;
    int j = 1;
    while (p && j < i) {
        pre = p;
        p = p->next;
        j++;
    }
    if (!p || j > i) {
        cout << "删除位置无效" << endl;
        return;
    }
    pre->next = p->next;
    delete p;
}

思路解析：

从头结点的下一个节点开始循环查找，记录当前节点位置和前一个节点位置，直到找到待删除节点或者遍历完整个链表。

如果找到待删除节点，将前一个节点的next指向待删除节点的next，然后删除待删除节点。

如果没有找到待删除节点，说明删除位置无效，直接输出提示信息即可。

删除单链表（带头结点）中第一个最小值结点的代码

### 回答1：
以下是删除单链表中第一个最小值结点的代码：

void deleteMinNode(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    ListNode* pre = head;
    ListNode* cur = head->next;
    ListNode* minPre = pre;
    ListNode* minNode = cur;
    while (cur != NULL) {
        if (cur->val < minNode->val) {
            minNode = cur;
            minPre = pre;
        }
        pre = cur;
        cur = cur->next;
    }
    minPre->next = minNode->next;
    free(minNode);
}

希望能够帮到你！

### 回答2：
删除单链表中第一个最小值结点的代码可以分为以下几个步骤：

1. 首先，需要判断链表是否为空。如果链表为空，则直接返回，无需删除任何结点。
2. 定义两个指针变量cur和pre，分别指向当前结点和当前结点的前一个结点。初始化时，cur指向头结点的下一个结点，pre指向头结点。
3. 定义一个变量minValue，用来保存当前找到的最小值。
4. 遍历链表，找到最小值结点的过程如下：
a. 如果当前结点的值小于minValue，则更新minValue为当前结点的值。
b. 如果当前结点的值等于minValue，则将cur指向的结点从链表中删除，即令pre的next指针指向cur的next指针所指向的结点。
c. 否则，将pre指向cur，再将cur指向下一个结点。
5. 返回链表头结点。

下面是使用C语言描述的删除单链表中第一个最小值结点的代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node* deleteMinNode(Node* head) {
    if (head->next == NULL) {
        return head;
    }
    Node *pre = head;
    Node *cur = head->next;
    int minValue = cur->data;

    while (cur != NULL) {
        if (cur->data < minValue) {
            minValue = cur->data;
        }
        cur = cur->next;
    }

    cur = head->next;
    while (cur != NULL) {
        if (cur->data == minValue) {
            pre->next = cur->next;
            free(cur);
            break;
        }
        pre = cur;
        cur = cur->next;
    }

    return head;
}

int main() {
    // 创建链表
    Node *head = (Node *)malloc(sizeof(Node));
    head->next = NULL;
    Node *p = head;
    int n;
    printf("输入链表长度：");
    scanf("%d", &n);
    
    printf("输入链表元素：");
    for (int i = 0; i < n; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        scanf("%d", &(newNode->data));
        newNode->next = NULL;
        p->next = newNode;
        p = p->next;
    }

    // 调用删除最小值结点函数
    head = deleteMinNode(head);

    // 输出链表
    printf("删除最小值结点后的链表：");
    p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }

    // 释放链表内存
    p = head;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }

    return 0;
}

注意: 该代码中假设链表的元素都是整数。

### 回答3：
要删除单链表中第一个最小值结点，可以按照以下步骤编写代码：

1. 定义一个指针p，初始指向头结点的下一个结点，即第一个数据结点。
2. 定义两个辅助指针，minPrev和minNode，初始值都指向头结点。
3. 通过遍历链表，找到第一个最小值结点，并记录其前一个结点。
4. 如果找到最小值结点，则将其前一个结点的next指针指向最小值结点的下一个结点。
5. 释放最小值结点的内存空间，防止内存泄露。
6. 返回删除后的链表头结点。

以下是代码实现：

#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* deleteMinNode(ListNode* head) {
    if (!head || !head->next) {
        return head;
    }
    
    ListNode* p = head->next;
    ListNode* minPrev = head;
    ListNode* minNode = head->next;
    
    while (p) {
        if (p->val < minNode->val) {
            minPrev = p;
            minNode = p;
        } else {
            p = p->next;
        }
    }
    
    if (minNode != nullptr) {
        minPrev->next = minNode->next;
        delete minNode;
    }
    
    return head;
}

int main() {
    ListNode* head = new ListNode(-1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(-3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(0);
    
    ListNode* updatedHead = deleteMinNode(head);
    
    // 遍历输出链表的元素
    ListNode* p = updatedHead->next;
    while (p) {
        cout << p->val << " ";
        p = p->next;
    }
    
    // 释放链表的内存空间
    p = updatedHead;
    while (p) {
        ListNode* temp = p;
        p = p->next;
        delete temp;
    }
    
    return 0;
}

上述代码首先定义了一个单链表的结构体ListNode，每个结点包含一个整数值和一个指向下一个结点的指针。函数deleteMinNode的参数为头结点，返回删除第一个最小值结点后的链表头结点。在主函数中创建一个带头结点的单链表的示例，然后调用deleteMinNode函数删除单链表中第一个最小值结点，并输出删除后的链表元素。最后需要释放链表的内存空间，以防止内存泄露。