定义：

struct node {
    
    int data;
    node* next;

};

新建有头指针的链表：

struct node *head;
head = NULL;//头指针初始为空
struct node *p;
//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
p=(struct node *)malloc(sizeof(struct node));
scanf("%d",&a);
p->data=a;//将数据存储到当前结点的data域中
p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空

完整版本：

#include <stdio.h>
#include <stdlib.h>
//这里创建一个结构体用来表示链表的结点类型
struct node
{
    
int data;
struct node *next;
};
int main()
{
    
struct node *head,*p,*q,*t;
int i,n,a;
scanf("%d",&n);
head = NULL;//头指针初始为空
for(i=1;i<=n;i++)//循环读入n个数
{
    
scanf("%d",&a);
//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
p=(struct node *)malloc(sizeof(struct node));
p->data=a;//将数据存储到当前结点的data域中
p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空
if(head==NULL)
head=p;//如果这是第一个创建的结点，则将头指针指向这个结点
else
q->next=p;//如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点
q=p;//指针q也指向当前结点
}
//输出链表中的所有数
t=head;
while(t!=NULL)
{
    
printf("%d ",t->data);
t=t->next;//继续下一个结点
}
getchar();getchar();
return 0;
}

合并采用先分别升序后再进行合并两个有序链表，分别升序采用双指针和递归调用。先看用归并排序：

用归并排序：

node* merge(node* p,node*p2) {
    //这里是合并的排序
    node* src = new node;
 src->next = nullptr;
    //src->data = 0;
    node* now = src;
    node* a1 = p;
    node* a2 = p2;
    while (a1 != NULL && a2 != NULL) {
    
        if (a1->data >= a2->data) {
    
            node* tem = a2->next;
            src->next = a2;
            a2 = tem;
        }
        else {
    
            node* tem = a1->next;
            src->next = a1;
            a1 = tem;
        }
        src = src->next;//合并两个有序链表 src->next=nullptr
    }
    if (a1 != NULL) src->next = a1;
    if (a2 != NULL)src->next = a2;
    return now->next;


}
node* merge_sort(node* p) {
    //这是将一个链表进行升序
    if (p == nullptr || p->next == nullptr) return p;
    node* fast = p;
    node* slow = new node;
    slow->data = 0;
    slow->next = p;

    while (fast != NULL && fast->next != NULL) {
    
        fast = fast->next->next;
        slow = slow->next;
    }
    node* rhead = slow->next;
    slow->next = NULL;
    node* lh = merge_sort(p);

    node* rh = merge_sort(rhead);
  
    node* after = merge(lh, rhead);
    return after;
}
int main()
{
    
    srand(0);
    node* m = new node;
   
    m->data = rand()%5;
    //cout << m->data;
    node* n = new node;
    n->data = rand()%7;
    m->next = n;
    
    node* nn = new node;
 
    nn->data = rand()%8;
    n->next = nn;
    nn->next = nullptr;
    node* copy_m = m;
    cout << "第一个链表：";
    while (copy_m) {
    
        cout << copy_m->data;
        copy_m = copy_m->next;
    }
    cout << endl;
    node* m2 = new node;
    m2->data =rand()%18;
    
    node* n2 = new node; 
    n2->data = rand() % 13;
    m2->next = n2;

    node* nn2 = new node;

    nn2->data = rand()%15;
    n2->next = nn2;
    nn2->next = nullptr;
    node* copy_n = m2;
    cout << "第二个链表：";
    while (copy_n) {
    
        cout << copy_n->data;
        copy_n = copy_n->next;
    }
    cout << endl;
   node*one = merge_sort(m);

   node*two= merge_sort(m2);
    node* new_m = merge(one,two);
    node* nice = new_m;
    cout << endl;
    cout << "合并两个有序链表后的结果：";
    while (nice) {
    
       
        cout << nice->data << "->";
        nice = nice->next;
    }
}

结果：

用冒泡排序：

node* merge_sort(node* p) {
    //这是将一个链表进行升序
    if (p == nullptr || p->next == nullptr) return p;
    node* mana = p;
    
    node* pp = mana;
  
    for (int i = 0; i < len(p) - 1; i++) {
    
        mana = p;
        for (int j = 0; j < len(p) - i - 1; j++) {
    
            node* t1 = mana;
            node* t2 = mana->next;
            if (t1->data > t2->data) {
    
                int tem = t1->data;
                t1->data = t2->data;
                t2->data = tem;
            }
            mana = mana->next;
        }
    }
    return pp;
}

int main()
{
    
    srand(0);
    node* m = new node;
   
    m->data = rand()%12;
    //cout << m->data;
    node* n = new node;
    n->data = rand()%17;
    m->next = n;
    
    node* nn = new node;
 
    nn->data = rand()%18;
    n->next = nn;
   

    node* nnn = new node;

    nnn->data = rand() % 23;
    nnn->next = NULL;
    nn->next = nnn;
    node* copy_m = m;
    cout << "第一个链表：";
    while (copy_m) {
    
        cout << copy_m->data<<"-";
        copy_m = copy_m->next;
    }
    cout << endl;
    node* m2 = new node;
    m2->data =rand()%18;
    
    node* n2 = new node; 
    n2->data = rand() % 13;
    m2->next = n2;

    node* nn2 = new node;

    nn2->data = rand()%15;
    n2->next = nn2;
    nn2->next = nullptr;
    node* copy_n = m2;
    cout << "第二个链表：";
    while (copy_n) {
    
        cout << copy_n->data << "-";
        copy_n = copy_n->next;
    }
    cout << endl;
   node*one = merge_sort(m);

   node*two= merge_sort(m2);
    node* new_m = merge(one,two);
    node* nice = new_m;
    cout << endl;
    cout << "合并两个有序链表后的结果：";
    while (nice) {
    
       
        cout << nice->data << "->";
        nice = nice->next;
    }
}