剑指Offer刷题 - 反转链表、合并两个排序链表、树的子结构、二叉树的镜像、顺时针打印矩阵

反转链表

题目描述：
输入一个链表，反转链表后，输出新链表的表头。

示例：

采用头插法插入就行了。
代码：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(!pHead)return nullptr;
        ListNode *head = new ListNode(0);
        while(pHead)
        {
             ListNode *temp= new ListNode(pHead->val);
            temp->next = head->next;
            head->next = temp;
            pHead = pHead->next;
        }
        return head->next;
    }
};

合并两个排序链表

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

示例：

本题属于简单题，可直接看代码逻辑就行了。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        ListNode *pHead = new ListNode(0);
        ListNode *r = pHead;
        while(pHead1 and pHead2)
        {
            int maxVal;
            if(pHead1->val < pHead2->val)
            {
                maxVal = pHead1->val;
                pHead1 = pHead1->next;
            }
            else
            {
                maxVal = pHead2->val;
                pHead2 = pHead2->next;
            }
            ListNode *temp = new ListNode(maxVal);
            r->next = temp;
            r = temp;
        }
        while(pHead1)
        {
            ListNode *temp = new ListNode(pHead1->val);
            r->next = temp;
            r = temp;
            pHead1 = pHead1->next;
        }
        while(pHead2)
        {
            ListNode *temp = new ListNode(pHead2->val);
            r->next = temp;
            r = temp;
            pHead2 = pHead2->next;
        }
        return pHead->next;
    }
};

树的子结构

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

示例：

本题主要通过递归判定当前节点是否相等，如果相等就判断子节点，如果不等就用该节点的子节点去和子树判断。

代码：

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool IsSubTree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(!pRoot2)return true;
        if(!pRoot1)return false;
        if(pRoot1->val != pRoot2->val)
            return IsSubTree(pRoot1->left, pRoot2) or IsSubTree(pRoot1->right, pRoot2);
        return IsSubTree(pRoot1->left, pRoot2->left) and IsSubTree(pRoot1->right, pRoot2->right);
           
    }
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(!pRoot2 or !pRoot1)return false;
        return IsSubTree(pRoot1, pRoot2) or IsSubTree(pRoot1->left, pRoot2) 
            or IsSubTree(pRoot1->right, pRoot2);
    }
};

二叉树的镜像

题目描述：
操作给定的二叉树，将其变换为源二叉树的镜像。

示例：

本题通过递归不断交换左右孩子即可。
代码：

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void swap(TreeNode* &p1, TreeNode* &p2)
    {
        TreeNode* temp = p1;
        p1 = p2;
        p2 = temp;
    }
    void Mirror(TreeNode *pRoot) {
        if(pRoot)
        {
            swap(pRoot->left, pRoot->right);
            Mirror(pRoot->left);
            Mirror(pRoot->right);
        }
    }
};

顺时针打印矩阵

题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

示例:

本题主要是要搞清楚遍历的顺序，然后按照题目要求顺序遍历即可。
分成上下左右四个方向，然后需要注意到了边界换方向即可。
代码如下：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        int up = 0, down = matrix.size() - 1, left = 0, right = matrix[0].size() - 1;
        int pos_x = 0, pos_y = 0;
        int num = matrix.size() * matrix[0].size();
        vector<int>matrix1;
        int count = 0;
        while(up <= down and left <= right)
        {
            matrix1.push_back(matrix[pos_x][pos_y]);
            //左 下 右 上
            if(count %4 == 0)
            {
                if(pos_y == right)
                {
                    ++count;
                    ++up;
                    ++pos_x;
                }
                else
                    ++pos_y;
            }
            else if(count %4 == 1)
            {
                if(pos_x == down)
                {
                    ++count;
                    --right;
                    --pos_y;
                }
                else ++pos_x;
            }
            else if(count %4 == 2)
            {
                if(pos_y == left)
                {
                    ++count;
                    --down;
                    --pos_x;
                }
                else --pos_y;
            }
            else if(count %4 == 3)
            {
                if(pos_x == up)
                {
                    ++count;
                    ++left;
                    ++pos_y;
                }
                else --pos_x;
            }
        }
        return matrix1;
    }
};