编写程序,建立2个带头结点单链表,输入若干整数将正整数插入第1个单链表,将负整数插入第2个单链表,插入前和插入后单链表保持递增或相等次序,显示2个单链表,最后销毁。程序不可存在内存泄漏。
时间: 2023-06-05 12:47:42 浏览: 245
题目描述:编写程序,建立2个带头结点单链表,输入若干整数将正整数插入第1个单链表,将负整数插入第2个单链表,插入前和插入后单链表保持递增或相等次序,显示2个单链表,最后销毁证明。程序不可存在内存泄漏。
这道题目要求我们建立两个带头结点的单链表,一个存放正整数,一个存放负整数。输入数值时,若为正数,则插入第一个单链表中;若为负数,则插入第二个单链表中。插入之前要判断保持递增或相等次序。同时,最后我们要销毁两个单链表,证明程序不会存在内存泄漏的问题。
相关问题
编写程序,建立2个带头结点单链表,输入若干整数将正整数插入第1个单链表,将负整数插入第2个单链表,插入前和插入后单链表保持递增或相等次序,显示2个单链表,最后销毁。程序不可存在内存泄漏。)建立2个单链表基础上,设计和实现就地逆置单链表函数,即利用原单链表结点建立元素次序相反的单链表。编写程序,建立2个单链表,就地逆置这2个单链表,显示逆置前后的各单链表。注意不可存在内存泄漏。
以下是代码实现:
```c
#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;
}
```
关于避免内存泄漏的问题,我们在销毁链表时需要逐个释放每个节点的内存,否则会造成内存泄漏。
阅读全文