数据结构：单链表的上机作业

最新推荐文章于 2024-08-16 08:54:14 发布

金汤肥牛粉面菜蛋

最新推荐文章于 2024-08-16 08:54:14 发布

阅读量196

点赞数 1

文章标签：数据结构

本文链接：https://blog.csdn.net/2302_79492138/article/details/139475541

版权

华中科技大学

教授刘干

01单链表逆置

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
void reverse(LinkList L);

int main(void){
    LinkList A;
    int c;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);
    reverse(A);
    Display(A);
}


void reverse(LinkList L){
    LNode p,q,r;
    p=L->next;
    if(p==NULL||p->next==NULL)
	{printf("No reverse needed!\n");
		return;
    }
    q=p->next;
    p->next=NULL;
    while(q){
        r=q->next;
        q->next=p;
        p=q;
        q=r;
    }
    L->next=p;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

02找单链表的中点

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L,LNode p);


int main(void){
    LinkList A;
    Lnode* x;
    int y,c;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    x=A->next;
    Display(A);
    y=function1(A,x);
    printf("%d,%p",y,x);
}

int function1(LinkList L,LNode p){
    int i;
    i=ListLength(L);
    for(int j=0;j<i/2;j++){
        p=p->next;
    }
    return p->data;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

03找到单链表倒数第K个节点

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L,LNode p,int k);


int main(void){
    LinkList A;
    Lnode* x;
    int y,c,a;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    printf("您要找列表的倒数第几个节点:");
    scanf("%d",&a);
    A=InitList();
    Build(A,c);
    x=A->next;
    Display(A);
    y=function1(A,x,a);
    printf("%d,%p",y,x);
}

int function1(LinkList L,LNode p,int k){
    int i;
    i=ListLength(L);
    for(int j=0;j<i-k;j++){
        p=p->next;
    }
    return p->data;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

04删除单链表的倒数第K个节点

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L,int k);


int main(void){
    LinkList A;
    int c,a;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    printf("您要找列表的倒数第几个节点:");
    scanf("%d",&a);
    A=InitList();
    Build(A,c);
    Display(A);
    function1(A,a);
    Display(A);
}

int function1(LinkList L,int k){
    int i;
    LNode p,q;
    p=L->next;
    i=ListLength(L);
    for(int j=0;j<i-k-1;j++){
        p=p->next;
    }
    q=p->next;
    p->next=q->next;
    free(q);
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

05 判断单链表是否有环，如果有，找出交点

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L);
void function2(LinkList A,int i,LinkList B,int j);
//将A的第i个节点指向B节点的第j个节点


int main(void){
    LinkList A;
    int c,m,n;

    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);

    printf("让A的第几个节点指向第几个节点(格式:2,3):");
    scanf("%d,%d",&m,&n);
    function2(A,m,A,n);
    printf("\n");
    (void)function1(A);

    
}

int function1(LinkList L){
    LNode fast,slow;
    int i=0;
    fast=L->next;
    slow=L->next;

    while(fast&&slow)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow){
            i=1;
            break;
        }
    }
    if(i==0){
        printf("没有环");
    }
    else{
        fast=L->next;
        while(fast!=slow)
    {
        fast=fast->next;
        slow=slow->next;
    }
    printf("有环，环处的数值为%d,地址为%p;",fast->data,fast);
    }
}


void function2(LinkList A,int i,LinkList B,int j){
    if(i==0&&j==0)return;
    LNode p,q;
    int m,n;
    p=A;
    q=B;
    for(m=i;m>0;m--){
    p=p->next;
    }
    for(n=j;n>0;n--){
    q=q->next;
    }
    p->next=q;
    printf("交点处的节点的数值为%d,地址为%p",q->data,q);
}


//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

06 判断两个单链表是否相交，若相交找出交点

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L,LinkList M);
void function2(LinkList A,int i,LinkList,int j);
//将A的第i个节点指向B节点的第j个节点

int main(void){
    LinkList A,B;
    int c,d,m,n;

    printf("请输入您的A列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);

    printf("请输入您的B列表所需要的节点数:");
    scanf("%d",&d);
    B=InitList();
    Build(B,d);
    Display(B);



    printf("让A的第几个节点指向B第几个节点(格式:2,3):");
    scanf("%d,%d",&m,&n);
    function2(A,m,B,n);

    Display(A);
   
    (void)function1(A,B);

}

int function1(LinkList L,LinkList M){
    int i,j,n,k=0;
    LinkList q,r;
    q=L->next;
    r=M->next;
    i=ListLength(L);
    j=ListLength(M);

    if(i<j){
        n=j-i;
        for(n;n>0;n--){
            r=r->next;
        }
    }

    else{
        n=i-j;
        for(n;n>0;n--){
            q=q->next;
        }
    }

    while(q&&r){
            if(q==r){
                k=1;
                break;
            }
            q=q->next;
            r=r->next;
        }

    if(k==0){
        printf("没有相交");
    }
    else{
        if(k==1){
            printf("相交了，交点处的值为%d,地址为%p:",q->data,q->next);
        }
    else{
        printf("error");

    }
    }
}    

void function2(LinkList A,int i,LinkList B,int j){
    if(i==0&&j==0)return;
    LNode p,q;
    p=A;
    q=B;
    for(i;i>0;i--){
    p=p->next;
    }
    for(j;j>0;j--){
    q=q->next;
    }
    p->next=q;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

07 对于有序单链表，删除重复节点（保留一个）

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L);


int main(void){
    LinkList A;
    int c;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);
    (void)function1(A);
    Display(A);
}

int function1(LinkList L){
    LNode p,q;
    p=L;
    while(p->next->next){
        if(p->next->data==p->next->next->data){
            q=p->next;
            p->next=q->next;
            free(q);
        }
        else{
            p=p->next;
        }
    }
    return 0;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

08 对于有序单链表，删除重复节点（无保留）

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L);


int main(void){
    LinkList A;
    int c;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);
    (void)function1(A);
    Display(A);
}

int function1(LinkList L){
    int i=0;
    LNode p,q;
    p=L;
    while(p->next->next){
        if(p->next->data==p->next->next->data){
            q=p->next;
            p->next=q->next;
            free(q);
            i=1;
        }
        else{
            if(i==1){
                q=p->next;
                p->next=q->next;
                free(q);
                i=0;
            }
            else{
                p=p->next;
            }
        }
    }
    return 0;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

09 约瑟夫问题（有损）

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L);
void function2(LinkList A,int i,LinkList B,int j);
//将A的第i个节点指向B节点的第j个节点


int main(void){
    LinkList A;
    int c;

    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);

    function2(A,c,A,1);
    printf("\n");
    (void)function1(A);

    
}

int function1(LinkList L){
   int m,n;
   LNode p,q,r;
   p=L->next;
   printf("请输入总共的数M和循环的数N:");
   scanf("%d,%d",&m,&n);
   while(p->next!=p){
    for(int i=1;i<n;i++){
        r=p;
        p=p->next;
    }
    printf("%d\t",p->data);
    q=r->next;
    r->next=p->next;
    p=p->next;
    free(q);
   }

}


void function2(LinkList A,int i,LinkList B,int j){
    if(i==0&&j==0)return;
    LNode p,q;
    int m,n;
    p=A;
    q=B;
    for(m=i;m>0;m--){
    p=p->next;
    }
    for(n=j;n>0;n--){
    q=q->next;
    }
    p->next=q;
}


//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}

10 合并两个升序的单链表（保留重复节点），合并后为升序

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
void function1(LinkList a,LinkList b,LinkList c);


int main(void){
    LinkList A,B,C;
    int c,d;
    printf("请输入您的A列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    printf("请输入您的B列表所需要的节点数:");
    scanf("%d",&d);
    B=InitList();
    C=InitList();
    Build(B,d);
    Display(A);
    Display(B);
    function1(A,B,C);
    Display(C);
    return 0;
}

void function1(LinkList a,LinkList b,LinkList c){
    if(a->next==NULL||a==NULL||b->next==NULL||b==NULL) return;
    LNode p,q;
    q=c;
    while(a->next&&b->next){
        if(a->next->data<=b->next->data){
            p=a->next;
            a->next=a->next->next;
            p->next=NULL;
            q->next=p;
            q=q->next;
        }
        else{
            p=b->next;
            b->next=b->next->next;
            p->next=NULL;
            q->next=p;
            q=q->next;
        }
    }
    while(a->next){
        p=a->next;
        a->next=a->next->next;
        p->next=NULL;
        q->next=p;
        q=q->next;
    }
    while(b->next){
        p=b->next;
        b->next=b->next->next;
        p->next=NULL;
        q->next=p;
        q=q->next;
    }
}


//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

11 合并两个升序的单链表（保留重复节点），合并后为降序

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
void function1(LinkList a,LinkList b,LinkList c);


int main(void){
    LinkList A,B,C;
    int c,d;
    printf("请输入您的A列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    printf("请输入您的B列表所需要的节点数:");
    scanf("%d",&d);
    B=InitList();
    C=InitList();
    Build(B,d);
    Display(A);
    Display(B);
    function1(A,B,C);
    Display(C);
    return 0;
}

void function1(LinkList a,LinkList b,LinkList c){
    if(a->next==NULL||a==NULL||b->next==NULL||b==NULL) return;
    LNode p,q;
    q=c;
    while(a->next&&b->next){
        if(a->next->data<=b->next->data){
            p=a->next;
            a->next=a->next->next;
            p->next=q->next;
            q->next=p;
        }
        else{
            p=b->next;
            b->next=b->next->next;
            p->next=q->next;
            q->next=p;
        }
    }
    while(a->next){
        p=a->next;
        a->next=a->next->next;
        p->next=q->next;
        q->next=p;
    }
    while(b->next){
        p=b->next;
        b->next=b->next->next;
        p->next=q->next;
        q->next=p;
    }
}


//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
    while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

12 判断一个单链表是否对称

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


typedef int ElemType;
typedef int status;
typedef struct lnode{
    ElemType data;
    struct lnode* next;
}Lnode,*LNode,*LinkList;


LinkList InitList();
void ListInsert(LinkList L,int i,ElemType e);
void Build(LinkList L,int n);
void Display(LinkList e);
int ListLength(LinkList L);
int function1(LinkList L);


int main(void){
    LinkList A;
    int y,c;
    printf("请输入您的列表所需要的节点数:");
    scanf("%d",&c);
    A=InitList();
    Build(A,c);
    Display(A);
    y=function1(A);
    if(y==0){
        printf("不对称");
    }
    else{
        printf("对称");
    }
}

int function1(LinkList L){
    LNode p;
    p=L->next;
    int i=ListLength(L),j;
    int arr[i-1];

    for(j=0;j<i;j++){
        arr[j]=p->data;
        p=p->next;
    }

    for(i=ListLength(L)-1,j=0;i>=j;i--,j++){
        if(arr[i]!=arr[j]){
            return 0;
        }
    }
    
    return 1;
}

//初始化节点数为1单链表
LinkList InitList(){
    LinkList head;
    head=(LinkList)malloc(sizeof(struct lnode));
    if(head!=NULL){
        head->next=NULL;
        head->data=0;
    }
    return head;
}

//在单链表的第i个结点之后插入一个节点,元素值为e（假设存在头节点，且头节点是第0个节点）
void ListInsert(LinkList L,int i,ElemType e){
    LNode p,N;
    N = (LNode)malloc(sizeof(Lnode)); 
    p=L;
    N->data=e;
    for(i;i>0;i--)p=p->next;
    N->next=p->next;
    p->next=N;
}

//用头插法在链表L中插入n个元素
void Build(LinkList L,int n){
    int i=0,k;
    for(i;i<n;i++){
        printf("请输入你想插入的第%d个值:",i+1);
        scanf ("%d",&k);
        printf("\n");
        ListInsert(L,0,k);
    }
}

//打印列表e
void Display(LinkList e){
    LNode p;
    p=e->next;
     while (p!=NULL)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int ListLength(LinkList L){
    int sum=0;
    LNode p=L->next;
    while(p){
    sum++;
    p=p->next;
    }
    return sum;
}