关于#链表#的问题：c语言数据结构，将两个单链表合成一个单链表求集合（皆为非降序），希望给出可以在dev中运行的代码 并给出详细解释

c语言数据结构，将两个单链表合成一个单链表求集合（皆为非降序），希望给出可以在dev中运行的代码 并给出详细解释，请指教

#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
    int data;
    struct Node* next;
}Node_t;

//开辟节点并初始化
Node_t* AollcNode(int x)
{
    Node_t* p = (Node_t*)malloc(sizeof(Node_t));//新建一个节点
    //初始化
    p->data = x;
    p->next = NULL;
    return p;
}
//合并
void MergeList(Node_t* head, Node_t* head1, Node_t* head2)
{
    Node_t* p = head;
    Node_t* p1 = head1->next;//指向第一个节点
    Node_t* p2 = head2->next;//指向第一个节点
    while (p1 && p2)
    {
        if (p1->data <= p2->data)
        {
            p->next = p1;
            p1 = p1->next;
        }
        else
        {
            p->next = p2;         
            p2 = p2->next;
        }
        p = p->next;//指向新的节点，起到连接下一个节点的左右
    }
    //链表2还有数据
    if (p1 == NULL)
    {
        p->next = p2;
    }
    //链表1还有数据
    if (p2 == NULL)
    {
        p->next = p1;
    }
}


//尾插入创建链表
void InintList(Node_t* head, Node_t** end)
{
    int i = 0;
    int x = 0;
    Node_t* p = NULL;
    printf("输入链表长度:>");
    int n = 0;
    scanf("%d", &n);
    for (; i < n; i++)
    {
        scanf("%d", &x);
        p = AollcNode(x);
        (*end)->next = p;
        *end = p;
    }
}

void ShowNode(Node_t* head)
{
    Node_t* p = head->next;
    while (p)
    {
        printf("%d->", p->data);
        p = p->next;
    }
    printf("NULL\n");
}

int main()
{
    Node_t* head1 = AollcNode(0);
    Node_t* head2 = AollcNode(0);
    Node_t* head3 = AollcNode(0);//合并后的tou
    printf("初始化链表1\n");
    Node_t* end1 = head1;
    //因为要记录结尾，要改变尾指针的指向要传址调用
    InintList(head1, &end1);
    ShowNode(head1);

    printf("初始化链表2\n");
    Node_t* end2 = head2;
    //因为要记录结尾，要改变尾指针的指向要传址调用
    InintList(head2, &end2);
    ShowNode(head2);

    printf("合并后:>");
    MergeList(head3, head1, head2);
    ShowNode(head3);

    free(head1);
    free(head2);
    free(head3);
    head1 = NULL;
    head2 = NULL;
    head3 = NULL;


    return 0;
}

参考如下

#include  <stdio.h>
#define MAXSIZE 100
typedef int DataType;
typedef struct{
       DataType data[MAXSIZE];
       int last;
}Seqlist;

/**********************************/
/*函数名称：initseqlist()         */
/*函数功能：初始化顺序表          */
/**********************************/
void initseqlist(Seqlist *L)
{    L->last=0;
}

/**********************************/
/*函数名称：input()               */
/*函数功能：输入顺序表            */
/**********************************/
void input(Seqlist *L)
{      
    DataType x;
       initseqlist(L);
       char flag=0; 
       do
       {    
       scanf("%d",&x);
       L->data[L->last++]=x;
       flag=getchar();
    }while(flag!='\n');
}

/**********************************/
/*函数名称：print()               */
/*函数功能：输出顺序表            */
/**********************************/
void print(Seqlist *L)
{   
    int i;
    if(L->last==0)
        printf("顺序表为空\n");
    else
        for(i=0;i<L->last;i++)
            {      printf("%d ",L->data[i]);
            if((i+1)%10==0) printf("\n");
        }
    printf("\n");
}
void insert(Seqlist *L,int x)
{
    int i,j;
    for(i=0;i<L->last;i++)
    {
        if(L->data[i]>x)
        {
                for(j=L->last;j>i;j--)
                {
                    L->data[j]=L->data[j-1];
                }
                L->data[i]=x;
                L->last++;
            break;
        }
    }
}
void merge(Seqlist *LA,Seqlist *LB)
{
    int i,j,k;
    for(i=0;i<LB->last;i++)
    {
        insert(LA,LB->data[i]);
    }
}
int main()
{
    Seqlist LA,LB,LC;
    printf("请输入线性表LA：");
    input(&LA); 
    printf("请输入线性表LB：");
    input(&LB); 
    printf("合并后的有序线性表LA为：");
    merge(&LA,&LB);
    print(&LA);
    return 0;
}

先写一个链表插入节点的函数，然后遍历一个链表的所有节点，逐个调用插入节点函数

#include <stdio.h>
typedef struct _Node
{
    int data;
    struct _Node *next;
}Node,*linklist;

void insertNode(linklist head,int n)
{
    linklist p = (linklist)malloc(sizeof(Node));
    linklist q = head;
    p->data = n;
    p->next = NULL;
    while(q->next != NULL)
    {
        if(q->next->data >= n)
        {
            p->next = q->next;
            q->next = p;
            return;
        }
        q = q->next;
    }
    q->next = p;
}

void insertNode(linklist head,Node *node)
{
    linklist q = head;
    while(q->next != NULL)
    {
        if(q->next->data >= node->data)
        {
            node->next = q->next;
            q->next = node;
            return;
        }
        q = q->next;
    }
    q->next = node;
}

void print(linklist head)
{
    linklist p = head->next;
    while(p != NULL)
    {
        printf("%d ",p->data);
        p = p->next;
    }
}

int main()
{
    Node N1,N2,*p,*q;
    int n,m,i;
    N1.next = N2.next = NULL;
    printf("第一个链表长度:");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("请输入第%d个数值:",i+1);
        scanf("%d",&m);
        insertNode(&N1,m);
    }
    printf("第二个链表长度:");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("请输入第%d个数值:",i+1);
        scanf("%d",&m);
        insertNode(&N2,m);
    }
    p = N2.next;
    while(p!=NULL)
    {
        q = p->next;
        insertNode(&N1,p);
        p = q;
    }
    print(&N1);
    return 0;
}

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

typedef struct _Node
{
    int data;
    struct _Node *next;
} Node;

typedef struct _List
{
    Node *head;
    Node *tail;
} List;

Node *CreateNode(int x)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = NULL;
    return p;
}

List *CreateList()
{
    List *l = (List *)malloc(sizeof(List));
    l->head = NULL;
    l->tail = NULL;
    return l;
}

void DestroyList(List *l)
{
    Node *p = l->head;
    while (p)
    {
        Node *q = p;
        p = p->next;
        free(q);
    }
    free(l);
}

void AppendList(List *l, int value)
{
    Node *p = CreateNode(value);
    if (l->tail)
    {
        l->tail->next = p;
        l->tail = p;
    }
    else
    {
        l->head = p;
        l->tail = p;
    }
}

void MergeList(List *l, const List *l1, const List *l2)
{
    const Node *p1 = l1->head;
    const Node *p2 = l2->head;
    while (p1 && p2)
    {
        if (p1->data <= p2->data)
        {
            AppendList(l, p1->data);
            p1 = p1->next;
        }
        else
        {
            AppendList(l, p2->data);
            p2 = p2->next;
        }
    }
    while (p1)
    {
        AppendList(l, p1->data);
        p1 = p1->next;
    }
    while (p2)
    {
        AppendList(l, p2->data);
        p2 = p2->next;
    }
}

void InputList(List *l)
{
    int x, n;
    printf("输入链表长度: ");
    scanf("%d", &n);
    printf("输入非降序链表数据: ");
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &x);
        AppendList(l, x);
    }
}

void PrintList(List *l)
{
    Node *p = l->head;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    List *l1 = CreateList();
    List *l2 = CreateList();
    List *l3 = CreateList();
    printf("初始化链表1\n");

    InputList(l1);
    PrintList(l1);

    printf("初始化链表2\n");

    InputList(l2);
    PrintList(l2);

    printf("合并后: ");
    MergeList(l3, l1, l2);
    PrintList(l3);

    DestroyList(l1);
    DestroyList(l2);
    DestroyList(l3);

    return 0;
}

从a.txt读取数据生成链表LA，从b.txt读取数据生成链表LB，然后对链表排序、合并，形成一个链表LC。
a.txt和b.txt中的数字以空格分隔，示例如下：
a.txt:

43 55 2 5 23 54 22 0 22 11

b.txt:

32 99 77 35 24 52 25

运行结果：

代码：

#include <iostream>
#include <fstream>
#include <stdlib.h>
using namespace std;
#define MAXSIZE 100
#define ERROR 0

typedef struct  
{
    int* elem; //记录所有的元素
    int length;
}sqlist;

//初始化链表
void InitList(sqlist &LA)
{
    LA.elem = new int[MAXSIZE];
    LA.length = 0;
}

//从文本文件中读取数字，并存入顺序表
void InputList(sqlist& LA,const char* filename)
{
    ifstream infile(filename); //读取
    if(!infile.is_open()) //判断文件是否打开
    {
        cout <<filename <<"打开失败！"<<endl;
        return;
    }
    //读取文件
    while(!infile.eof())
    {
        infile >> LA.elem[LA.length];
        LA.length++;
    }
    infile.close();
}

//采用冒泡排序算法，将链表中的元素排序
void SortList(sqlist &LA)
{
    int i,j,t;
    for(i=0;i<LA.length-1;i++)
    {
        for(j=0;j<LA.length-1-i;j++)
        {
            if(LA.elem[j] > LA.elem[j+1]) //从小到大排序，如果是从大到小，把>改成<即可
            {
                t = LA.elem[j];
                LA.elem[j] = LA.elem[j+1];
                LA.elem[j+1] = t;
            }
        }
    }
}

//合并两个链表，把链表合并到LC中，并按从小到大的顺序排列
void MergeList(sqlist LA,sqlist LB,sqlist &LC)
{
    int i=0,j=0,index = 0;
    while(i<LA.length && j<LB.length)
    {
        if(LA.elem[i] <= LB.elem[j])
            LC.elem[index++] = LA.elem[i++]; //把较小的值放入LC
        else if(LB.elem[i] < LA.elem[j])
            LC.elem[index++] = LB.elem[j++];
    }
    //把LA中剩余的部分放入LC
    while(i<LA.length)
        LC.elem[index++] = LA.elem[i++];

    //把LB中剩余的部分放入LC
    while(j<LB.length)
        LC.elem[index++] = LB.elem[j++];

    LC.length = LA.length + LB.length;
}

void PrintList(sqlist L)
{
    int i = 0;
    for(;i<L.length;i++)
    {
        if(i<L.length -1)
            cout << L.elem[i] <<" ";
        else
            cout << L.elem[i] <<endl;
    }
}

int main()
{
    sqlist LA,LB,LC; 
    const char* file1 = "a.txt"; //第一个文件的名字
    const char* file2 = "b.txt"; //第二个文件的名字
    //初始化
    InitList(LA);
    InitList(LB);
    InitList(LC);
    InputList(LA,file1); //读取文件
    InputList(LB,file2);
    cout <<"LA排序前："<<endl;
    PrintList(LA);
    cout <<"LB排序前："<<endl;
    PrintList(LB);
    //顺序表排序
    SortList(LA);
    SortList(LB);
    cout <<"LA排序后："<<endl;
    PrintList(LA);
    cout <<"LB排序后："<<endl;
    PrintList(LB);
    //合并LA和LB
    cout <<"合并LA和LB："<<endl;
    MergeList(LA,LB,LC);
    PrintList(LC);

    system("pause"); //暂停程序，避免一闪而过
    return 0;
}

1，按要求已实现代码，将以下代码拷贝到"main.cpp"文件中，在Dev C++下可以直接编译运行
2，代码中有详细的注释，题主可以参考实现过程

#include <stdio.h>
#include <malloc.h>

//构造结构体
typedef struct list
{
    int data;
    struct list* next;
}*List, LNode;

//函数声明
List init_list(List head, int num);
void print_list(List head);
List merge(List l1, List l2);

int main()
{
    List l, l1, l2;
    l1 = (LNode*)malloc(sizeof(LNode));
    l1 = init_list(l1, 2);//链表l1（非降序）初始化2个元素
    printf("L1元素如下：\n");
    print_list(l1);//打印l1元素

    l2 = (LNode*)malloc(sizeof(LNode));
    l2 = init_list(l2, 3);//链表l2（非降序）初始化3个元素
    printf("L2元素如下：\n");
    print_list(l2);//打印l2元素

    l = merge(l1, l2); //非降序合并L1和L2
    printf("合并后的元素如下：\n");
    print_list(l);//打印合并后的链表元素
    return  0;
}

//两个有序链表合并函数
List merge(List l1, List l2)
{
    List head, p, s;
    head = (List)malloc(sizeof(LNode));
    p = head;
    while (l1 != NULL || l2 != NULL)
    {
        s = (List)malloc(sizeof(LNode));
        if (l1 != NULL && l1->data <= l2->data)
        {
            s->data = l1->data;
            l1 = l1->next;
        }
        else
        {
            s->data = l2->data;
            l2 = l2->next;
        }
        s->next = NULL;
        p->next = s;
        p = p->next;
    }
    return head->next;
}

//链表初始化函数
List init_list(List head, int num)
{
    int i = 1;
    List p = head;
    while (i <= num)
    {
        List s;
        s = (LNode*)malloc(sizeof(LNode));
        s->data = i * num;
        s->next = NULL;
        p->next = s;
        p = p->next;
        i++;
    }
    return head->next;
}

//链表输出函数
void print_list(List head)
{
    List p;
    p = head;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}