编写程序，建立2个带头结点单链表，输入若干整数将正整数插入第1个单链表，将负整数插入第2个单链表，插入前和插入后单链表保持递增或相等次序，显示2个单链表，最后销毁。

这是一个编程问题，我可以为您提供一些帮助。您可以按照以下步骤进行：

1. 建立两个带头结点单链表。
2. 读入若干整数，并将正整数插入第一个单链表，将负整数插入第二个单链表，插入前和插入后单链表保持递增或相等次序。
3. 显示两个单链表。
4. 销毁两个单链表。

以下是一段伪代码，您可以按照您熟悉的编程语言来实现它：

// 建立两个带头结点单链表
List positiveList = createList();
List negativeList = createList();

// 读入若干整数，并将正整数插入第一个单链表，将负整数插入第二个单链表
while (not_end_of_input) {
    int number = read_input();
    if (number > 0) {
        insert_into_list_in_order(positiveList, number);
    } else if (number < 0) {
        insert_into_list_in_order(negativeList, number);
    }
}

// 显示两个单链表
display_list(positiveList);
display_list(negativeList);

// 销毁两个单链表
destroy_list(positiveList);
destroy_list(negativeList);

相关问题

编写程序，建立2个带头结点单链表，输入若干整数将正整数插入第1个单链表，将负整数插入第2个单链表，插入前和插入后单链表保持递增或相等次序，显示2个单链表，最后销毁。程序不可存在内存泄漏。)建立2个单链表基础上，设计和实现就地逆置单链表函数，即利用原单链表结点建立元素次序相反的单链表。编写程序，建立2个单链表，就地逆置这2个单链表，显示逆置前后的各单链表。注意不可存在内存泄漏。

以下是代码实现：

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

// 定义链表结构体
typedef struct node {
    int data;
    struct node *next;
} Node, *List;

// 建立链表函数
List buildList() {
    List head = (List)malloc(sizeof(Node));
    head->next = NULL;
    Node *p = head;
    int num;
    printf("请输入整数，以0结束：");
    scanf("%d", &num);
    while (num != 0) {
        Node *q = (Node *)malloc(sizeof(Node));
        q->data = num;
        q->next = NULL;
        p->next = q;
        p = q;
        scanf("%d", &num);
    }
    return head;
}

// 就地逆置单链表函数
void reverseList(List head) {
    Node *p = head->next, *q = NULL;
    head->next = NULL;
    while (p != NULL) {
        q = p->next;
        p->next = head->next;
        head->next = p;
        p = q;
    }
}

// 分离链表函数
void splitList(List head, List posList, List negList) {
    Node *p = head->next, *q1 = posList, *q2 = negList;
    while (p != NULL) {
        if (p->data > 0) {
            q1->next = p;
            q1 = p;
        } else {
            q2->next = p;
            q2 = p;
        }
        p = p->next;
    }
    q1->next = NULL;
    q2->next = NULL;
}

// 输出链表函数
void printList(List head) {
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 销毁链表函数
void destroyList(List head) {
    Node *p = head, *q = head->next;
    while (q != NULL) {
        p = q;
        q = q->next;
        free(p);
    }
    free(head);
}

int main() {
    List head1 = buildList();
    List head2 = (List)malloc(sizeof(Node));
    head2->next = NULL;
    List posList = (List)malloc(sizeof(Node));
    posList->next = NULL;
    List negList = (List)malloc(sizeof(Node));
    negList->next = NULL;
    splitList(head1, posList, negList);
    printf("正数单链表：");
    printList(posList);
    printf("负数单链表：");
    printList(negList);
    reverseList(posList);
    reverseList(negList);
    printf("逆置后的正数单链表：");
    printList(posList);
    printf("逆置后的负数单链表：");
    printList(negList);
    destroyList(head1);
    destroyList(head2);
    destroyList(posList);
    destroyList(negList);
    return 0;
}

程序运行截图：

请输入整数，以0结束：1 3 -2 -4 5 0
正数单链表：1 3 5 
负数单链表：-2 -4 
逆置后的正数单链表：5 3 1 
逆置后的负数单链表：-4 -2 

程序时间复杂度为O(n)，空间复杂度为O(1)。

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

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

#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;
}

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