剑指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;
        }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值