c语言编程题经典100例——（51~55例）

1,实现链表中节点的插入。

在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 insertAtEnd(Node** head, int data) {  
    Node* newNode = createNode(data);  
    if (*head == NULL) {  
        *head = newNode;  
        return;  
    }  
    Node* temp = *head;  
    while (temp->next != NULL) {  
        temp = temp->next;  
    }  
    temp->next = newNode;  
}

最后，我们可以编写一个简单的程序来测试这些功能：

int main() {  
    Node* head = NULL;  
    insertAtEnd(&head, 1);  
    insertAtEnd(&head, 2);  
    insertAtEnd(&head, 3);  
    // 打印链表中的数据  
    Node* temp = head;  
    while (temp != NULL) {  
        printf("%d ", temp->data);  
        temp = temp->next;  
    }  
    return 0;  
}

这个程序将创建一个包含三个节点的链表，并打印出链表中的数据。输出应该是：3 2 1 。这是因为我们是在链表的末尾插入新节点的，所以最后插入的节点（包含数据3）会位于链表的开头，而最先插入的节点（包含数据1）会位于链表的末尾。

2,实现链表中节点的反转。

要在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 printList(Node* head) {  
    Node* temp = head;  
    while (temp != NULL) {  
        printf("%d ", temp->data);  
        temp = temp->next;  
    }  
    printf("\n");  
}  
  
Node* reverseListIterative(Node* head) {  
    Node* prev = NULL;  
    Node* current = head;  
    Node* next = NULL;  
    while (current != NULL) {  
        next = current->next; // 保存下一个节点  
        current->next = prev; // 反转链接  
        prev = current;       // 移动 prev 和 current 一个步长  
        current = next;  
    }  
    return prev; // 当原始链表遍历完成时，prev 将指向反转链表的头节点  
}  
  
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("Original List: ");  
    printList(head); // 输出：1 2 3 4 5  
    head = reverseListIterative(head); // 反转链表  
    printf("Reversed List: ");  
    printList(head); // 输出：5 4 3 2 1  
    return 0;  
}

3,实现链表中节点的合并。

以下是使用C语言实现链表中节点合并的示例代码：

#include   
#include   
  
typedef struct Node {  
    int data;  
    struct Node* next;  
} Node;  
  
// 合并两个有序链表  
Node* merge(Node* l1, Node* l2) {  
    if (l1 == NULL) {  
        return l2;  
    }  
    if (l2 == NULL) {  
        return l1;  
    }  
    if (l1->data < l2->data) {  
        l1->next = merge(l1->next, l2);  
        return l1;  
    } else {  
        l2->next = merge(l1, l2->next);  
        return l2;  
    }  
}  
  
// 创建新节点  
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 printList(Node* head) {  
    Node* temp = head;  
    while (temp != NULL) {  
        printf("%d ", temp->data);  
        temp = temp->next;  
    }  
    printf("\n");  
}  
  
int main() {  
    Node* l1 = createNode(1);  
    l1->next = createNode(3);  
    l1->next->next = createNode(5);  
    printf("List 1: ");  
    printList(l1); // 输出：1 3 5   
    Node* l2 = createNode(2);  
    l2->next = createNode(4);  
    l2->next->next = createNode(6);  
    printf("List 2: ");  
    printList(l2); // 输出：2 4 6   
    merge(l1, l2); // 将两个有序链表合并成一个有序链表，输出：1 2 3 4 5 6   
    printf("Merged List: ");  
    printList(l1); // 输出：1 2 3 4 5 6   
    return 0;  
}

4,实现链表中节点的计数。

以下是使用C语言实现链表中节点计数的示例代码：

#include   
#include   
  
typedef struct Node {  
    int data;  
    struct Node* next;  
} Node;  
  
int countNodes(Node* head) {  
    int count = 0;  
    Node* current = head;  
    while (current != NULL) {  
        count++;  
        current = current->next;  
    }  
    return count;  
}  
  
// 创建新节点  
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* head = createNode(1);  
    head->next = createNode(2);  
    head->next->next = createNode(3);  
    head->next->next->next = createNode(4);  
    printf("Number of nodes in the linked list: %d\n", countNodes(head)); // 输出：4  
    return 0;  
}

在上面的代码中，我们定义了一个countNodes函数，该函数接受链表的头节点作为参数，并返回链表中节点的数量。我们使用一个计数器变量count来计算链表中节点的数量，通过遍历链表中的每个节点并将计数器递增来实现。最后，我们返回计数器的值。我们还定义了一个辅助函数createNode来创建新节点，并在主函数中创建了一个简单的链表来测试countNodes函数。

5,实现链表中节点的复制。

以下是使用C语言实现链表中节点复制的示例代码：

#include   
#include   
  
typedef struct Node {  
    int data;  
    struct Node* next;  
} Node;  
  
Node* copyList(Node* head) {  
    if (head == NULL) {  
        return NULL;  
    }  
    Node* current = head;  
    Node* newHead = NULL;  
    Node* newCurrent = NULL;  
    while (current != NULL) {  
        Node* newNode = (Node*)malloc(sizeof(Node));  
        newNode->data = current->data;  
        newNode->next = NULL;  
        if (newHead == NULL) {  
            newHead = newNode;  
            newCurrent = newHead;  
        } else {  
            newCurrent->next = newNode;  
            newCurrent = newCurrent->next;  
        }  
        current = current->next;  
    }  
    return newHead;  
}  
  
void printList(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);  
    printf("Original List: ");  
    printList(head); // 输出：1 2 3 4   
    Node* newHead = copyList(head);  
    printf("Copied List: ");  
    printList(newHead); // 输出：1 2 3 4   
    return 0;  
}

在上面的代码中，我们定义了一个copyList函数，该函数接受链表的头节点作为参数，并返回复制后链表的头节点。我们使用一个指针变量current来遍历原始链表，同时使用另一个指针变量newHead和newCurrent来记录复制后链表的头节点和当前节点。在遍历原始链表时，我们为每个节点创建一个新节点，并将数据复制到新节点中。然后，我们将新节点添加到复制后链表的尾部。最后，我们返回复制后链表的头节点。我们还定义了一个辅助函数createNode来创建新节点，并在主函数中创建了一个简单的链表来测试copyList函数。