数据结构：单向链表-CFANZ编程社区

结构体

创建链表

结构体

typedef int DataType;
typedef struct node
{
    DataType data;
    struct node *pnext;
}LinkNode;

创建链表

LinkNode *CreateLinklist()
{
    LinkNode *pHead=NULL;
    pHead=malloc(sizeof(LinkNode));
    if(pHead==NULL)
    {
        return NULL;
    }
    pHead->pnext=NULL;
    return pHead;
}

插入链表

头插法

int HeadInsertLink(LinkNode *pHead,DataType data)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=malloc(sizeof(LinkNode));
    if(pTmpnode==NULL)
    {
        return -1;
    }
    pTmpnode->data=data;
    pTmpnode->pnext=pHead->pnext;
    pHead->pnext=pTmpnode;
    return 0;
}

尾插法

int TailInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *ptmpnode=NULL;
    LinkNode *Newnode=NULL;
    ptmpnode=pHead;
    while (ptmpnode->pnext!=NULL)
    {
        ptmpnode=ptmpnode->pnext;
    }
    Newnode=malloc(sizeof(LinkNode));
    if(Newnode==NULL)
    {
        return -1;
    }
    Newnode->data=TmpData;
    Newnode->pnext=NULL;
    ptmpnode->pnext=Newnode;
    return 0;
}

遍历打印

int Showlist(void *Element,void *arg)
{
    int *data = Element;
    printf("%d  ",*data);
    return 0;
}
int ShowLinkList(LinkNode *pHead,int (*pFun)(void *Element,void *arg),void *arg)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead->pnext;
    int ret=0;
    while(pTmpnode!=NULL)
    {
        ret=pFun(&pTmpnode->data,arg);
        if(ret!=0)
        {
            break;
        }
        pTmpnode=pTmpnode->pnext;
    }
    return 0;
}

更新链表指定节点

int UpdateLinkList(LinkNode *pHead, DataType OldData, DataType NewData)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead;
    while(pTmpnode!=NULL)
    {   
        if(pTmpnode->data==OldData)
        {
             pTmpnode->data=NewData;
        }
        pTmpnode=pTmpnode->pnext;
   
    }
    
    return 0;
}

查找链表指定节点

LinkNode *FindLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead;
    while(pTmpnode->data!=TmpData)
    {
        pTmpnode=pTmpnode->pnext;
    }
    return pTmpnode;
}

删除链表指定节点

int DeleteLinklist(LinkNode *pHead,DataType data)
{
    LinkNode *pTmpnode=NULL;
    LinkNode *pPreNode=NULL;
    pTmpnode=pHead;
    pPreNode=pHead;
    while(pTmpnode!=NULL)
    {
       if((pTmpnode->data!=data)) 
       {
            pPreNode=pTmpnode;
            pTmpnode=pTmpnode->pnext;
       }
        else
        {
            pPreNode->pnext=pTmpnode->pnext;
            free(pTmpnode);
            pTmpnode=pPreNode->pnext;
        }
    }
  
    return 0;

}

销毁链表

int DestoryLinklist(LinkNode **pHead)
{
    LinkNode *pTmpnode=NULL;
    LinkNode *pTmpnext=NULL;
    pTmpnode=*pHead;

    while(pTmpnode!=NULL)
    {
        pTmpnext=pTmpnode->pnext;
        free(pTmpnode);
        pTmpnode=pTmpnext; 
    }
    *pHead=NULL;
    return 0;
}

找到元素中间位置

LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast=pHead->pnext;
    LinkNode *pSlow=pHead->pnext;
    while(pFast!=NULL)
    {
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            break;
        }
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            break;
        }
        pSlow=pSlow->pnext;
    }
    return pSlow;
}

找到链表倒数第k个节点

LinkNode *FindKthLinkNode(LinkNode *pHead,int k)
{
    int i=0;
    LinkNode *pFast=pHead->pnext;
    LinkNode *pSlow=pHead->pnext;
    for(i=0;i<k;i++)
    {
        pFast=pFast->pnext;
        if(pFast->pnext==NULL)
        {
            return NULL;
        }
    }
    while(pFast!=NULL)
    {
        pFast=pFast->pnext;
        pSlow=pSlow->pnext;
    }
    return pSlow;
}

链表元素倒置

int ReverseLinkList(LinkNode *pHead)
{
    LinkNode *pInsertNode=pHead->pnext;
    LinkNode *pTmpNode=pHead->pnext;
    pHead->pnext=NULL;
    while(pTmpNode!=NULL)
    {
        //保留革命火种
        pTmpNode=pTmpNode->pnext;
        //将剩余链表的第一个插入头结点pnext
        pInsertNode->pnext=pHead->pnext;
        pHead->pnext=pInsertNode;
        //插入节点向后移动
        pInsertNode=pTmpNode;
    }
    return 0;
}

链表元素排序

冒泡排序

int BubbleLinkList(LinkNode *pHead)
{
    LinkNode *ptmpNode1=NULL;
    LinkNode *ptmpNode2=NULL;
    LinkNode *pEnd=NULL;
    DataType pTmpData;
//没有元素或只有一个元素直接返回
    if(pHead->pnext==NULL ||pHead->pnext->pnext==NULL)
    {
        return -1;
    }
    while(1)
    {
        ptmpNode1=pHead->pnext;
        ptmpNode2=pHead->pnext->pnext;
//最后一次只有两个元素，此时链表已经排好序，pEnd和pTmpNode
相等，直接结束外层循环        
        if(ptmpNode2==pEnd)
        {
            break;
        }


//第一次排序结束时标志为pTmpNode=NULL,但是pEnd此时还是NULL,所以这里直接写成pEnd
        while(ptmpNode2!=pEnd)
        {
            if(ptmpNode1->data > ptmpNode2->data)
            {
                pTmpData=ptmpNode1->data;
                ptmpNode1->data=ptmpNode2->data;
                ptmpNode2->data=pTmpData;
            }
            ptmpNode1=ptmpNode1->pnext;
            ptmpNode2=ptmpNode2->pnext;
        }    
        pEnd=ptmpNode1;
    }
    return 0;
}

选择排序

//选择排序
int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pSwapNode=pHead->pnext;
    LinkNode *pMinNode=pHead->pnext;
    LinkNode *pTmpNode=NULL;
    DataType TmpData;
    if(pHead->pnext==NULL)
    {
        return 0;
    }
    while(pSwapNode->pnext!=NULL)
    {
        pMinNode=pSwapNode;
        pTmpNode=pSwapNode->pnext;
        while(pTmpNode!=NULL)
        {
            if(pMinNode->data >pTmpNode->data )
            {
                pMinNode=pTmpNode;
            }
            pTmpNode=pTmpNode->pnext;
        }
        if(pMinNode->data < pSwapNode->data)
        {
            TmpData=pMinNode->data;
            pMinNode->data=pSwapNode->data;
            pSwapNode->data=TmpData;
        }
        pSwapNode=pSwapNode->pnext;
    }
    return 0;
}

如何判断一个链表是否有环？环长？环的入口位置？

LinkNode *IsHasCircle(LinkNode *pHead,int *len)
{
    int ret=0;
    *len=1;
    LinkNode *pFast=NULL;
    LinkNode *pSlow=NULL;
    LinkNode *pTmpNode=NULL;
    LinkNode *pNode1=NULL;
    LinkNode *pNode2=NULL;
    pFast=pSlow=pHead->pnext;
//判断是否有环
    while(1)
    {
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            ret=0;
            break;
        }
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            ret=0;
            break;
        }
        pSlow=pSlow->pnext;
        if(pFast==pSlow)
        {
            ret=1;
            break;
        }
    }
    if(ret==1)
    {
        //获得环长
        pTmpNode=pSlow->pnext;
        while(pTmpNode!=pSlow)
        {
            (*len)++;
            pTmpNode=pTmpNode->pnext;
        }
        获得环入口节点
        pNode1=pHead->pnext;
        pNode2=pSlow;
        while(pNode1!=pNode2)
        {
            pNode1=pNode1->pnext;
            pNode2=pNode2->pnext;
        }
        return pNode1;
        
    }
    return NULL;
}