剑指offer[11-15]

11.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

class Solution {
public:
void reOrderArray(vector<int> &array)
{
    for (int i = 0; i < array.size();i++)
        {
            for (int j = array.size() - 1; j>i;j--)
            {
                if (array[j] % 2 == 1 && array[j - 1]%2 == 0) //前偶后奇交换
                {
                    swap(array[j], array[j-1]);
                }
            }
        }
    }
};

12.输入一个链表，输出该链表中倒数第k个结点。

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead==NULL||k==0)
            return NULL;
        ListNode*pTail=pListHead,*pHead=pListHead;
        for(int i=1;i<k;++i)
        {
            if(pHead->next!=NULL)
                pHead=pHead->next;
            else
                return NULL;
        }
        while(pHead->next!=NULL)
        {
            pHead=pHead->next;
            pTail=pTail->next;
        }
        return pTail;
    }
};

13.输入一个链表，反转链表后，输出新链表的表头。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* h = NULL;
        for(ListNode* p = pHead; p; ){
            ListNode* tmp = p -> next;
            p -> next = h;
            h = p;
            p = tmp;
        }
        return h;
    }
};

14.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
        {
            if (pHead1 == NULL)
            {
                return pHead2;
            }
            if (pHead2 == NULL)
            {
                return pHead1;
            }
            else if (pHead1->val < pHead2->val)
            {
                pHead1->next= Merge(pHead1->next, pHead2);
                return pHead1;
            }
            else
                pHead2->next= Merge(pHead1, pHead2->next);
            return pHead2;
        }      
};

15.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

class Solution {
public:
   bool subtree(TreeNode*pRoot, TreeNode *pRoot2)
    {
            if (pRoot2 == NULL)
            {
                return true;
            }
            if (pRoot == NULL)
            {
                return false;
            }
           if (pRoot->val!=pRoot2->val)
            {
                return false;
            }
            return subtree(pRoot->left, pRoot2->left) && subtree(pRoot->right, pRoot2->right);

   }
        bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
        {
            bool result = false;
            if (pRoot1 != NULL&&pRoot2 != NULL){
                if (pRoot1->val == pRoot2->val)
                {
                    result = subtree(pRoot1, pRoot2);
                }
                if (!result)
                {
                    result = HasSubtree(pRoot1->left, pRoot2);
                }
                if (!result)
                {
                    result = HasSubtree(pRoot1->right, pRoot2);
                }

            }
            return result;
        }
};