day11之求二叉樹的高度+銷燬一顆二叉樹+鏈表每K個節點之間逆序

• 求二叉樹的高度

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
        val(x), left(NULL), right(NULL) {
        }
};


int  High(TreeNode *root)
{
    if(root == NULL)
        return 0 ;
    if(root->left == NULL && root->right == NULL)
        return 1;

    int size1 = High(root->left); //左子樹的高度
    int size2 = High(root->right); //右子樹的高度.

    return (size1>size2 ? size1+1:size2+1);
}

• 銷燬一顆二叉樹–>Destroy(Node* root)

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
        val(x), left(NULL), right(NULL) {
        }
};


void Destroy(TreeNode *root)
{
    if(root == NULL)
        return ;

    if(root->left == NULL && root->right == NULL)
    {
        delete root;
        root = NULL;
        return ;
    }

    if(root->left)
        Destroy(root->left);
    if(root->right)
        Destroy(root->right);
    delete root;
    root = NULL;
}

• 鏈表每k個節點之間逆置
  鏈表翻轉。給出一個鏈表和一個數k，比如鏈表1→2→3→4→5→6，k=2，翻轉後2→1→4→3→6→5，若k=3,翻轉後3→2→1→6→5→4，若k=4，翻轉後4→3→2→1→5→6，

struct Node
{
    int value;
    struct Node * Next;

    Node(int data):value(data),Next(NULL) {    }
};

Node * Resign(stack<Node*> &s, Node * left, Node *right)//返回的是下次調整的前驅。
{
    Node *pCur = s.top();
    s.pop();

    if (left != NULL)
    {
        left->Next = pCur;   //(1)
    }

    while (!s.empty())
    {
        Node *pNext = s.top();
        s.pop();
        pCur->Next = pNext;
        pCur = pNext;     //循環結束後pCur指向逆置後的尾部。
    }
    pCur->Next = right;  //(2)  這兩步是連上原來的鏈表。
    return pCur;
}


Node* ReverseKNode1(Node * pHead, int k)
{
    if (pHead == NULL || k < 2)  //當k == 1就相當於不逆置了，k < 0無意義。
    {
        return NULL;
    }
    Node *pCur = pHead;
    Node * pPre = NULL;
    Node * pNext = NULL;
    Node * newNode = pHead;
    stack<Node*> s;
    int num = 0;

    while (pCur)
    {
        pNext = pCur->Next;
        s.push(pCur);
        num++;

        if (num == k)
        {
            //將k個節點逆置，並且返回逆置後的尾節點，這個節點就是下次逆置的前驅。
            pPre = Resign(s,pPre,pNext);

            //重置頭節點。
            newNode = newNode == pHead ? pCur : newNode;  //第一次逆置要修改頭的指向，其他逆置不需要。
            num = 0;
        }

        pCur = pNext;
    }

    return newNode;
}