c语言编程题经典100例——（56~60例）
1，实现链表中节点的比较。
在C语言中，链表是一种常见的数据结构，用于存储一系列的数据元素。每个节点包含数据和指向下一个节点的指针。比较两个链表节点的操作取决于具体需求。如果想比较两个节点中的数据，可以写一个函数来实现这个操作。
以下是一个简单的示例，该示例展示了如何比较两个链表节点：
#include
#include
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 比较两个节点的函数
int compareNodes(Node* node1, Node* node2) {
return node1->data - node2->data;
}
// 创建新节点的函数
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
if(newNode == NULL) {
printf("Memory allocation failed\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
int main() {
Node* node1 = createNode(10);
Node* node2 = createNode(20);
Node* node3 = createNode(30);
node1->next = node2;
node2->next = node3;
int result = compareNodes(node1, node3);
if(result < 0) {
printf("Node 1 is less than Node 3\n");
} else if(result > 0) {
printf("Node 1 is greater than Node 3\n");
} else {
printf("Node 1 is equal to Node 3\n");
}
return 0;
} 在这个示例中，首先定义了一个名为Node的结构体，用于表示链表的节点。然后创建了一个名为compareNodes的函数，该函数接收两个节点作为参数，并返回它们之间的差值。在主函数中，创建了三个节点并将它们连接起来形成一个链表。然后使用compareNodes函数比较了第一个节点和第三个节点，并打印出了相应的结果。
2，实现链表中节点的遍历。
在C语言中，遍历链表节点通常是通过一个循环来完成的，该循环从头节点开始，然后依次访问每个节点，直到到达链表的末尾。以下是一个简单的示例，展示了如何使用C语言实现链表中节点的遍历：
#include
#include
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 创建新节点的函数
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// 遍历链表节点的函数
void traverseList(Node* head) {
Node* current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}
int main() {
Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
printf("Traversing the linked list:\n");
traverseList(head);
return 0;
} 在这个示例中，首先定义了一个名为Node的结构体，用于表示链表的节点。然后创建了一个名为createNode的函数，该函数用于创建新的节点。接着定义了一个名为traverseList的函数，该函数接收一个头节点作为参数，并通过一个while循环来遍历链表中的每个节点。在循环中，打印出每个节点的数据，并将当前节点更新为下一个节点。最后，在主函数中，创建了一个包含5个节点的链表，并使用traverseList函数遍历了这些节点。
3，实现链表中节点的查找。
在C语言中，可以使用链表数据结构进行节点的查找。以下是一个简单的示例，展示了如何使用C语言实现链表中节点的查找：
#include
#include
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 创建新节点的函数
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// 在链表中查找节点的函数
Node* searchNode(Node* head, int data) {
Node* current = head;
while (current != NULL) {
if (current->data == data) {
return current;
}
current = current->next;
}
return NULL;
}
int main() {
Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
int target = 3;
Node* result = searchNode(head, target);
if (result != NULL) {
printf("Found node with data: %d\n", result->data);
} else {
printf("Node not found\n");
}
return 0;
} 在这个示例中，首先定义了一个名为Node的结构体，用于表示链表的节点。然后创建了一个名为createNode的函数，该函数用于创建新的节点。接着定义了一个名为searchNode的函数，该函数接收一个头节点和一个目标数据作为参数，并通过一个while循环来遍历链表中的每个节点。在循环中，检查当前节点的数据是否等于目标数据，如果是，则返回当前节点。如果循环结束仍未找到目标节点，则返回NULL。最后，在主函数中，创建了一个包含5个节点的链表，并使用searchNode函数查找目标数据。如果找到目标节点，则打印出该节点的数据；否则打印出“Node not found”。
4，实现链表中节点的插入。
在C语言中，可以通过链表结构体的指针来插入新的节点。以下是一个简单的示例，展示了如何在链表中插入新的节点：
#include
#include
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 创建新节点的函数
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// 在链表中插入新节点的函数
void insertNode(Node** head, int data) {
// 创建新节点
Node* newNode = createNode(data);
// 如果链表为空，将新节点设置为头节点
if (*head == NULL) {
*head = newNode;
return;
}
// 找到链表的末尾，并将新节点插入到末尾之后
Node* current = *head;
while (current->next != NULL) {
current = current->next;
}
current->next = newNode;
}
int main() {
Node* head = NULL; // 初始化链表为空
// 插入节点
insertNode(&head, 1);
insertNode(&head, 2);
insertNode(&head, 3);
insertNode(&head, 4);
insertNode(&head, 5);
// 遍历链表并打印节点的数据
Node* current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
return 0;
} 在这个示例中，首先定义了一个名为Node的结构体，用于表示链表的节点。然后创建了一个名为createNode的函数，该函数用于创建新的节点。接着定义了一个名为insertNode的函数，该函数接收一个指向头节点的指针和一个目标数据作为参数，并通过一个while循环来遍历链表，找到链表的末尾并将新节点插入到末尾之后。最后，在主函数中，初始化了一个空链表，并使用insertNode函数插入了5个节点。然后遍历链表并打印出每个节点的数据。
5，实现链表中节点的删除。
在C语言中，可以使用链表数据结构的指针来实现节点的删除。以下是一个简单的示例，展示了如何使用C语言实现链表中节点的删除：
#include
#include
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 创建新节点的函数
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// 删除链表中节点的函数
void deleteNode(Node** head, int data) {
// 如果链表为空，则直接返回
if (*head == NULL) {
return;
}
// 如果要删除的节点是头节点
if ((*head)->data == data) {
Node* temp = *head;
*head = (*head)->next;
free(temp);
return;
}
// 查找要删除的节点并删除它
Node* current = *head;
while (current->next != NULL && current->next->data != data) {
current = current->next;
}
if (current->next != NULL) {
Node* temp = current->next;
current->next = current->next->next;
free(temp);
}
}
int main() {
Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
// 删除节点并打印链表数据
deleteNode(&head, 3);
Node* current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
return 0;
} 在这个示例中，首先定义了一个名为Node的结构体，用于表示链表的节点。然后创建了一个名为createNode的函数，该函数用于创建新的节点。接着定义了一个名为deleteNode的函数，该函数接收一个指向头节点的指针和一个目标数据作为参数，并删除链表中的目标节点。如果要删除的节点是头节点，则直接将头节点指向下一个节点，并释放原头节点的内存；否则，遍历链表查找目标节点，并将其删除。最后，在主函数中，创建了一个包含5个节点的链表，并使用deleteNode函数删除了其中一个节点。然后遍历链表并打印出每个节点的数据。