二叉樹的高度 、銷燬、鏈表的翻轉（k爲一組、n-m 之間）兩種實現、

1.二叉樹的高度：

//實現思路：左右子樹較高的一支，將其結果結+1就是當前樹的高度
size_t GetHeight(Node* pRoot)
{
    if (pRoot)
    {
        size_t left = GetHeight(pRoot->pLeft);
        size_t right= GetHeight(pRoot->pRight);
        return left > right ? left + 1 : right + 1;
    }

2.二叉樹的銷燬

//實現思路：後序遍歷，進行銷燬
void Destroy(Node*& pRoot) //參數最好給引用，方便直接修改外部參數爲NULL
{
    if (pRoot)
    {
        Destroy(pRoot->pLeft);
        Destroy(pRoot->pRight);

        delete pRoot;
        pRoot = NULL;
    }
}

3.鏈表的翻轉（以k爲一組）

//以K爲單位翻轉鏈表
//思路：兩種實現思路：1.遞歸法2.迭代法

//遞歸出口，如果鏈表長度小於
//實現區間內的鏈表翻轉，並且返回翻轉後的頭結點
//內部調用自己，將返回結果善加利用

Node* reversekGroup1(Node* head, int k)
{
    if (head == NULL || head->pNext == NULL || k < 2)
    {
        return head;
    }

    Node* next_group = head;
    for (int i = 1; i < k; i++)  //走k-1步
    {
        if (next_group)
        {
            next_group = next_group->pNext;
        }
        else
        {
            return head;   //長度小於K  ，直接返回頭結點
        }
    }
    Node* new_next_group = reversekGroup1(next_group,k);//返回下一組的頭結點

    Node* prev = NULL, *cur = head;


    while (cur != next_group)// 實現翻轉:翻轉三要素：三個指針，保存下一個指針，就可以自由操作了
    {
        Node* next = cur->pNext;
        cur->pNext = prev ? prev : new_next_group;

        prev = cur;
        cur = next;
    }
    return prev;   //prev will be the new head of this group
}


//prev爲 first的前一個元素，[begin ,end] 閉區間，保證三者都不爲NULL
//返回翻轉後的倒數第一個元素
//實現翻轉
Node* reverse(Node* prev, Node* begin, Node* end)
{
    Node* end_next =end->pNext;
    for (Node* p = begin, *cur = p->pNext, *next = cur->pNext;
        cur != end_next;
        p = cur, cur = next, next = next ? next->pNext : NULL
        )
    {
        cur->pNext = p;
    }
    begin->pNext = end_next;
    prev->pNext = end;
    return begin;
}


//迭代法：思路：每K個區間翻轉一次，實現整體翻轉
Node* reversekGroup2(Node* head, int k)
{
    if (head == NULL || head->pNext == NULL || k < 2)
    {
        return head;
    }
    Node dummy(-1);   //因爲頭結點會發生改變，所以虛擬頭結點可以有效的解決該問題
    dummy.pNext = head;

    for (Node* prev = &dummy, *end = head; end; end = prev->pNext)
    {
        //每K個劃分爲一組
        for (int i = 0; i < k&&end; i++)
        {
            end = end->pNext;
        }
        if (end == NULL)
        {
            break;   //不足K個
        }

        prev = reverse(prev,prev->pNext,end);
    }

    return dummy.pNext;
}

void Test1()
{
    Node* node1 = new Node(1);
    Node* node2 = new Node(2); 
    Node* node3 = new Node(3);
    Node* node4 = new Node(4);
    Node* node5 = new Node(5);
    Node* node6 = new Node(6);
    Node* node7 = new Node(7);
    Node* node8 = new Node(8);
    Node* node9 = new Node(9);
    Node* node10 = new Node(10);

    node1->pNext = node2;
    node2->pNext = node3;
    node3->pNext = node4;
    node4->pNext = node5;
    node5->pNext = node6;
    node6->pNext = node7;
    node7->pNext = node8;
    node8->pNext = node9;
    node9->pNext = node10;

    //ReverseEveryKth(node1, 2);

    //reverBetween(node1,2,4);
    Print(node1);
    cout << endl;

    /*Node* temp=reversekGroup1(node1, 3);
    Print(temp);
    cout << endl;*/
    Node* temp = reversekGroup2(node1, 3);
    Print(temp);

}

4.鏈表的翻轉（n-m之間）

//將n-m之間的元素進行翻轉
//頭插法實現
Node* reverBetween(Node* head, int m, int n)
{
    Node dummy(-1);

    dummy.pNext = head;

    Node* prev = &dummy;
    for (int i = 0; i < m; i++)
    {
        prev = prev->pNext;
    }

    Node* head2 = prev;
    prev = head2->pNext;

    Node* cur = prev->pNext;
    for (int i = m; i < n; i++)
    {
        //頭插法
        //三步翻轉法(頭結點始終不變，插入到頭的下一個結點)

        prev->pNext = cur->pNext;
        cur->pNext = head2->pNext;
        head2->pNext = cur;  //頭插法
        cur = prev->pNext;
    }

    return dummy.pNext;
}