在面試中面試資料結構中關於連結串列的基本操作，從未到頭列印單鏈表、逆置\翻轉單鏈表、合併兩個有序連結串列，合併後連結串列依然有序、查詢單鏈表的中間結點，只能遍歷一次單鏈表、刪除連結串列的倒數第K個結點，要求只能遍歷一次單鏈表等連結串列的操作，都是面試中常考題，所以這些是必須會的，實現如下

head.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int DataType;

typedef struct ListNode
{
    struct ListNode* _pNext;
    DataType data;
}*PNode;



void PrintSListFromTail2Head(PNode pHead);                           // 逆序列印單鏈表 

void DeleteListNotTailNode(PNode pos);                               // 刪除連結串列的非尾結點，要求：不能遍歷連結串列 


void InesrtPosFront(PNode pos, DataType data);                      // 在連結串列pos位置前插入值到data的結點 


PNode FindMiddleNode(PNode pHead);                                  // 查詢連結串列的中間結點，要求只能遍歷一次連結串列 


PNode FindLastKNode(PNode pHead, int K);                            // 查詢連結串列的倒數第K個結點，要求只能遍歷一次連結串列


PNode DeleteLastKNode(PNode pHead, int K);                          // 刪除連結串列的倒數第K個結點，要求只能遍歷一次連結串列 


void JosephCircle(PNode* pHead, const int M);                       // 用單鏈表實現約瑟夫環 


void ReverseSList(PNode* pHead);                                    // 連結串列的逆置--三個指標 


PNode ReverseSListOP(PNode pHead);                                  // 連結串列的逆置--頭插法 


void BubbleSort(PNode pHead);                                        // 用氣泡排序思想對單鏈表進行排序 


PNode MergeSList(PNode pHead1, PNode pHead2);                       // 合併兩個有序單鏈表，合併後依然有序


int IsSListCross(PNode pHead1, PNode pHead2);                       // 判斷兩個單鏈表是否相交---連結串列不帶環 


PNode GetCorssNode(PNode pHead1, PNode pHead2);                     // 求兩個單鏈表相交的交點---連結串列不帶環 
 

head.c

#include"head.h"

void PrintSListFromTail2Head(PNode pHead)                           // 逆序列印單鏈表 
{   
    assert(pHead);
    PNode pNewNode = pHead;

    if (NULL == pHead)
    {
        return;
    }
    else if (pNewNode)
    {
        PrintSListFromTail2Head(pNewNode->_pNext);
    }
    printf("%d", pNewNode->data);
    return;
}

void DeleteListNotTailNode(PNode pos)                               // 刪除連結串列的非尾結點，要求：不能遍歷連結串列 
{
    PNode p_Cur = pos->_pNext;
    pos->data =p_Cur->data;
    pos->_pNext = p_Cur->_pNext;
    free(p_Cur);
    p_Cur = NULL;
}

void InesrtPosFront(PNode pos, DataType data)                       // 在連結串列pos位置前插入值到data的結點 
{
    PNode p = pos->_pNext;                     //放置pos位置後面的指標
    pos ->_pNext = (PNode)BuyNewNode(pos->data);      //新建立的結點放在pos後面,並且新建立的結點的data是pos位置的data
    pos->_pNext->_pNext = p;                   //將原來pos後面的結點連線起來
    pos->data = data;                          //將需要插入的資料元素放在pos的位置
 

}

PNode FindMiddleNode(PNode pHead)                                  // 查詢連結串列的中間結點，要求只能遍歷一次連結串列 
{
    assert(pHead);
    if (NULL == pHead->_pNext )
    {
        return pHead;
    }
    PNode Fast = pHead;                        //建立一個快指標，每次走兩步
    PNode Slow = pHead;                        //建立一個慢指標，一次走一步

    while (Fast && Fast->_pNext)               //判斷元素個數是奇數和偶數時，返回中間結點
    {
        Fast = Fast->_pNext->_pNext;
        Slow = Slow->_pNext;
    }
    return Slow;                               //最後返回慢指標剛好走到中間結點
}

PNode FindLastKNode(PNode pHead, int K)                            // 查詢連結串列的倒數第K個結點，要求只能遍歷一次連結串列
{
    assert(pHead);
    if (NULL == pHead || K<=0)                                 //判空連結串列和輸入的合法性
    {
        return NULL;
    }
    PNode Fast = pHead;
    PNode Slow = pHead;

    while (K--)
    {
        Fast = Fast->_pNext;                                  //快指標先向後走k步，然後慢指標和快指標一起以相同的速度向後走
    }

    while (Fast)
    {
        Fast = Fast->_pNext;
        Slow = Slow->_pNext;
    }
        return Slow;
}

PNode DeleteLastKNode(PNode pHead, int K)                          // 刪除連結串列的倒數第K個結點，要求只能遍歷一次連結串列 
{
    assert(pHead);
    if (NULL == pHead)
    {
        return NULL;
    }
    PNode Fast = pHead;
    PNode Slow = pHead;
    PNode Cur_Node = NULL;

    while (K--)
    {
        Fast = Fast->_pNext;                                  //快指標先向後走k步，然後慢指標和快指標一起以相同的速度向後走
    }

    while (Fast)
    {
        Fast = Fast->_pNext;
        Cur_Node = Slow;
        Slow = Slow->_pNext;
        Cur_Node->_pNext = Slow->_pNext;
    }
    return pHead;
}

void JosephCircle(PNode* pHead, const int M)                        // 用單鏈表實現約瑟夫環 
{
    PNode Cur_node = NULL;
    PNode Del_node = NULL;
    int count = 0;
    assert(pHead);
    if (NULL == pHead || M <= 0)
    { 
        return;
    }

    Cur_node = *pHead;
    while (Cur_node->_pNext)
    {
        Cur_node = Cur_node->_pNext;
    }
    Cur_node->_pNext = *pHead;
    Cur_node = *pHead;

    while (Cur_node->_pNext != Cur_node)
    {
        count = M;
        while (--count)
        {
            Cur_node = Cur_node->_pNext;
        }
        Del_node = Cur_node->_pNext;
        Cur_node->_pNext  = Del_node->_pNext;
        free(Del_node);
        Del_node = NULL;
    }

}

void ReverseSList(PNode* pHead)                                    // 連結串列的逆置--三個指標 
{
    PNode Pre_node = NULL;
    PNode Cur_node = NULL;
    PNode Next_node = NULL;
    assert(pHead);
    Cur_node = *pHead;
    while (Cur_node)
    {
        Pre_node = Cur_node;
        Cur_node = Cur_node->_pNext;
        Pre_node->_pNext = Next_node;
        Next_node = Pre_node;
    }
}   

PNode ReverseSListOP(PNode pHead)                                  // 連結串列的逆置--頭插法 
{
    PNode Cur_node = NULL;
    PNode Next_node = NULL;
    assert(pHead);
    if (NULL == pHead || NULL == pHead->_pNext)
    {
        return NULL;
    }

    while (pHead)
    {
        Cur_node = pHead;
        pHead = pHead->_pNext;
        Cur_node->_pNext = Next_node;
        Next_node = Cur_node;
    }
    pHead = Next_node;

    return pHead;
}



void BubbleSort(PNode pHead)                                        // 用氣泡排序思想對單鏈表進行排序,從小到大排序
{
    PNode Tail = NULL;
    PNode P_Cur = pHead;
    int flag = 0;

    if (NULL == pHead || NULL == pHead->_pNext)
    {
        return;
    }

    while (Tail != pHead)                   //先判斷單鏈表是否是有序的，按照排序結果，如果一趟排序，標記flag沒有發生變化就直接列印單鏈表
    {
        P_Cur = pHead;
        flag = 0;
    }

    while (P_Cur!=Tail)
    {
        while (P_Cur->_pNext!=Tail)
        {
            if (P_Cur->data > P_Cur->data)
        {
            DataType tmp = P_Cur->data;
            P_Cur->data = P_Cur->_pNext->data;
            P_Cur->_pNext->data = tmp;
            flag = 1;
        }
            P_Cur = P_Cur->_pNext;
        }
        Tail = P_Cur;

        if (0 == flag)
        {
            return;
        }

    }
}

PNode MergeSList(PNode pHead1, PNode pHead2)                       // 合併兩個有序單鏈表，合併後依然有序
{   
    PNode  P_NewNode = NULL;
    pHead1 = pHead1->_pNext;
    pHead2 = pHead2->_pNext;
    P_NewNode = pHead1;

    while (pHead1 && pHead2)                                    //兩個連結串列首先都不為空，然後判斷兩個連結串列的data的大小
    {
        if (pHead1->data > pHead2->data)
        {
            P_NewNode = P_NewNode->_pNext;
            P_NewNode->data  = pHead2->data;
            pHead2 = pHead2->_pNext;
        }
        else
        {
            P_NewNode = P_NewNode->_pNext;
            P_NewNode->data  = pHead1->data;
            pHead1 = pHead1->_pNext;
        }
    }
    P_NewNode->_pNext = pHead1 ? pHead1 : pHead2;         //判斷連結串列是否一個已經為空,直接將另一個連結串列的內容連結在後面
    free(pHead2);
    return P_NewNode;
}

int IsSListCross(PNode pHead1, PNode pHead2)                        // 判斷兩個單鏈表是否相交---連結串列不帶環 
{
    PNode p1 = pHead1;
    PNode p2 = pHead2;
    int p1_Size = 0;                   //pHead1的大小，設定計數器計數
    int p2_Size = 0;                   //pHead2的大小，設定計數器計數
    int k = 0;                         //PHead1和PHead大小比較相差的步數

    if (NULL == p1 || NULL == p2)                               //判斷連結串列是否為空，如果為空就返回0，所以不想交
    {                                    
        return 0;
    }

    while (p1)                                        //連結串列1不為空繼續計數
    {
        p1_Size++;
        p1 = p1->_pNext;
    }
        while (p2)                                       //連結串列的大小
    {
    p2_Size++;
    p2 = p2->_pNext;
}

if (p1_Size > p2_Size)
{
    k = p1_Size - p2_Size;
    while (k--)
    {
        p1->_pNext;
    }
    p2->_pNext;
    if (p1->data == p2->data)
    {
        return 1;
    }
}

if (p1_Size < p2_Size)
{
    k = p2_Size - p1_Size;
    while (k--)
    {
        p2->_pNext;
    }
    p1->_pNext;
}
if (p1->data == p2->data)
{
    return 1;
}
 

}

PNode GetCorssNode(PNode pHead1, PNode pHead2)                     // 求兩個單鏈表相交的交點---連結串列不帶環
{   
    PNode p1 = pHead1;
    PNode p2 = pHead2;
    int p1_Size = 0;                   //pHead1的大小，設定計數器計數
    int p2_Size = 0;                   //pHead2的大小，設定計數器計數
    int k = 0;                         //PHead1和PHead大小比較相差的步數

    if (NULL == p1 || NULL == p2)                               //判斷連結串列是否為空，如果為空就返回0，所以不想交
    {
        return NULL;
    }

    while (p1)                                        //連結串列1不為空繼續計數
    {
        p1_Size++;
        p1 = p1->_pNext;
    }
    while (p2)                                       //連結串列的大小
    {
        p2_Size++;
        p2 = p2->_pNext;
    }

    if (p1_Size > p2_Size)
    {
        k = p1_Size - p2_Size;
        while (k--)
        {
            p1->_pNext;
        }
        p2->_pNext;
        if (p1->data == p2->data)
        {
            return p1;
        }
    }

    if (p1_Size < p2_Size)
    {
        k = p2_Size - p1_Size;
        while (k--)
        {
            p2->_pNext;
        }
        p1->_pNext;
    }
    if (p1->data == p2->data)
    {
        return p1;
    }
    else
    {
        return NULL;
    }

}