一.线性表的运用

Sakura_—

已于 2023-10-21 22:26:00 修改

阅读量94

点赞数

文章标签： C 算法数据结构

于 2023-09-21 22:57:39 首次发布

本文链接：https://blog.csdn.net/m0_74161592/article/details/133150307

版权

单链表：

初始化，尾插，输出，长度，取值，查找，删除，插入

单链表：

初始化，判空，添加，按结点删除，尾添，

头添，按值查找，按位查找，按值删除，历遍，

单链表：

初始化，尾插，输出，长度，取值，查找，删除，插入

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}
//尾插法创建单链表
void ListInsertTail(Linklist *L,int n){
   
    Lnode * p;//存储要插入的元素
    Lnode *r=L;//指向尾结点 ,也可作 Lnode *r;r=(*L)
    int a[n];
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=a[i];//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;//p指向首元结点
    printf("链表为：");
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
//获取长度
void Getlength(Linklist L){
    Linklist p;
    p=L->next;//p指向首元结点
    int count=0;//计数器
    while(p!=NULL){
        count++;
        p=p->next;
    }
    printf("链表的长度是 %d\n",count);
}
//获取第XX个元素的内容
void Getelement(Linklist L){
    Linklist p=L->next;//利用p从首元结点结点开始顺着链表扫描，此后p依次下移指向当前扫描到的结点
    int count=1;//因为p初始指向首元结点，所以计数器初始值为1
    int target;
    int XX;//目标元素序号
    printf("目标元素的排列序号是（从1开始）\n");
    scanf("%d",&XX);
    while(p!=NULL && count<XX){//向后扫描直到扫描到目标元素或者历尽链表发现没有目标元素
        p=p->next;
        count++;
    }
    if(!p && count<XX) printf("该元素不存在！！\n");
    else target=p->data;
    printf("序号为%d的目标元素是%d\n",XX,target);
 
}
//按值查找，获取指定元素中链表中的位置(默认链表中无重复元素）
void Findlocation(Linklist L){
    Linklist p;
    p=L->next;//p指向首元结点
    int count =1;//因为p初始指向首元结点，所以计数器初始值为1
    int target;
    printf("目标元素的值是\n");
    scanf("%d",&target);
    while(p&&p->data!=target){
        p=p->next;
        count++;
    }
        if(p) printf("%d在链表中是第%d个元素\n",target,count);
        else printf("链表中没有该元素！！\n");
    
}
//插入，在第i个元素前插入元素e
void Insert(Linklist L){
    int i,e;
    int count=1;因为p初始指向首元结点，所以计数器初始值为1
    printf("请问在哪个元素位置前插入什么元素？\n");
    scanf("%d %d",&i,&e);
    Lnode *s;
    Lnode *p=L->next;//p指向首元结点结点
    while(p->next!=NULL&&count<i-1){//寻找前驱结点（i-1个结点）位置，并把p指向前驱结点
        p=p->next;
        count++;
    }
    if(p==NULL||count>i-1)printf("插入位置非法！！\n");//i小于1（刚开始count=0时，若i=0则非法）或者大于表长加1，亦或者表空
    else{
        s=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        s->data=e;//将s的数值域设置为e
        s->next=p->next;//将结点s插入L中，新结点s的指针域指向ai结点
        p->next=s;
        Printlist(L);
    }
    
}
//删除第i个结点
void Deleteelem(Linklist L){
    int i,e,count=1;//因为p初始指向首元结点，所以计数器初始值为1
    printf("请输入需要删除的结点：\n");
    scanf("%d",&i);
    Linklist p=L->next;//p指向首元结点
    Linklist q;
    while(p->next!=NULL && count<i-1){//寻找前驱结点
        p=p->next;
        count++;
    }
    
    if(p==NULL||count>i-1 ){printf("删除位置不合理！！\n");}
     q=p->next;
    // p->data=q->next->data;
    e=q->data;
     p->next=q->next;
     free(q);
     Printlist(L);
    
}
int main(){
    Linklist list;
    list=InitList();
    int n,e;
    printf("请输入链表元素个数n=");
    scanf("%d",&n);
    ListInsertTail(&list,n);
    
     Printlist(list);
     Getlength(list);
     Getelement(list);
     Findlocation(list);
     Insert(list);
     Deleteelem(list);
   
   return 0;
}

单链表：

初始化，判空，添加，按结点删除，尾添，

头添，按值查找，按位查找，按值删除，历遍，

更改，指定位置添加，清空，按位序删除

# include <stdio.h>
# include <stdlib.h>
# include <stdbool.h>
//定义结构体（结点）
typedef struct _node {
    int value;
    struct _node * next;
} Node;
 
//定义数据结构struct _list表示整个链表
//存放链表的信息：头结点（如果有的话）或首结点、尾结点、链表长度等等
typedef struct _list
{
    Node* head;//始终指向首结点
    Node* tail;//始终指向尾结点
    int size;//表示链表的长度，用在List_Insert函数中，用来判断输入的位置i是否越界，可以简化代码
} List;
//初始化链表
bool InitList(List* pList)
{
    pList->head = pList->tail = NULL;
    pList->size = 0;
    return true;
}
//判空
bool Empty(List* pList)
{
    return (pList->head==NULL);
}
 
//在指定结点之后添加结点
bool InsertNextNode(Node* p, int elem)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    if(s == NULL)//内存分配失败
    {
        sign = true;
    }
    s->value = elem;
    s->next = p->next;
    p->next = s;
 
    return sign;
}
//在指定节点之前添加结点
/*
偷天换日的操作！
    指定结点的前驱结点是未知的，从头结点遍历的话时间复杂度高O(n)
    虽然结点不能交换位置，但是结点中的数据可以交换位置[O(1)]
*/
bool InsertPriorNode(Node* p, int elem)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    if(s == NULL)
    {
        sign = false;
    }
    //连接
    s->next = p->next;
    p->next = s;
    //下面两个语句是精髓
    s->value = p->value;//将结点p中的元素复制到s中
    p->value = elem;//p中元素替换为elem
 
    return sign;
}
//删除指定结点p(局限：当该结点是尾结点时，无法完成操作)
bool DeleteNode(Node* p)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* q = p->next;//q指向p的后继结点
    p->value = p->next->value;//p结点和它的后继结点交换数据
    p->next = q->next;//将q结点删除
    free(q);
 
    return sign;
}
//结点添加（尾添加）
Node* List_AddOnTail(List* pList, int number)//传入指针的指针
{
    //分配结点空间，并写入p->value
    Node* p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //head始终指向首结点，tail始终指向尾结点
    //如果链表是空的，最新分配的结点（p）既是head，也是tail
    if(pList->head == NULL)
    {
        pList->head = p;
        pList->tail = p;
    }
    //如果链表不是空的，只需要处理tail
    else
    {
        pList->tail->next = p;//此时链表的尾结点要指向新分配的结点
        pList->tail = p;//新分配的结点成为链表的tail
    }
    pList->size ++;
    pList->tail->next = NULL;//tail里面的指针必须是NULL
 
/*  //在链表的尾结点之后添加结点，需要循环，
    Node* last = pList->head;
    if(last)
    {
        while(last->next)
        {
            last = last->next;
        }
        //接上去
        last->next = p;
    }
    else
    {
        pList->head = p;
    }
*/
    return pList->head;
}
//结点添加(头添)
Node* List_AddOnHead(List* pList, int n)
{
    Node* p = (Node*)malloc(sizeof(Node));
    p->value = n;
    p->next = NULL;
    if(pList->head == NULL)
    {
        pList->head = p;
        pList->tail = p;
    }
    else
    {
        p->next = pList->head;
        pList->head = p;
    }
    pList->size ++;
    return pList->head;
}
//遍历输出链表
void List_Print(List* pList)
{
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        printf("%-5d", p->value);
    }
    printf("\n");
}
//查（按位）
Node* List_GetElem(List* pList, int i)
{
    Node* q;
    if(i<1 || i>pList->size)
        q = NULL;
    else
    {
        Node* p = pList->head;
        int j = 1;
        while(j<i)
        {
            p = p->next;
            j++;
        }
        q = p;
    }
 
    return q;
}
//查（按值）
bool List_Search(List* pList, int number)
{
    bool isFound = false;
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        if(p->value == number)
        {
            isFound = true;
            break;
        }
    }
    return isFound;
}
//按值删除元素（仅删除第一个）
void List_DeleteByValue(List* pList, int number)
{
    Node* prev;
    Node* p;
    Node* q;
    for(p=pList->head,q=NULL; p; q=p,p=p->next)
    {
        if(number == p->value)
        {
            if(q)
            {
                q->next = p->next;
            }
            else
            {
                pList->head = p->next;
            }
        free(p);
        break;
        }
    }
}
//更改指定元素
void List_Change(List* pList, int a, int b)
{
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        if(p->value == a)
        {
            p->value = b;
        }
    }
}
//在指定位置添加元素，引入链表长度（pList->size）
bool List_Insert(List* pList, int i, int elem)
{
    bool sign = true;
    if(i<1 || i>pList->size+1)
        sign = false;
    else if(i == 1)
    {
        Node* s = (Node*)malloc(sizeof(Node));
        s->value = elem;
        s->next = pList->head;
        pList->head = s;
    }
    //找到第i-1个结点
    else
    {
        Node* p = List_GetElem(pList, i-1);//封装 找到第i-1个结点,注意这里传入的参数是List*类型
        sign = InsertNextNode(p,elem);//封装 在第i-1个结点之后插入新结点
    }
    return sign;
}
//按位序删除元素
bool List_DeleteByOrder(List* pList, int i, int* elem)
{
    bool sign = true;
    if(i<1 || i>pList->size+1)
        sign = false;
    else if(i == 1)
    {
        Node* p = pList->head;
        pList->head = p->next;
        free(p);
    }
    //找到第i-1个结点
    else
    {
        Node* p = List_GetElem(pList, i-1);//简单的封装  注意这里传入的参数是List*类型
        if(p==NULL || p->next==NULL)//i值越界或者第i-1个结点没有后继结点
        {
            sign = false;
        }
        Node* q = p->next;
        *elem = q->value;
        p->next = q->next;
        free(q);
    }
    return sign;
}
//清除链表
bool List_Clear(List* pList)
{
    Node* p;
    Node* q;
    bool sign = true;
    if(pList->head == NULL)
        sign = false;
    p = pList->head->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    pList->head->next = NULL;//注意！！！不能少
    return sign;
}
 
int main(void)
{
//创建并初始化，输入元素
    List list;
    InitList(&list);
    int number;
    printf("请输入整数（输入-1结束）：\n");
    do
    {
        scanf("%d", &number);
        if(number != -1)
        {
            list.head = List_AddOnTail(&list, number);//注意这里要传入head的地址
            //list.head = List_AddOnHead(&list, number);
        }
    }while(number != -1);
//遍历并输出链表
    printf("链表中的元素为：");
    List_Print(&list);
//查(按值)
    printf("\n请输入您要查找的元素：");
    scanf("%d", &number);
    if(List_Search(&list, number) == true)
    {
        printf("找到了！\n");
    }
    else
    {
        printf("没找到！\n");
    }
//查（按位）
    printf("请输入您要查找的位序：");
    int i, elem;
    scanf("%d", &i);
    if(List_GetElem(&list, i) != NULL)
    {
        printf("找到了！该元素是%d\n", List_GetElem(&list, i)->value);//这个地方的写法有问题吗？
    }
    else
    {
        printf("位序越界！\n");
    }
//删除，按元素值
    printf("\n请输入您要删除的元素：");
    scanf("%d", &number);
    if(List_Search(&list, number) == true)
    {
        List_DeleteByValue(&list, number);
        printf("删除成功！当前链表中的元素为：");
        List_Print(&list);
    }
    else
    {
        printf("删除失败！您要删除的元素不存在！\n");
    }
 
//更改链表元素
    int a, b;
    printf("\n请输入旧元素：");
    scanf("%d", &a);
    if(List_Search(&list, a))
    {
        printf("请输入新元素：");
        scanf("%d", &b);
        List_Change(&list, a, b);
        printf("更改成功！当前链表元素为：");
        List_Print(&list);
    }
    else
    {
        printf("未找到！\n");
    }
//插入元素
    printf("\n请输入您要插入的位置和数字：");
    scanf("%d%d", &i, &elem);
    if(List_Insert(&list, i, elem))
    {
        printf("插入成功！当前链表元素为：");
        List_Print(&list);
    }
    else
    {
        printf("插入失败！\n");
    }
//按位序删除元素
    printf("\n请输入您要删除的结点的位序：");
    scanf("%d", &i);
    if(List_DeleteByOrder(&list, i, &elem))
    {
        printf("删除成功！删除的元素为:%d\n当前链表元素为：", elem);
        List_Print(&list);
    }
    else
    {
        printf("删除失败！\n");
    }
 
//链表清除
    if(List_Clear(&list))
    {
        printf("\n链表已清空！\n");
    }
    else
    {
        printf("\n清空失败，链表为空\n");
    }
 
    return 0;
}

尾部添加一个元素，

输入len个数插入到单链表L尾，

输出单链表中的节点值，

冒泡排序，

判断某个元素在单链表中是否存在，

将单链表的数据存到另一个单链表的末尾，

返回两个单链表的并集，

返回单链表a-b的差集，

返回单链表a和b的交集，

判断两个单链表是否完全相等

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}
//尾插法创建单链表
void ListInsertTail(Linklist *L,int n){
   
    Lnode * p;//存储要插入的元素
    Lnode *r=L;//指向尾结点 ,也可作 Lnode *r;r=(*L)
    int a[n];
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=a[i];//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;//p指向首元结点
    printf("链表为：");
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

//功能说明：在单链表的尾部添加元素
//实现方式：
//1.定义一个临时的节点n  给临时节点开辟空间
//2.元素e存入临时节点的数据域中 将临时节点n的next置空
//3.将尾节点的next指向临时节点n 尾节点后移
void tailAddElemLinkList(Linklist *l,int e) {
    Lnode *r=l;
    //定义一个临时的节点n  给临时节点开辟空间
    Lnode *n = (Lnode*)malloc(sizeof(Lnode));
    //元素e存入节点n中
    n->data = e;
    //将临时节点n的next置空
    n->next = NULL;
    //将新节点插入末尾
    r->next = n;
    //尾指针后移一位
    r=n;

}

//功能说明：单链表从小到大的排序 冒泡排序 （值交换）
//参数： LinkList* L 单链表的头节点
// 实现方式： 从第一个元素节点开始逐一比较，将节点的值进行交换
void linkListSort(Linklist L){
    Lnode* i = L->next;//i指向首元结点
    Lnode* j = L->next;
    //外层循环
    while(i){
        //内层循环
        while(j){//j从第i个元素开始
            //值交换
            if(i->data > j->data){
                int e = i->data;
                i->data = j->data;
                j->data = e;
            }
            j = j->next;
        }
        j = i->next;//第i个元素和后面的元素对比排序结束（现在第i个元素小于后面的所有元素），j指向i的下一个元素
        i = i->next;//开始下一个元素的对比
    }
}
//功能说明：判断某个元素在单链表中是否存在 存在返回1 不存在返回-1
//参数1： LinkList *L 单链表的头节点
//参数2：要查找的元素e
//实现方式：遍历单链表L，拿元素e和单链表L中的所有元素匹配 成功返回1 失败返回-1
int searchElem(Linklist L, int e){
    Lnode *temp = L->next;
    while(temp!=NULL){
        if(e == temp->data) return 1;
        temp = temp->next;
    }
    return -1;
}
//功能说明：将单链表的数据存到另一个单链表的末尾 重复元素不存入
//参数1： LinkList *L1 存取元素的单链表的头节点
//参数2： LinkList *L1_rear 存取元素的单链表的尾节点
//参数3：LinkList *L2_head 被存取的单链表的头节点
//实现方式：
// 遍历单链表L2，判断每一个元素在L1中是否存在
//不存在则存入该元素到L1，L1的尾节点后移，最后返回L1的尾节点
Linklist spliceLinkList(Linklist L1,Lnode *L1_rear,Lnode *L2_head){
    Lnode *r = L1_rear;
    while(L2_head){
        //判断单链表a里面的元素在单链表L存不存在， 不存在则存入（数据去重）
        if(searchElem(L1,L2_head->data) == -1){
            //将L2_head->data从尾节点r存入L1中
             tailAddElemLinkList(&r,L2_head->data);
        }
        L2_head = L2_head->next;
    }
    return r;
}
//功能说明：返回两个单链表的并集
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式： 将两个单链表去重后存入一起，排序成一个有序链表 （使用上面封装的函数实现）
Linklist unionLinkList(Linklist a,Linklist b){
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    Linklist L = InitList();
    Lnode *r = L;
    Lnode *pa = a->next;
    Lnode *pb = b->next;
    r = spliceLinkList(L,r,pa);
    r = spliceLinkList(L,r,pb);
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：返回单链表a-b的差集
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式：
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//不存在则存入新的单链表L
Linklist diffLinkList(Linklist a,Linklist b){
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    Linklist L = InitList();
    Lnode *r = L;
    Lnode *pa = a->next;
    while(pa){
        //判断单链表b里面的元素在单链表a存不存在，不存在则存入（数据去重）
        if(searchElem(b,pa->data) == -1 && searchElem(L,pa->data) == -1){
            tailAddElemLinkList(&r,pa->data);
        }
        pa = pa->next;
    }
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：返回单链表a和b的交集 （和上面的函数一模一样，判断里面改一下就行）
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式：
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//存在则存入新的单链表L
Linklist intersectionLinkList(Linklist a,Linklist b) {
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    Linklist L = InitList();
    Lnode *r = L;
    Lnode *pa = a->next;
    while(pa){
        //判断单链表b里面的元素在单链表a存不存在， 存在则存入（数据去重）
        if(searchElem(b,pa->data) == 1 && searchElem(L,pa->data) == -1){
            tailAddElemLinkList(&r,pa->data);
        }
        pa = pa->next;
    }
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：判断两个单链表是否完全相等
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//返回值：相等返回 int 1 不相等返回 int 0
//单链表a和单链表b如果他们的差集都为空，则他们完全相等
int equalLinkList(Linklist a,Linklist b){
    //判断a-b和b-a的差集是否都为空  差集为空则相等
    if(!diffLinkList(a,b)->next && !diffLinkList(b,a)->next){
        return 1;
    }
    return 0;
}
int main(){
    //初始化一个节点作为头节点
    Linklist l1 = InitList();
    Linklist l2 = InitList();
    int n,m,e;
    printf("请输入第一个链表元素个数n=");
    scanf("%d",&n);
    ListInsertTail(&l1,n);
    Printlist(l1);
    printf("请输入第二个链表元素个数m=");
    scanf("%d",&m);
    ListInsertTail(&l2,m);
    Printlist(l2);
    printf("\n两个单链表的并集：");
    Printlist(unionLinkList(l1,l2));
    printf("\n单链表a-b的差集：");
    Printlist(diffLinkList(l1,l2));
    printf("\n单链表b-a的差集：");
    Printlist(diffLinkList(l2,l1));
    printf("\n单链表a和单链表b的交集：");
    Printlist(intersectionLinkList(l2,l1));
    printf("\n单链表的数据是否相等：");
    if(equalLinkList(l2,l1))
        printf("相等");
    else
        printf("不相等");
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
//定义单链表的结构体
typedef struct Node{
    ElemType data;        //数据域 存储该Node数据
    struct Node *next;    //指针域 指向下一个Node
}LinkList;
//返回一个初始化的节点L
LinkList* InitList(){
    LinkList* L;                                //定义一个节点
    L = (LinkList*)malloc(sizeof(LinkList));    //分配节点空间
    L->next = NULL;                                //节点指针域置空
    return L;
}
//功能说明：在单链表的尾部添加元素，返回添加元素后的尾节点
//参数1：LinkList *r 要添加元素的单链表的尾节点
//参数2：ElemType e 要添加的元素e
//返回值：LinkList * r  新的尾节点
//实现方式：
//1.定义一个临时的节点n  给临时节点开辟空间
//2.元素e存入临时节点的数据域中 将临时节点n的next置空
//3.将尾节点的next指向临时节点n 尾节点后移 返回新的尾节点
LinkList *tailAddElemLinkList(LinkList *r,ElemType e) {
    //定义一个临时的节点n  给临时节点开辟空间
    LinkList *n = (LinkList*)malloc(sizeof(LinkList));
    //元素e存入节点n中
    n->data = e;
    //将临时节点n的next置空
    n->next = NULL;
    //将新节点插入末尾
    r->next = n;
    //尾指针后移一位
    r = r->next;
    //返回新的尾节点
    return r;
}
//功能说明：创建单链表，从键盘输入len个数插入到单链表L中
//参数1： LinkList* L 要链接节点的头节点
//参数2：int len 要添加的节点个数
//实现方式：
//定义一个尾指针r 定义变量e用于存储每次输入的元素值
//使用循环每次输入一个元素值 将元素通过尾部添加到单链表
void createList(LinkList* L,int len){
    //定义一个尾指针r并初始化为头指针
    LinkList* r = L;
    //定义变量e用于存储每次输入的元素值
    ElemType e;
    printf("请输入%d个单链表的元素：",len);
    int i;
    for(i = 0; i < len; i++){
        //获取输入的元素
        scanf("%d",&e);
        r = tailAddElemLinkList(r,e);
    }
}
//功能说明：输出单链表中的节点值
//参数： LinkList* L 要显示的单链表的头节点
//实现方式：定义一个节点p指向第一个节点 循环判断节点p是否存在，存在则输出data，节点p向后移动一位
void showLinkList(LinkList* L) {
    LinkList* p = L->next;
    while(p){
        printf("%d ",p->data);
        p = p->next;
    }
}
//功能说明：单链表从小到大的排序 冒泡排序 （值交换）
//参数： LinkList* L 单链表的头节点
// 实现方式： 从第一个元素节点开始逐一比较，将节点的值进行交换
void linkListSort(LinkList* L){
    LinkList* i = L->next;
    LinkList* j = L->next;
    //外层循环
    while(i){
        //内层循环
        while(j){
            //值交换
            if(i->data > j->data){
                ElemType e = i->data;
                i->data = j->data;
                j->data = e;
            }
            j = j->next;
        }
        j = i->next;
        i = i->next;
    }
}
//功能说明：判断某个元素在单链表中是否存在 存在返回1 不存在返回-1
//参数1： LinkList *L 单链表的头节点
//参数2：要查找的元素e
//实现方式：遍历单链表L，拿元素e和单链表L中的所有元素匹配 成功返回1 失败返回-1
int searchElem(LinkList *L, ElemType e){
    LinkList *temp = L->next;
    while(temp){
        if(e == temp->data) return 1;
        temp = temp->next;
    }
    return -1;
}
//功能说明：将单链表的数据存到另一个单链表的末尾 重复元素不存入
//参数1： LinkList *L1 存取元素的单链表的头节点
//参数2： LinkList *L1_rear 存取元素的单链表的尾节点
//参数3：LinkList *L2_head 被存取的单链表的头节点
//实现方式：
// 遍历单链表L2，判断每一个元素在L1中是否存在
//不存在则存入该元素到L1，L1的尾节点后移，最后返回L1的尾节点
LinkList *spliceLinkList(LinkList *L1,LinkList *L1_rear,LinkList *L2_head){
    LinkList *r = L1_rear;
    while(L2_head){
        //判断单链表a里面的元素在单链表L存不存在， 不存在则存入（数据去重）
        if(searchElem(L1,L2_head->data) == -1){
            //将L2_head->data从尾节点r存入L1中
            r = tailAddElemLinkList(r,L2_head->data);
        }
        L2_head = L2_head->next;
    }
    return r;
}
//功能说明：返回两个单链表的并集
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式： 将两个单链表去重后存入一起，排序成一个有序链表 （使用上面封装的函数实现）
LinkList *unionLinkList(LinkList *a,LinkList *b){
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    LinkList *L = InitList();
    LinkList *r = L;
    LinkList *a_head = a->next;
    LinkList *b_head = b->next;
    r = spliceLinkList(L,r,a_head);
    r = spliceLinkList(L,r,b_head);
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：返回单链表a-b的差集
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式：
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//不存在则存入新的单链表L
LinkList *diffLinkList(LinkList *a,LinkList *b){
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    LinkList *L = InitList();
    LinkList *r = L;
    LinkList *a_head = a->next;
    while(a_head){
        //判断单链表b里面的元素在单链表a存不存在，不存在则存入（数据去重）
        if(searchElem(b,a_head->data) == -1 && searchElem(L,a_head->data) == -1){
            r = tailAddElemLinkList(r,a_head->data);
        }
        a_head = a_head->next;
    }
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：返回单链表a和b的交集 （和上面的函数一模一样，判断里面改一下就行）
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//实现方式：
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//存在则存入新的单链表L
LinkList *intersectionLinkList(LinkList *a,LinkList *b) {
    //初始化一个单链表L用于存储 单链表a和单链表b的并集
    LinkList *L = InitList();
    LinkList *r = L;
    LinkList *a_head = a->next;
    while(a_head){
        //判断单链表b里面的元素在单链表a存不存在， 存在则存入（数据去重）
        if(searchElem(b,a_head->data) == 1 && searchElem(L,a_head->data) == -1){
            r = tailAddElemLinkList(r,a_head->data);
        }
        a_head = a_head->next;
    }
    //排序合并的并集结果
    linkListSort(L);
    return L;
}
//功能说明：判断两个单链表是否完全相等
//参数1：LinkList *a 单链表a的头节点
//参数1：LinkList *b 单链表b的头节点
//返回值：相等返回 int 1 不相等返回 int 0
//单链表a和单链表b如果他们的差集都为空，则他们完全相等
int equalLinkList(LinkList *a,LinkList *b){
    //判断a-b和b-a的差集是否都为空  差集为空则相等
    if(!diffLinkList(a,b)->next && !diffLinkList(b,a)->next){
        return 1;
    }
    return 0;
}
int main(){
    //初始化一个节点作为头节点
    LinkList* L1 = InitList();
    LinkList* L2 = InitList();
    int len;
    printf("请输入要创建的第一个单链表长度：");
    scanf("%d",&len);
    createList(L1,len);
    printf("第一个单链表的元素为：");
    showLinkList(L1);
    
    printf("\n请输入要创建的第二个单链表长度：");
    scanf("%d",&len);
    createList(L2,len);
    printf("第二个单链表的元素为：");
    showLinkList(L2);
    
    printf("\n两个单链表的并集：");
    showLinkList(unionLinkList(L1,L2));
    printf("\n单链表a-b的差集：");
    showLinkList(diffLinkList(L1,L2));
    printf("\n单链表b-a的差集：");
    showLinkList(diffLinkList(L2,L1));
    printf("\n单链表a和单链表b的交集：");
    showLinkList(intersectionLinkList(L2,L1));
    printf("\n单链表的数据是否相等：");
    if(equalLinkList(L2,L1))
        printf("相等");
    else
        printf("不相等");
    return 0;
}

1.单链表的分解

利用单链表A表示一个非零整数序列，把链表A分解为两个具有相同结构的链表B和C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点。要求空间复杂度为O(1)。

输入

第一行输入链表A的长度n；

第二行输入链表A的n个元素（以空格间隔）。

输出

第一行输出链表B的元素；

第二行输出链表C的元素（以空格间隔）。

样例输入 Copy

3 -6 1 -2 4 -3 8

样例输出 Copy

-6 -2 -3
3 1 4 8

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}

void ListInsertTail(Linklist *L){
    int n,num;
    Lnode * p;//存储要插入的元素
    Lnode *r=L;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
       // printf("请输入第%d个元素：",i+1);
        scanf("%d",&num);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=num;//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
void InsertTail(Linklist *L,int e){
    Lnode * p;//存储要插入的元素
    Lnode *r=L;
        
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=e;//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    r->next=NULL;//将最终的结点next域值设为NULL
}//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}


void Resolve(Linklist La, Linklist Lb,Linklist Lc)
{
        Lnode * pre = La;
        Lnode * pb = Lb;
        Lnode * pa = La;
        pa = pa->next;
        while (pa)
        {
            if (pa->data < 0)
            {
                Lnode *p=(Lnode *)malloc(sizeof(Lnode));
                p = pa;               //生成新节点
                pre->next = pa->next; //删除小于0的节点，pre始终为pa的前驱
                pa = pa->next;        //pa后移
                p->next = NULL;       //后插法将元素插入Lb中
                pb->next = p;
                pb = p; //插入
            }
            else //大于0
            {
                pre = pa;
                pa = pa->next; //pre为pa的前驱，pa指针后移动。
            }
        }
   
}
int main(){
    Linklist l1,l2,l3;
    l1=InitList();
   l2=InitList();
    l3=InitList();
    ListInsertTail(l1);
    Resolve(l1,l2,l3);
    Printlist(l2);
    Printlist(l1);
    return 0;
  
}

2.两个有序链表的差集

链表A和B分别示两个递增的整数集合，求出A和B的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。要求空间复杂度为O(1)。

输入

第一行为序列A的长度n；

第二行为序列A的n个元素；

第三行为序列B的长度m；

第四行为序列B的m个元素（元素之间用空格分隔）。

输出

若有差集：

第一行输出两个递增有序链表中元素的差集；

第二行输出该差集中元素的个数。

若无差集：

输出0

样例输入 Copy

样例输出 Copy

7 9
2

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


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

typedef struct list
{
    Node* head;
    Node* tail;
    int length;

}List;
void Init_list(List* L)
{
    Node* first = (Node*)malloc(sizeof(Node));
    if(!first)  printf("wrong!\n");
    first -> data = 0;
    first -> next = NULL;
    L->head = L->tail = first;
    int size_list;
    scanf("%d",&size_list);
    L->length = size_list;

    for(int i = 0; i< size_list; i++)
    {
        Node* new = (Node*)malloc(sizeof(Node));
        scanf("%d",&new -> data);
        new -> next = NULL;
        L->tail -> next = new;
        L->tail = new;

    }


}
void  chaji(List* l1, List l2)
{
    Node *p, *q,*save,*prev;
    p = l1->head->next;  q = l2.head->next; prev = l1->head;
    while(p && q)
    {
        if(p->data == q->data)
        {
            p = p -> next;
            q = q-> next;
            prev -> next = p;
            l1->length --;
        }
        else if(p->data > q->data)
        {
            q = q->next;
        }
        else
        {
            prev = p;
            p = p->next;
        }
    }

}


void print_list(List L)
{
    Node* p;
    p = L.head->next;
    while(p != NULL)
    {
        printf("%d ",p->data);
        p = p -> next;
    }
    printf("\n");
}


int main(int argc, char const *argv[])
{
    List l1,l2;

    Init_list(&l1);
    Init_list(&l2);

     chaji(&l1,l2);
    if(l1.length==0){
        printf("0");
    }
    else {
        print_list(l1);
        printf("%d\n", l1.length);
    }
    return 0;
}

3.两个有序链表的交集

单链表A和B分别示两个递增的整数集合，求出A和B的交集并以同样的形式存储，并存放在A中。要求空间复杂度为O(1)。

输入

第一行为序列A的长度n；

第二行为序列A的n个元素；

第三行为序列B的长度m；

第四行为序列B的m个元素（元素之间用空格分隔）。

输出

若有交集：

第一行输出单链表A和B的交集，每个数据之间用空格分隔；

第二行输出该交集中元素的个数。

若无交集：

输出0

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

}Node;

typedef struct list
{
    Node* head;
    Node* tail;

}List;

void only_init(List *L)
{

    Node* first = (Node*)malloc(sizeof(Node));
    if(!first)
        printf("-1");
    first -> data = 0;
    first -> next = NULL;
    L->head = L->tail = first;

}

void Init_list(List* L)
{
    Node* first = (Node*)malloc(sizeof(Node));
    if(!first)
        printf("-1");
    first -> data = 0;
    first -> next = NULL;
    L->head = L->tail = first;

    int length;

    scanf("%d",&length);
    for(int i = 0; i< length; i++)
    {
        Node* new = (Node*)malloc(sizeof(Node));
        scanf("%d",&new -> data);
        new -> next = NULL;
        L->tail -> next = new;
        L->tail = new;

    }


}


int merge(List l1,List l2,List *l3)
{
    Node *p, *q,*w,*save,*prev;
    p = l1.head->next;  q = l2.head->next; w = l3->tail;
    int count=0;
    w -> next = NULL;

    
    while(p && q)
    {
        if(p->data == q->data)
        {count++;
            save = p;
            p = p -> next;
            q = q-> next;
            w -> next = save;
            save -> next = NULL;
            w = w -> next;

        }
        else if(p->data < q -> data)
        {
            p = p->next;
            
        }
        else
            q = q->next;
    }
    return count;

}


void print_list(List L)
{
    Node* p;
    p = L.head->next;

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

    printf("\n");
}


int main(int argc, char const *argv[])
{
    List l1,l2,l3;
    Init_list(&l1);
    Init_list(&l2);
    only_init(&l3);
     int P= merge(l1,l2,&l3);
    if(P==0){
        printf("0");
    }
    else {
        print_list(l3);
        printf("%d",P);}
    return 0;
}

4.查找单链表中最大值

利用单链表表示一个整数序列，通过一趟遍历在单链表中确定值最大的结点。

输入

第一行输入元素个数n；

第二行依次输入链表的n个元素（以空格间隔）。

输出

输出单链表的最大值。

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}

void ListInsertTail(Linklist *L){
    int n,num;
    Lnode * p;//存储要插入的元素
    Lnode *r=L;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
       // printf("请输入第%d个元素：",i+1);
        scanf("%d",&num);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=num;//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;
   
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
}

void FindMax( Linklist l ) {
    int max,temp;
    Lnode *p=l->next;
    //Lnode *r;
    max=p->data;
    if(p==NULL){
        exit(0);
    }
    while (p!=NULL){
        if(max<p->data){
            max=p->data;
        }
        p=p->next;
        
    }
    printf("%d",max);
    
}


int main(){
    Linklist l1;
   // Lnode *l2;
    l1=InitList();
   // l2=InitList();
   ListInsertTail(l1);
   FindMax(l1);
    return 0;
  
}

5.单链表的逆置

利用单链表表示一个整数序列，通过一趟遍历，将单链表中所有结点的链接方向逆转。要求空间复杂度为O(1)。

输入

第一行为单链表的长度n，
第二行为单链表的n个元素（元素之间用空格分隔）。

输出

逆序输出单链表中的元素，元素之间用空格分隔。

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}

void ListInsertTail(Linklist *L){
    int n,num;
    Lnode * p;//存储要插入的元素
    Lnode *r=L;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
       // printf("请输入第%d个元素：",i+1);
        scanf("%d",&num);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=num;//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;
   
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
}

Linklist ReverseList( Linklist l ) {
    Linklist p = l->next, l1;
    l1 = (Lnode*)malloc(sizeof(Lnode));
        l1->data = l->data;
        l1->next = NULL;
        while (p)
        {
            Linklist q;
             q =(Lnode*)malloc(sizeof(Lnode));
            q->data = p->data;
            q->next = l1->next;
            l1->next = q;
            p = p->next;
        }
        return l1;
}


int main(){
    Linklist l1;
    Lnode *l2;
    l1=InitList();
    l2=InitList();
   ListInsertTail(l1);
   // Printlist(l1);
    l2=ReverseList(l1);
    Printlist(l2);
    return 0;
  
}

6.删除有序链表中满足区间要求的元素

创建一个含有n个整型元素的递增单链表，删除单链表中值大于等于min且小于等于max的所有元素（min和max是给定的两个参数，min<max，其值可以和表中的元素相同，也可以不同）。如果min或max不合理或单链表为空，则输出-1并退出运行。

输入

第一行输入元素个数n；

第二行依次输入n个元素（元素之间用空格分隔）；

第三行输入给定的min和max（以空格间隔）。

输出

输出顺序表中删除元素后的所有元素，元素之间用空格分隔（若成功删除）；

-1（若未成功删除）。

#include<stdio.h>
#include<stdlib.h>
 
typedef struct node{
    int  data;
    struct node *next;
    //struct node *prior;
}Lnode,*Linklist;
 
 
//单链表初始化,定义一个Linklist(Lnode*)型函数，由其带回头指针地址
Linklist InitList(){
    Lnode *L;
    L=(Lnode* )malloc(sizeof(Lnode));
    if(L==NULL){
        printf("申请内存失败！！");
        exit(0);
    }
    L->next==NULL;// 双向链表中需要L->prior==NULL;
    return L;
}
//尾插法创建单链表
void ListInsertTail(Linklist *L,int n){
   
    int num;
    Lnode * p;//存储要插入的元素
    Lnode *r=L;//指向尾结点 ,也可作 Lnode *r;r=(*L)
   
    
    if(n==0){
        printf("-1");
        exit(0);
    }
    for(int i=0;i<n;i++){
        scanf("%d",&num);
        p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
        p->data=num;//结点数据域中放入元素
        r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
        r=p;//r指向新的尾结点
    }
    r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
    Lnode *p;
    p=L->next;
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
}

void Delete(Linklist L,int n){
    int min,max;
    scanf("%d %d",&min,&max);
    Lnode *p=L->next;//首元结点p
    Lnode *pre,*s,*q;
    if(min>max||L->next==NULL){
        printf("-1");
        exit(0);
    }
    if(p->data>max){//首元结点大于max
        printf("-1");
        exit(0);
    }
    if(p->data>=min){//首元结点大于min且小于max
        while(p->data<=max&&p->next!=NULL){
            s->next=p->next;
            free(s);
            p=s->next;
        }
        if(p->next==NULL&&p->data<=max){
            free(p);
            s->next=NULL;
        }
    }
    else{//首元结点小于min
        q=p->next;
        while(q->data<min){//该链表所有元素都小于min
            if(q->next==NULL){
                printf("-1");
                exit(0);
            }
            p=p->next;
            q=q->next;
        }
        while (q->data <= max&&q->next!=NULL){
                  p->next = q->next;
                  free(q);
                  q = p->next;
              }
              if (q->next == NULL&&q->data <= max){
                      free(q);
                      p->next = NULL;
              }
    
    }
}

int main(){
    Linklist l1;
    l1=InitList();
    int n;
    scanf("%d",&n);
    ListInsertTail(l1,n);
    Delete(l1,n);
    Printlist(l1);
    return 0;
}

7.两个有序链表的合并

题目描述

给定两个非递减的整数序列A和B，利用链表表示序列A和B，将A和B合并为一个非递减的有序序列C，序列C允许有重复的数据。要求空间复杂度为O(1)。

输入

第一行为序列A的长度n；

第二行为序列A的n个元素；

第三行为序列B的长度m；

第四行为序列B的m个元素（元素之间用空格分隔）。

输出

输出合并后的序列，每个数据之间用空格分隔。

样例输入 Copy

样例输出 Copy

1 2 3 4 5 6 7 8 9 10

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE    20
#define LISTINCREMENT   10
#define OK                1
typedef int ElemType;
typedef int Status;

typedef struct Node{
 ElemType data;
 struct Node *next;
}LNode,*LinkList;
//头插法创建链表 
void InitList(LNode *L){
 int n; scanf("%d",&n); 
 int i;
 for(i=0;i<n;i++){
  LNode *s=(LinkList)malloc(sizeof(LNode));
  scanf("%d",&s->data);  
  s->next=L->next;
  L->next=s;
 }
}
//尾插法创建链表
void Create(LNode *L){
 int n; scanf("%d",&n);
 int i;
 LNode *s,*r=L;//使r指向尾结点
 for(i=0;i<n;i++){
  s=(LinkList)malloc(sizeof(LNode));
  scanf("%d",&s->data);
  r->next=s;
  r=s;
 }
 r->next=NULL;
} 
//输出 
void print(LNode*L){//倒着输出的 
 LNode *p=L->next;
 while(p){
  printf("%d ",p->data);
  p=p->next;
 }
} 
 int ListBing(LinkList s1,LinkList s2,LinkList s3)
  {
       LNode *p=s1->next,*q=s2->next,*x=s3,*s;
       while (p&&q)     //查找第i-1个结点或遍历到表尾
        {     s=(LinkList)malloc(sizeof(LNode));
               if(p->data<=q->data)
               {
                s->data=p->data;
                p=p->next;
      }
      else if(p->data>=q->data){
       s->data=q->data;
                q=q->next;
      }
      x->next=s;
               x=s;
        }
        x->next=NULL;
        if(p)
       {
        x->next=p;
  } 
  if(q)
   {
        x->next=q; 
   }
      return 1;
    }


int main(){
 LNode line1,line2,line3;
 int i,x;
    LNode *s1=&line1,*s2=&line2,*s3=&line3;
    Create(s1);
    Create(s2);
    ListBing(s1,s2,s3);
    print(s3);
 return 0;
}