无头单链表的所有操作（包含面试题）

#define _CRT_SECURE_NO_WARNINGS 1
#include <malloc.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int DataType;
typedef struct Node
{
    DataType arr;
    struct Node* next;
}Node,*PNode;
void InitLinkList(PNode* pHead); //初始化链表
PNode BuyNode(DataType data); //新建一个结点
int SizeLinkList(PNode pHead); //求链表大小即结点个数
void PrintLinkList(PNode pHead);// 打印链表
void PushBack(PNode* pHead, DataType data);//尾插
void PopBack(PNode* pHead); //尾删
void PushFront(PNode* pHead, DataType data);//头插
void PopFront(PNode* pHead); //头删
int Find(PNode pHead, DataType data); //找到data返回data
PNode Find1(PNode pHead, DataType data);//找到data返回该结点的地址
void Insert(PNode* pHead, int pos, DataType data); //在pos的位置插入data
void Erase(PNode* pHead, int pos);  //删除pos位置的结点（pos为第几个元素）
void Erase1(PNode* pHead, PNode pos);//删除pos位置的结点（pos为指针即地址）
void Remove(PNode* pHead, DataType data);//移除data
void RemoveAll(PNode* pHead, DataType data);//移除链表中所有的data
void ResversePrintLinkList(PNode pHead); //逆序打印链表
void DeleteNotTailNode(PNode pos); // 删除不是尾结点的结点
void InsertNotHeadNode(PNode pos, DataType data); // 在不是第一个结点的位置插入data
PNode JosephCircle(PNode pHead,int m);//约瑟夫环
PNode FindTailNode(PNode pHead);//找链表的尾结点
PNode ReverseLinkList(PNode pHead);//链表逆序（三指针法）
PNode ReverseLinkList1(PNode pHead); //链表逆序（头插法）
void BubbleSort(PNode* pHead); //冒泡排序
PNode FindMidNode(PNode pHead);// 找链表的中间结点
PNode FindLastKNode(PNode pHead, int k); //找倒数第K个结点
PNode MergeLinkList(PNode pHead1, PNode pHead2); //对两个有序链表进行合并且合并后的链表依然有序
int IsCross(PNode pHead1,PNode pHead2);//判断两个无环链表是否相交
PNode GetCrossNode(PNode pHead1, PNode pHead2); //若两个无环链表相交，找到其交点
PNode HasCircle(PNode pHead); //判断一个链表是否有环
int GetCircleLen(PNode pMeetNode);  //求一个有环链表的环的长度
PNode GetEnterNode(PNode pHead,PNode pMeetNode);// 求一个有环链表环的入口点
int IsCrossWithCircle(PNode pHead1, PNode pHead2); //判断两个有环链表是否相交
void UnionSet(PNode* pHead1, PNode* pHead2); // 找到两个有序链表中的相同元素
void InitLinkList(PNode* pHead)
{
    *pHead=NULL;
}
PNode BuyNode(DataType data)
{
    PNode NewNode=(PNode)malloc(sizeof(Node));
    NewNode->arr=data;
    NewNode->next=NULL;
    return NewNode;
}
int SizeLinkList(PNode pHead)
{
    int i=0;
    if(pHead==NULL)
    {
        return 0;
    }
    else
    {
        while(pHead)
        {
            i++;
            pHead=pHead->next;
        }
        return i;
    }
}
void PrintLinkList(PNode pHead)
{
    while(pHead!=NULL)
    {
        printf("%d->",pHead->arr);
        pHead=pHead->next;
    }
    printf("NULL\n");
}
void PushBack(PNode* pHead, DataType data)
{
    assert(pHead);
    if (*pHead==NULL)
    {
        *pHead=BuyNode(data);
    }
    else 
    {
        PNode CurNode=*pHead;
        while(CurNode->next!=NULL)
        {
            CurNode=CurNode->next;
        }
        CurNode->next=BuyNode(data);
    }
}
void PopBack(PNode* pHead)
{
    assert(pHead);
    if(*pHead==NULL)
    {
        printf("该链表为空");
    }
    else 
    {
        PNode CurNode=*pHead;
        PNode PreNode=*pHead;
        while(CurNode->next!=NULL)
        {
            PreNode=CurNode;
            CurNode=CurNode->next;
        }
        PreNode->next=NULL; 
    }
}
void PushFront(PNode* pHead, DataType data)
{
    assert(pHead);
    if((*pHead)==NULL)
    {
        PNode NewNode=BuyNode(data);
        (*pHead)=NewNode;
        (*pHead)->next=NULL;
    }
    else
    {
        PNode NewNode=BuyNode(data);
        NewNode->next=(*pHead);
        (*pHead)=NewNode;
    }
}
void PopFront(PNode* pHead)
{
    assert(pHead);
    if((*pHead)==NULL)
    {
        printf("该链表为空");
    }
    else
    {
        (*pHead)=(*pHead)->next;
    }
}
int Find(PNode pHead, DataType data)
{
    PNode p=NULL;
    int pos=1;
    assert(pHead);
    if(pHead==NULL)
    {
        return 0;
    }
    else
    {
        p=pHead;
        while(p)
        {
            if(p->arr!=data)
            {
                p=p->next;
                pos++;
            }
            else
            {
                return pos;
            }
        }
    }
    printf("没找到\n");
    return 0;
}
PNode Find1(PNode pHead, DataType data)
{
    PNode pos=NULL;
    if(pHead==NULL)
    {
        return NULL;
    }
    pos=pHead;
    while(pos)
    {
        if(pos->arr==data)
        {
            return pos;
        }
        pos=pos->next;  
    }
    return NULL;
}
void Insert(PNode* pHead,int pos, DataType data)
{
    int i=0;
    PNode p=BuyNode(data);
    assert(pHead);
    i=SizeLinkList(*pHead);
    if(pos<=i && pos>1)
    {
        PNode PreNode=NULL;
        PNode CurNode=*pHead;
        while(pos-1)
        {
            PreNode=CurNode;
            CurNode=CurNode->next;
            pos--;
       }
        p->next=CurNode;
        PreNode->next=p;
    }
    else if(pos==1)
    {
        p->next=(*pHead);
        *pHead=p;
    }
    else
    {
        printf("插入结点位置不合理\n");
    }
}
void Erase(PNode* pHead,int pos)
{
    int i=0;
    i=SizeLinkList(*pHead);
    assert(pHead);
    if((*pHead)==NULL)
    {
        printf("该链表为空");
    }
    else
    {
        if(pos<=i && pos>1)
        {
            PNode PreNode=NULL;
            PNode CurNode=*pHead;
            while(pos-1)
            {
                PreNode=CurNode;
                CurNode=CurNode->next;
                pos--;
            }
            PreNode->next=CurNode->next;    
        }
        else if(pos==1)
        {
            *pHead=(*pHead)->next;
        }
        else
        {
            printf("删除结点位置不合理\n");
        }
    }
}
void Erase1(PNode* pHead, PNode pos)
{
    PNode PreNode=NULL;
    PNode CurNode=(*pHead);
    assert(pHead);
    if((*pHead)==NULL)
    {
        printf("该链表为空");
    }
    while(CurNode)
    {
        PreNode=CurNode;
        CurNode=CurNode->next;
        if(CurNode==pos)
        {
            PreNode->next=CurNode->next;
        }   
    }   
}
void Remove(PNode* pHead, DataType data)
{
    assert(pHead);
    if((*pHead)==NULL)
    {
        printf("该链表为空");
    }
    else
    {
        PNode PreNode=NULL;
        PNode CurNode=(*pHead);
        while(CurNode->next!=NULL)
        {
            PreNode=CurNode;
            CurNode=CurNode->next;
            if(CurNode->arr==data)
            {
                PreNode->next=CurNode->next;
            }
        }
    }
}
void RemoveAll(PNode* pHead, DataType data)
{
    int count=0;
    assert(pHead);
    if((*pHead)==NULL)
    {
        printf("该链表为空");
    }
    else
    {
        PNode CurNode=(*pHead);
        while(CurNode->next!=NULL)
        {
            if((CurNode->arr)==data)
            {
                count++;
            }
            CurNode=CurNode->next;
        }
    }
    while(count)
    {
        Remove(pHead,data);
        count--;
    }
}
void ResversePrintLinkList(PNode pHead)
{
    if(pHead!=NULL)
    {
        ResversePrintLinkList(pHead->next);
        printf("%d->",pHead->arr);
    }

}
void DeleteNotTailNode(PNode pos)
{
    PNode DelNode=NULL;
    if(pos==NULL || pos->next==NULL)
    {
        return;
    }
    DelNode=pos->next;
    pos->arr=DelNode->arr;
    pos->next=DelNode->next;
    free(DelNode);
}
void InsertNotHeadNode(PNode pos,DataType data)
{
    PNode NewNode=BuyNode(data);
    if(pos==NULL)
    {
        return;
    }
    NewNode->next=pos->next;
    pos->next=NewNode;
    NewNode->arr=pos->arr;
    pos->arr=data;
}
PNode FindTailNode(PNode pHead)
{
    if(pHead==NULL)
    {
        return NULL;
    }
    while(pHead->next)
    {
        pHead=pHead->next;
    }
    return pHead;
}
PNode JosephCircle(PNode pHead,int m)
{
    PNode pos=NULL;
    PNode PreNode=NULL;
    int count=0;
    if(pHead==NULL || m<=0)
    {
        return NULL;
    }
    else
    {
        pos=pHead;
        while(pos->next!=pos)
        {
            count=m;
            while(--count)
            {
                PreNode=pos;
                pos=pos->next;
            }
            PreNode->next=pos->next;
        }
        return pos;
    }
}
PNode ReverseLinkList(PNode pHead)     //三指针法
{
    PNode PreNode=pHead;
    PNode Node=PreNode->next;
    PNode NextNode=Node->next;
    if(pHead==NULL || pHead->next==NULL)
    {
        return pHead;
    }
    while(NextNode!=NULL)
    {
        Node->next=PreNode;
        PreNode=Node;
        Node=NextNode;
        NextNode=NextNode->next;
    }
    pHead->next=NULL;
    Node->next=PreNode;
    return Node;
}
PNode ReverseLinkList1(PNode pHead)     // 头插法
{
    PNode pNewHead=NULL;
    PNode CurNode=pHead;
    PNode NextNode=CurNode->next;
    if(pHead==NULL || pHead->next==NULL)
    {
        return pHead;
    }
    while(NextNode)
    {
        CurNode->next=pNewHead;
        pNewHead=CurNode;
        CurNode=NextNode;
        NextNode=NextNode->next;
    }
    CurNode->next=pNewHead;
    pNewHead=CurNode;
    return pNewHead;
}
void BubbleSort(PNode* pHead)
{
    PNode Node=*pHead;
    PNode pos=*pHead;
    PNode TailNode=NULL;
    if((*pHead)==NULL || (*pHead)->next==NULL)
    {
        return;
    }
    while(Node->next)
    {
        while(pos->next!=TailNode)
        {
            if(pos->arr>pos->next->arr)
            {
                DataType temp=pos->arr;
                pos->arr=pos->next->arr;
                pos->next->arr=temp;
            }
            pos=pos->next;
        }
        TailNode=pos;
        pos=*pHead;
        Node=Node->next;
    }
}
PNode FindMidNode(PNode pHead)
{
    PNode SlowNode=pHead;
    PNode FastNode=pHead;
    if(pHead==NULL)
    {
        printf("该链表为空");
    }
    while(FastNode && FastNode->next)
    {
        FastNode=FastNode->next->next;
        SlowNode=SlowNode->next;
    }
    return SlowNode;
}
PNode FindLastKNode(PNode pHead,int k)
{
    PNode SlowNode=pHead;
    PNode FastNode=pHead;
    if(pHead==NULL || k<=0)
    {
        return NULL;
    }
    while(k--)
    {
        FastNode=FastNode->next;
    }
    while(FastNode)
    {
        FastNode=FastNode->next;
        SlowNode=SlowNode->next;
    }
    return SlowNode;
}
PNode MergeLinkList(PNode pHead1,PNode pHead2)
{
    PNode pL1=pHead1;
    PNode pL2=pHead2;
    PNode NewNode=NULL;
    PNode TailNode=NULL;
    if(pHead1==NULL)
    {
        return pHead2;
    }
    if(pHead2==NULL)
    {
        return pHead1;
    }
    if(pL1->arr<=pL2->arr)
    {
        NewNode=pL1;
        TailNode=pL1;
        pL1=pL1->next;
    }
    else
    {
        NewNode=pL2;
        TailNode=pL2;
        pL2=pL2->next;
    }
    while(pL1 && pL2)
    {
        if(pL1->arr<=pL2->arr)
        {
            TailNode->next=pL1;
            pL1=pL1->next;
        }
        else
        {
            TailNode->next=pL2;
            pL2=pL2->next;
        }
        TailNode=TailNode->next;
    }
    if(pL1==NULL)
    {
        TailNode->next=pL2;
    }
    if(pL2==NULL)
    {
        TailNode->next=pL1;
    }
    return NewNode;
}
int IsCross(PNode pHead1,PNode pHead2)
{
    PNode pL1=pHead1;
    PNode pL2=pHead2;
    if(pL1==NULL || pL2==NULL)
    {
        return 0;
    }
    if(pL1 && pL2)
    {
        while(pL1)
        {
            pL1=pL1->next;
        }
        while(pL2)
        {
            pL2=pL2->next;
        }
        if(pL1==pL2)
        {
            return 1;
        }
    }   
    return 0;
}
PNode GetCrossNode(PNode pHead1,PNode pHead2)
{
    PNode pL1=pHead1;
    PNode pL2=pHead2;
    int size=0;
    int size1=0;
    int size2=0;
    if(pL1==NULL || pL2==NULL)
    {
        return NULL;
    }
    if(IsCross(pHead1,pHead2)==1)
    {
        size1=SizeLinkList(pHead1);
        size2=SizeLinkList(pHead2);
        size=size1-size2;
        if(size>0)
        {
            while(size--)
            {
                pL1=pL1->next;
            }
            pL1=pL1->next;
            pL2=pL2->next;
            if(pL1==pL2)
            {
                return pL1;
            }
        }
        else
        {
            size=0-size;
            while(size--)
            {
                pL2=pL2->next;
            }
            pL1=pL1->next;
            pL2=pL2->next;
            if(pL1==pL2)
            {
                return pL1;
            }
        }
    }
    return NULL;
}
PNode HasCircle(PNode pHead)
{
    PNode FastNode=pHead;
    PNode SlowNode=pHead;
    if(pHead==NULL)
    {
        return NULL;
    }
    while(FastNode && FastNode->next)
    {
        FastNode=FastNode->next->next;
        SlowNode=SlowNode->next;
        if(FastNode==SlowNode)
        {
            return FastNode;
        }
    }
    return NULL;
}
int GetCircleLen(PNode pMeetNode)
{
    PNode CurNode=pMeetNode;
    int count=1;
    if(pMeetNode==NULL)
    {
        return 0;
    }
    while(pMeetNode!=CurNode->next)
    {
        CurNode=CurNode->next;
        count++;
    }
    return count;
}
PNode GetEnterNode(PNode pHead,PNode pMeetNode)
{
    PNode pH=pHead;
    PNode pM=pMeetNode;
    if (pHead==NULL || pMeetNode==NULL)
    {
        return NULL;
    }
    while(pH!=pM)
    {
        pH=pH->next;
        pM=pM->next;
    }
    return pH;
}

int IsCrossWithCircle(PNode pHead1,PNode pHead2)
{
    PNode pM1=HasCircle(pHead1);
    PNode pM2=HasCircle(pHead2);
    if(NULL==pM1 || NULL==pM2)
    {
        return 0;
    }
    if(NULL==pM1 && NULL==pM2)
    {
        int k=0;
        return k=IsCross(pHead1,pHead2);
    }
    if(NULL!=pM1 && NULL!=pM2)
    {
        PNode CurNode=pM1;

        while(CurNode->next!=pM1)
        {
            if(pM2==CurNode)
            {
                return 1;
            }
            CurNode=CurNode->next;
        }
        if(pM2==CurNode)
        {
            return 1;
        }
    }
    return 0;
}

void UnionSet(PNode* pHead1, PNode* pHead2)
{
    PNode pL1=*pHead1;
    PNode pL2=*pHead2;
    assert(pHead1);
    assert(pHead2);
    if(NULL==(*pHead1)||NULL==(*pHead2))
    {
        printf("无相同元素");
    }
    else
    {
        while(pL1 && pL2)
        {
            if(pL1->arr>pL2->arr)
            {
                pL2=pL2->next;      
            }
            else if(pL1->arr<pL2->arr)
            {
                pL1=pL1->next;
            }
            else
            {
                printf("%d\n",pL1->arr);
                if(pL1->arr==pL1->next->arr && pL2->arr==pL2->next->arr)
                {
                    pL1=pL1->next;
                    pL2=pL2->next;
                }
                pL1=pL1->next;
                pL2=pL2->next;  
            }
        }
    }   
}
void fun()
{
    PNode pHead=NULL;
    PNode pHead1=NULL;
    PNode pHead2=NULL;
    PNode pos=NULL;
    PNode pos1=NULL;
    PNode TailNode=NULL;
    PNode TailNode1=NULL;
    PNode EnterNode=NULL;
    int i=0;
    int j=0;
    //int pos=0;
    /*InitLinkList(&pHead);
    PushBack(&pHead,1);
    PushBack(&pHead,2);
    PushBack(&pHead,3);
    PushBack(&pHead,4);
    PushBack(&pHead,5);
    PushBack(&pHead,6);
    PushBack(&pHead,7);
    PushBack(&pHead,8);
    PrintLinkList(pHead);*/
    /*PopBack(&pHead);
    PopBack(&pHead);
    PrintLinkList(pHead);   */
    PushFront(&pHead1,7);
    PushFront(&pHead1,6);
    PushFront(&pHead1,5);
    PushFront(&pHead1,5);
    PushFront(&pHead1,3);
    PushFront(&pHead1,2);
    PrintLinkList(pHead1);
    PushFront(&pHead2,9);
    PushFront(&pHead2,6);
    PushFront(&pHead2,5);
    PushFront(&pHead2,5);
    PushFront(&pHead2,1);
    PrintLinkList(pHead2);
    /*i=SizeLinkList(pHead);
    printf("%d\n",i);*/
    /*PopFront(&pHead);
    PopFront(&pHead);
    PopFront(&pHead);
    PrintLinkList(pHead);*/
    /*pos=Find1(pHead, 3);
    //printf("%p\n",pos);*/
    //Insert(&pHead,1,5);
    //PrintLinkList(pHead);
    /*Erase1(&pHead,Find1(pHead, 4));
    PrintLinkList(pHead);*/
    //PushFront(&pHead,5);
    //PushFront(&pHead,3);
    //PushFront(&pHead,6);
    //PrintLinkList(pHead);
    ///*Remove(&pHead,2);
    //PrintLinkList(pHead);*/
    //RemoveAll(&pHead,3);
    //PrintLinkList(pHead);
    /*ResversePrintLinkList(pHead);
    printf("NULL\n");*/
    //DeleteNotTailNode(pHead->next);
    //PrintLinkList(pHead);
    ///*InsertNotHeadNode(pHead->next,9);
    //PrintLinkList(pHead);*/
    /*pos=FindTailNode(pHead);
    printf("%p\n",pos);
    pos->next=pHead;
    pos1=JosephCircle(pHead,3);
    printf("%p\n",pos1);*/
    /*pos=ReverseLinkList(pHead);
    PrintLinkList(pos);*/
    /*pos=ReverseLinkList1(pHead);
    PrintLinkList(pos);*/
    /*BubbleSort(&pHead);
    PrintLinkList(pHead);*/
    /*pos=FindMidNode(pHead);
    printf("%p\n",pos);*/
    /*pos=FindLastKNode(pHead,3);
    printf("%p\n",pos);*/
    /*pos=MergeLinkList(pHead1,pHead2);
    PrintLinkList(pos);*/
    /*TailNode=FindTailNode(pHead1);
    pos=Find1(pHead2,3);
    TailNode->next=pos;*/
    //PrintLinkList(pHead1);
    //PrintLinkList(pHead2);
    //i=IsCross(pHead1,pHead2);
    //printf("%d\n",i);
    //pos1=GetCrossNode(pHead1,pHead2);
    //printf("%p\n",pos1);
    /*TailNode=FindTailNode(pHead);
    TailNode->next=Find1(pHead,3);
    pos=HasCircle(pHead);
    printf("%p\n",pos);
    printf("%d\n",GetCircleLen(pos));
    pos1=GetEnterNode(pHead,pos);
    printf("%p\n",pos1);*/
    //TailNode=FindTailNode(pHead1);// 有环相交
    //pos=Find1(pHead1,5);
    //TailNode->next=pos;
    //TailNode1=FindTailNode(pHead2);
    //pos1=Find1(pHead2,1);
    //TailNode1->next=pos1;
    //=Find1(pHead1,5);
    //i=IsCrossWithCircle(pHead1,pHead2);
    //printf("%d\n",i);
    UnionSet(&pHead1,&pHead2);
}
int main()
{
    fun();
    system("pause");
    return 0;
}