编写一个单链表销毁代码

在编写单链表销毁（也称为内存释放）的代码时，我们需要遍历整个链表，并释放每个节点占用的内存空间。这里是一个基本的伪代码示例：

// 假设 Node 类有一个指向前一个节点的 next 变量和一个存储数据的数据域 data
class ListNode:
    def __init__(self, data=None):
        self.data = data
        self.next = None

def destroy_linked_list(head):
    if head is not None:
        # 首先处理头节点
        current = head
        while current is not None:
            # 释放当前节点的内存
            del current
            # 移动到下一个节点
            current = current.next
        # 头节点也被释放了，因为它们都在循环里
    else:
        print("链表为空，无需销毁")

# 调用 destroy_linked_list 函数并传入链表的头节点
head = ...  # 初始化链表
destroy_linked_list(head)

相关问题

编写C++程序，建立两个带头节点的单链表，输入若干整数，将正整数插入第一个单链表，将负整数插入第二个单链表，插入前和插入后单链表保持递增次序，打印这两个单链表，最后销毁。

编写C++程序，建立两个带头节点的单链表，实现将正整数插入第一个单链表，将负整数插入第二个单链表，并保持递增次序。以下是一个示例代码：

#include <iostream>
using namespace std;

// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 插入节点到链表中并保持递增次序
void insertNode(ListNode* head, int val) {
    ListNode* newNode = new ListNode(val);
    ListNode* cur = head;
    while (cur->next && cur->next->val < val) {
        cur = cur->next;
    }
    newNode->next = cur->next;
    cur->next = newNode;
}

// 打印链表
void printList(ListNode* head) {
    ListNode* cur = head->next;
    while (cur) {
        cout << cur->val << " ";
        cur = cur->next;
    }
    cout << endl;
}

// 销毁链表
void destroyList(ListNode* head) {
    ListNode* cur = head;
    while (cur) {
        ListNode* temp = cur;
        cur = cur->next;
        delete temp;
    }
}

int main() {
    // 建立两个带头节点的单链表
    ListNode* list1 = new ListNode(0);    ListNode* list2 = new ListNode(0);

    // 输入若干整数，将正整数插入第一个单链表，将负整数插入第二个单链表
    int num;
    cout << "请输入整数（输入0结束）：" << endl;
    cin >> num;
    while (num != 0) {
        if (num > 0) {
            insertNode(list1, num);
        } else {
            insertNode(list2, num);
        }
        cin >> num;
    }

    // 打印两个单链表
    cout << "第一个单链表：";
    printList(list1);    cout << "第二个单链表：";
    printList(list2);

    // 销毁两个单链表
    destroyList(list1);
    destroyList(list2);

    return 0;
}

要求建立两个带头结点的单链表。输入若干整数，将正整数插入第一个单链表，将负整数插入第二个单链表。在插入前和插入后，两个单链表都要保持递增或相等的次序。最后，显示两个单链表，并销毁它们。在编写程序时，需要注意避免内存泄漏的问题。

以下是建立两个带头结点的单链表的代码，实现了输入若干整数，将正整数插入第一个单链表，将负整数插入第二个单链表。在插入前和插入后，两个单链表都保持递增或相等的次序。最后，显示两个单链表，并销毁它们。

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

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

void insert(Node *head, int data) {
    Node *p = head;
    while (p->next != NULL && p->next->data < data) {
        p = p->next;
    }
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = p->next;
    p->next = newNode;
}

void printList(Node *head) {
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void destroyList(Node *head) {
    Node *p = head;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }
}

int main() {
    Node *head1 = (Node *)malloc(sizeof(Node));
    head1->next = NULL;
    Node *head2 = (Node *)malloc(sizeof(Node));
    head2->next = NULL;

    int n;
    printf("请输入整数个数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        int data;
        printf("请输入第%d个整数：", i + 1);
        scanf("%d", &data);
        if (data >= 0) {
            insert(head1, data);
        } else {
            insert(head2, data);
        }
    }

    printf("第一个单链表：");
    printList(head1);
    printf("第二个单链表：");
    printList(head2);

    destroyList(head1);
    destroyList(head2);

    return 0;
}

关于避免内存泄漏的问题，我们在销毁链表时需要逐个释放每个节点的内存，否则会造成内存泄漏。