有头结点的单链表的各种操作

//有头结点的单链表

template <class T>
struct Node
{
    T data;
    Node<T> *next;
};
//-----------------------------------------------
//初始化单链表
template <class T>
int init_list(Node<T> **L)
{
    (*L) = (Node<T>*)malloc(sizeof(Node<T>));
    (*L)->next = NULL;
    return 1;
}
//-----------------------------------------------
//从尾部追加一个结点
template <class T>
int append_list(Node<T> *L , T data)
{
    Node<T>* pNewNode = (Node<T>*)malloc(sizeof(Node<T>));

    pNewNode->data = data;
    pNewNode->next = NULL;

    Node<T>* pNode = L;
    while(pNode->next != NULL)
    {
        pNode = pNode->next;
    }
    pNode->next = pNewNode;
    return 1;
}
//删除尾部结点
template <class T>
int delete_tail_list(Node<T> *L)
{
    if(L == NULL)
        return 0;
    Node<T> *pNode = L->next;
    Node<T> *pPre = L;

    while(pNode != NULL)
    {
        if(pNode->next == NULL)
        {
            pPre->next = NULL;
            free(pNode);
            cout << "delete tail node success!" << endl;
            break;
        }
        pNode = pNode->next;
        pPre = pPre->next;
    }
    return 1;
}
//----------------------------------------------------------
//从头部添加一个结点
template <class T>
int add_head_list(Node<T> *L , T data)
{
    if(L == NULL)
        return 0;

    Node<T> *pNewNode = (Node<T>*)malloc(sizeof(Node<T>));
    
    pNewNode->data = data;
    pNewNode->next = L->next;
    
    L->next = pNewNode;
    
    return 1;
}
//从头部删除一个结点
template <class T>
int delete_head_list(Node<T> *L)
{
    if(L == NULL)
        return 0;
    if(L->next != NULL)
    {
        Node<T> *pNode = L->next;

        L->next = L->next->next;
        free(pNode);
        cout << "delete head list success!" << endl;
    }
    return 1;
}
//----------------------------------------------------------
//从指定位置pos(1~~len)添加
template <class T>
int insert_list(Node<T> *L , int pos , T data)
{
    if(L == NULL)
        return 0;
    Node<T> *pPre = L;
    Node<T> *pNode = L->next;

    int index = 0;
    while(pNode != NULL)
    {
        index++;

        if(pos == index)
        {
            Node<T> *pNewNode = (Node<T>*)malloc(sizeof(Node<T>));
            pNewNode->data = data;
            pNewNode->next = pNode;

            pPre->next = pNewNode;

            return 1;
        }
        pNode = pNode->next;
        pPre = pPre->next;
    }
    cout << "pos(" << pos << ") error" << endl;
    return 0;
}
//从指定位置pos(1~~len)删除一个结点
template <class T>
int delete_pos_list(Node<T> *L , int pos)
{
    if(L == NULL)
        return 0;

    Node<T> *pPre = L;
    Node<T> *pNode = L->next;

    int index = 0;
    while(pNode != NULL)
    {
        index++;
        if(pos == index)
        {
            pPre->next = pNode->next;
        
            pNode->next = NULL;
            free(pNode);

            return 1;
        }

        pNode = pNode->next;
        pPre = pPre->next;
    }
    cout << "pos(" << pos << ") error" << endl;
    return 0;
}
//-----------------------------------------------
//判断是否为空
template <class T>
bool isempyt(Node<T> *L)
{
    if(L->next == NULL)
        return true;
    return false;
}
//-----------------------------------------------
//清除链表
template <class T>
int clear_list(Node<T> *L)
{
    Node<T> *pNode = NULL;

    if(L == NULL)
    {
        return 0;
    }
    while(L->next != NULL)
    {
        pNode = L->next;
        L->next = L->next->next;
        free(pNode);
    }
    return 1;
}
//-----------------------------------------------
//删除链表
template <class T>
int delete_list(Node<T> **L)
{
    clear_list(*L);
    free(*L);
    *L = NULL;
    return 1;
}
//-----------------------------------------------
//返回长度
template <class T>
int len_list(Node<T> *L)
{
    Node<T> *pNode = L->next;

    int len = 0;
    while(pNode != NULL)
    {
        len++;
        pNode = pNode->next;
    }
    return len;
}
//-----------------------------------------------
//正序打印整个列表
template <class T>
void print_list(Node<T> *L)
{
    Node<T> * pNode = L->next;

    while(pNode != NULL)
    {
        cout << pNode->data << "  ";
        pNode = pNode->next;
    }
    cout << endl;
}
//-----------------------------------------------
//倒序打印整个列表(递归调用)
template <class T>
void reverse(Node<T> *pNode)
{
    if(pNode == NULL)
        return;
    if(pNode->next != NULL)
    {
        reverse(pNode->next);
    }
    
    cout << pNode->data << "  ";
    
    return;
}
template <class T>
void print_reverse_list(Node<T> *L)
{
    if(L == NULL)
        return;
    reverse(L->next);
    cout << endl;
    return;
}
//-----------------------------------------------
//倒置整个链表(非递归,用stack)
template <class T>
void reverse_list(Node<T> *L)
{
    if(L == NULL)
        return;
    
    stack<Node<T> *> st;

    Node<T> *pNode = L->next;
    Node<T> *pTemp = NULL;
    while(pNode != NULL)
    {
        st.push(pNode);

        pTemp = pNode;
        
        pNode = pNode->next;
        
        pTemp->next = NULL;
    }

    pNode = L;
    while(!st.empty())
    {
        pTemp = st.top();

        pNode->next = pTemp;
        pNode = pNode->next;
        st.pop();
    }
}

//倒置整个链表(非递归不用stack)
template <class T>
void reverse_list1(Node<T> *L)
{
    if(L == NULL)
        return;
    Node<T> * pNode = L->next;
    Node<T> * pNewNode = NULL;
    while(pNode != NULL)
    {
        Node<T> *pCur = pNode;
        pNode = pNode->next;
        pCur->next = pNewNode;
        pNewNode = pCur;
    }
    L->next = pNewNode;
}
//-----------------------------------------------
//返回倒数第K个结点
template <class T>
Node<T> *reci_node(Node<T> *L , int k)
{
    if(L == NULL || k <= 0)
        return NULL;
    Node<T> *pNode = L;
    Node<T> *kNode = L->next;
    
    if(kNode == NULL) return NULL;//无元素结点直接返回

    while(k > 0)
    {
        k--;
        pNode = pNode->next;
        if(pNode->next == NULL)    //已经是最后一个结点了
            break;
    }
    if(k > 0) return NULL;//超过长度

    while(pNode->next != NULL && kNode->next != NULL)
    {
        kNode = kNode->next;
        pNode = pNode->next;
    }

    return kNode;
}
//-----------------------------------------------
//返回链表中单结点
template <class T>
Node<T> * middle_node(Node<T> *L)
{
    if(L == NULL || L->next == NULL || L->next->next == NULL || L->next->next->next == NULL)//至少三个元素结点
        return NULL;

    Node<T> * pFast = L->next;
    Node<T> * pSlow = L->next;

    while(pFast->next != NULL)
    {
        pSlow = pSlow->next;    //慢指针一次走一步
        pFast = pFast->next;    //快指针一次走两步(第一步)
        if(pFast->next != NULL)
        {
            pFast = pFast->next;    //快指针一次走两步(第二步)走够两步的是单数个元素
        }
        else
        {
            break;        //快指针走了一步就到尾部了,没走够两步的是双数个元素
        }
    }
    return pSlow;
}
//-----------------------------------------------
//冒泡排序
void bubble_sort_list(Node<int> *L)
{
    if(L == NULL)
        return;

    Node<int> *pFlag = NULL;    //标志指针,有序区的首个结点指针,开始有序区没有结点所以NULL

    while(pFlag != L->next)        //
    {
        Node<int> *pCur = L->next;
        Node<int> *pNext = pCur->next;

        while(pNext != pFlag)
        {
            if(pCur->data > pNext->data)
            {
                int data = pCur->data;
                pCur->data = pNext->data;
                pNext->data = data;
            }
            pCur = pCur->next;
            pNext = pNext->next;
        }
        pFlag = pCur;    //一趟比较后有序区首结点指针
    }
}

//-----------------------------------------------
//把两个有序的链表合并成一个新链表,新链表也要求是有序的
Node<int> *merge_list(Node<int> *L1 , Node<int> *L2)
{
    if(L1 == NULL || L2 == NULL) return NULL;
    if(L1->next == NULL && L2->next == NULL) return NULL;
    
    if(L1->next != NULL && L2->next == NULL) return L1;
    if(L2->next != NULL && L1->next == NULL) return L2;

    Node<int> *pNewList = NULL;
    init_list(&pNewList);
    Node<int> *tail = pNewList;

    Node<int> *p1 = L1->next;
    L1->next = NULL;
    Node<int> *p2 = L2->next;
    L2->next = NULL;

    while(p1 != NULL && p2 != NULL)
    {
        if(p1->data < p2->data)
        {
            tail->next = p1;
            p1 = p1->next;
            tail = tail->next;
        }
        else
        {
            tail->next = p2;
            p2 = p2->next;
            tail = tail->next;
        }
    }

    if(p1 != NULL)
    {
        tail->next = p1;
    }
    if(p2 != NULL)
    {
        tail->next = p2;
    }
    
    return pNewList;
}
//-----------------------------------------------
//测试单链表
void simple_list_main()
{
    Node<int> *pList = NULL;

    init_list(&pList);

    append_list(pList , 2);
    append_list(pList , 12);
    append_list(pList , 23);
    append_list(pList , 52);
    append_list(pList , 92);
    append_list(pList , 22);
    append_list(pList , 102);
    append_list(pList , 18);
    append_list(pList , 45);
    
    print_list(pList);
    //--------------------------------------------------------
    cout << "add head list : 100" << endl;
    add_head_list(pList , 100);
    print_list(pList);
    //--------------------------------------------------------
    cout << "add list pos 1 : 999" << endl;
    insert_list(pList , 1 , 999);
    print_list(pList);

    //--------------------------------------------------------
    Node<int> *kNode = reci_node(pList, 11);
    if(kNode != NULL)
    {
        cout << "reci k : " << 11 << " data : "<< kNode->data << endl;
    }
    //--------------------------------------------------------
    Node<int> *mNode = middle_node(pList);
    if(mNode != NULL)
    {
        cout << "middle node : " << mNode->data << endl;
    }
    //--------------------------------------------------------
    cout << "bubble sort list: " << endl;
    bubble_sort_list(pList);
    print_list(pList);

    Node<int> *pOtherList = NULL;
    init_list(&pOtherList);
    append_list(pOtherList , 1);
    append_list(pOtherList , 312);
    append_list(pOtherList , 25);
    append_list(pOtherList , 57);
    append_list(pOtherList , 91);
    append_list(pOtherList , 27);
    append_list(pOtherList , 1001);
    append_list(pOtherList , 28);
    append_list(pOtherList , 49);

    cout << "other list : " << endl;
    print_list(pOtherList);

    cout << "bubble sort list: " << endl;
    bubble_sort_list(pOtherList);
    print_list(pOtherList);
    //--------------------------------------------------------
    Node<int> *pNewList = merge_list(pList , pOtherList);
    cout << "merge pList and pOtherList : " << endl;
    print_list(pNewList);

    //--------------------------------------------------------
    cout << "delete pos 18 list " << endl;
    delete_pos_list(pNewList , 18);
    print_list(pNewList);
    //--------------------------------------------------------
    cout << "print reverse list:" << endl;

    print_reverse_list(pNewList);

    //--------------------------------------------------------
    cout << "reverse list:" << endl;

    reverse_list1(pNewList);
    print_list(pNewList);

    cout << "list len : " << len_list(pNewList) <<  endl; 

    //--------------------------------------------------------
    delete_tail_list(pNewList);
    print_list(pNewList);
    //--------------------------------------------------------
    delete_head_list(pNewList);
    print_list(pNewList);
    //=========================================================
    cout << "clear list" << endl;
    clear_list(pNewList);
    
    cout << "list len : " << len_list(pNewList) <<  endl;

    cout << "delete list" << endl;
    delete_list(&pNewList);
    delete_list(&pList);
    delete_list(&pOtherList);
    return;
}