归并两个有序链表 将两个有序链表,合并成一个升序链表 ,把链表B的每一个节点都依次摘下来, 然后按照“插入排序”插入到链表A中 c语言

可以使用迭代的方法来实现，具体思路如下：

1. 定义一个新的链表C，用于存储合并后的链表。

2. 分别定义指向链表A和链表B的指针pA和pB，初始时分别指向链表A和链表B的头节点。

3. 遍历链表A和链表B，比较pA和pB指向的节点的值的大小，将较小的节点摘下来，插入到链表C中。

4. 如果链表A或链表B遍历完成后，将剩余的节点依次插入到链表C中。

5. 返回链表C的头节点。

代码实现如下：

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

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

// 创建链表节点
ListNode* createNode(int val) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

// 合并两个有序链表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    // 定义新链表C，并初始化
    ListNode* l3 = createNode(0);
    ListNode* p = l3;

    // 定义指向链表A和链表B的指针
    ListNode* pA = l1;
    ListNode* pB = l2;

    // 遍历链表A和链表B，比较节点值的大小，将较小的节点插入到链表C中
    while (pA != NULL && pB != NULL) {
        if (pA->val < pB->val) {
            p->next = pA;
            pA = pA->next;
        }
        else {
            p->next = pB;
            pB = pB->next;
        }
        p = p->next;
    }

    // 将剩余的节点插入到链表C中
    if (pA != NULL) {
        p->next = pA;
    }
    if (pB != NULL) {
        p->next = pB;
    }

    // 返回链表C的头节点
    return l3->next;
}

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

int main() {
    // 创建链表A
    ListNode* l1 = createNode(1);
    l1->next = createNode(2);
    l1->next->next = createNode(4);

    // 创建链表B
    ListNode* l2 = createNode(1);
    l2->next = createNode(3);
    l2->next->next = createNode(4);

    // 合并链表A和链表B
    ListNode* l3 = mergeTwoLists(l1, l2);

    // 打印合并后的链表
    printList(l3);

    return 0;
}

输出结果为：1 1 2 3 4 4。