单项链表以及环链表

简单操作有：    1.创建  2.销毁 3.插入  4.删除 5.打印  6.修改 7.查询

主要是复杂操作：

一、找到中间节点位置

//算法：
//  快指针pFast每次走2步
//  慢指针pSlow每次走1步
//  快指针到达末尾时，慢指针所在的位置即为中间位置
LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;

    pFast = pSlow = pHead->pNext;
    while (pFast != NULL)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }

        pSlow = pSlow->pNext;
    }

    return pSlow;
}

二、找到链表倒数第k个节点

//算法：
//  快指针先走k步
//  慢指针和快指针每次走1步(快指针总是领先慢指针k步)
//  当快指针走到末尾时,慢指针即指向链表倒数第k个节点
LinkNode *FindLastKthLinkNode(LinkNode *pHead, int k)
{
    LinkNode *pFast = pHead->pNext;
    LinkNode *pSlow = pHead->pNext;
    int i = 0;

    for (i = 0; i < k; i++)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
    }

    if (NULL == pFast)
    {
        return NULL;
    }

    while (pFast != NULL)
    {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext;
    }

    return pSlow;
}

三、倒置链表

int ReversalLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pHead->pNext;
    pHead->pNext = NULL;
    pInsertNode = pTmpNode;

    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        pInsertNode->pNext = pHead->pNext;
        pHead->pNext = pInsertNode;
        pInsertNode = pTmpNode;
    }

    return 0;
}

四、冒泡排序

int BubbleSortLinkList(LinkNode *pHead)
{   
    LinkNode *pTmpNode1 = NULL;
    LinkNode *pTmpNode2 = NULL;
    LinkNode *pEnd = NULL;
    DataType TmpData;

    //如果链表没有节点或者只有1个节点返回0 
    if (NULL == pHead->pNext || NULL == pHead->pNext->pNext)
    {
        return 0;
    }

    while (1)
    {
        pTmpNode1 = pHead->pNext;
        pTmpNode2 = pHead->pNext->pNext;
        if (pTmpNode2 == pEnd)
        {
            break;
        }

        while (pTmpNode2 != pEnd)
        {
            if (pTmpNode1->Data > pTmpNode2->Data)
            {
                TmpData = pTmpNode1->Data;
                pTmpNode1->Data = pTmpNode2->Data;
                pTmpNode2->Data = TmpData;
            }
            pTmpNode1 = pTmpNode1->pNext;
            pTmpNode2 = pTmpNode2->pNext;
        }
        pEnd = pTmpNode1;
    }
    
    return 0;
}

五、选择排序

类似暂定一个最小的 后面找到最小则和前面互换  循环比较

int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pMinNode = NULL;
    LinkNode *pSwapNode = NULL;
    DataType TmpData;

    if (NULL == pHead->pNext)
    {
        return 0;
    }

    pSwapNode = pHead->pNext;

    while (pSwapNode->pNext != NULL)
    {
        pMinNode = pSwapNode;
        pTmpNode = pSwapNode->pNext;
        while (pTmpNode != NULL)
        {
            if (pTmpNode->Data < pMinNode->Data)
            {
                pMinNode = pTmpNode;
            }
            pTmpNode = pTmpNode->pNext;
        }
        if (pMinNode != pSwapNode)
        {
            TmpData = pMinNode->Data;
            pMinNode->Data = pSwapNode->Data;
            pSwapNode->Data = TmpData;
        }
        pSwapNode = pSwapNode->pNext;
    } 

    return 0;
}

最后还有一个环链表：如何判断一个链表是否有环？环长？环的入口位置？
        （1）是否有环：快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环
        （2）如何计算环长：标记相遇的位置，让指针继续向后走，没走一步计算器自加,走回到标记位置，则计算器值即为环长
        （3）如何计算环入口位置：将一个指针从第一个节点向后走，将一个指针从相遇点向后走，两个指针相遇的位置即为环入口的位置

//判断链表是否有环
//实现方式：
//     快指针每次走2步，慢指针每次走1步
//     两者能够相遇即为有环
LinkNode *IsHasCircle(LinkNode *pHead, int *pcnt)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;
    LinkNode *pTmpNode = NULL;
    LinkNode *pNode1 = NULL;
    LinkNode *pNode2 = NULL;
    int ret = 0;
    int cnt = 1;

    pSlow = pFast = pHead->pNext;
    while (1)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }

        pSlow = pSlow->pNext;
        if (pSlow == pFast)
        {
            ret = 1;
            break;
        }
    }

    if (1 == ret)
    {
        //获得环长
        pTmpNode = pSlow->pNext;
        while (pTmpNode != pSlow)
        {
            cnt++;
            pTmpNode = pTmpNode->pNext;
        }
        *pcnt = cnt;

        //获得环入口位置
        pNode1 = pSlow;
        pNode2 = pHead->pNext;
        while (1)
        {
            pNode1 = pNode1->pNext;
            pNode2 = pNode2->pNext;
            if (pNode1 == pNode2)
            {
                return pNode1;
            }
        }
    }

    return NULL;
}