如何使用函数打印出单链表L

假设单链表的结构体定义为：

typedef struct node {
    int data;
    struct node *next;
} ListNode;

可以使用如下函数来打印单链表：

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

这个函数接收一个指向单链表头结点的指针，然后遍历整个链表，依次打印出每个节点的数据。最后在末尾加上一个换行符。

相关问题

用VS2010可以使用的C语言实现已知单链表L，L中的数据为{1，3，5，7，9，11，13，15}且有序。设计算法实现如下操作： （1）使用函数生成单链表L； （2）使用函数打印出L； （3）使用函数插入6、8、10，保证插入后仍旧有序。 （4）使用函数删除大于12的数； （5）使用函数查找6、8的位置（返回位置）。

好的，下面是可以在 VS2010 中使用的 C 语言实现代码：

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

// 定义单链表结构体
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

// 生成单链表
ListNode* createList() {
    int arr[] = {1, 3, 5, 7, 9, 11, 13, 15};
    int n = sizeof(arr) / sizeof(int);
    ListNode *head = (ListNode*)malloc(sizeof(ListNode));
    head->val = arr[0];
    head->next = NULL;
    ListNode *tail = head;
    for (int i = 1; i < n; i++) {
        ListNode *node = (ListNode*)malloc(sizeof(ListNode));
        node->val = arr[i];
        node->next = NULL;
        tail->next = node;
        tail = node;
    }
    return head;
}

// 打印单链表
void printList(ListNode *head) {
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
}

// 插入节点
void insertNode(ListNode *head, int val) {
    ListNode *node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    ListNode *p = head;
    while (p->next != NULL && p->next->val < val) {
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
}

// 删除节点
ListNode* deleteNode(ListNode *head, int val) {
    ListNode *p = head;
    while (p->next != NULL && p->next->val > val) {
        p = p->next;
    }
    if (p->next != NULL && p->next->val == val) {
        ListNode *q = p->next;
        p->next = q->next;
        free(q);
    }
    return head;
}

// 查找节点
int findNode(ListNode *head, int val) {
    int pos = 0;
    while (head != NULL) {
        pos++;
        if (head->val == val) {
            return pos;
        }
        head = head->next;
    }
    return -1;
}

int main() {
    // 生成单链表
    ListNode *head = createList();
    // 打印单链表
    printf("List: ");
    printList(head);
    // 插入节点
    insertNode(head, 6);
    insertNode(head, 8);
    insertNode(head, 10);
    // 打印单链表
    printf("List after insertion: ");
    printList(head);
    // 删除节点
    head = deleteNode(head, 13);
    head = deleteNode(head, 15);
    // 打印单链表
    printf("List after deletion: ");
    printList(head);
    // 查找节点
    int pos6 = findNode(head, 6);
    int pos8 = findNode(head, 8);
    printf("Position of 6: %d\n", pos6);
    printf("Position of 8: %d\n", pos8);
    return 0;
}

希望对您有帮助！

如何实现单链表L的遍历

单链表的遍历就是依次访问链表中的每个节点，并对每个节点进行某些操作。可以使用循环或递归的方式来实现单链表的遍历。

以下是使用循环实现单链表遍历的示例代码：

void traverseList(ListNode *L) {
    ListNode *p = L;
    while (p != NULL) {
        // 对节点p进行操作
        printf("%d ", p->data);
        p = p->next;
    }
}

这个函数接收一个指向单链表头结点的指针，然后使用一个指针 p 遍历整个链表。在循环中，对每个节点 p 进行某些操作，这里只是简单地打印出节点 p 的数据。最后，当 p 指向 NULL 时，遍历结束。

以下是使用递归实现单链表遍历的示例代码：

void traverseList(ListNode *p) {
    if (p == NULL) {
        return;
    }
    // 对节点p进行操作
    printf("%d ", p->data);
    traverseList(p->next);
}

这个函数也接收一个指向单链表头结点的指针，然后使用递归的方式遍历整个链表。在递归函数中，先判断当前节点 p 是否为 NULL，如果是，则直接返回。否则，对当前节点 p 进行某些操作，然后递归调用函数 traverseList(p->next) 遍历下一个节点。