剑指Offer66题之每日6题 - 第十天

第一题：链表中环的入口结点

题目：

一个链表中包含环，请找出该链表的环的入口结点。

解析：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        ListNode *p_l = pHead, *p_f = pHead;
        if (!(p_l != nullptr && p_f != nullptr && p_f->next != nullptr))
            return nullptr;
        do {
            p_l = p_l->next;
            p_f = p_f->next->next;
        } while (p_l != nullptr && p_f != nullptr &&
            p_f->next != nullptr && p_l != p_f);
        if (!(p_l != nullptr && p_f != nullptr && p_f->next != nullptr))
            return nullptr;
        for (p_l = pHead; p_l != p_f; p_l = p_l->next, p_f = p_f->next) {}
        return p_l;
    }
};

第二题：删除链表中重复的结点

题目：

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为1->2->5

解析：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/

class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if (pHead == nullptr)
            return nullptr;
        ListNode *p;
        for (p = pHead->next; p != nullptr && p->val == pHead->val; p = p->next);
        return pHead->next == p ? (pHead->next = deleteDuplication(p), pHead) : deleteDuplication(p);
    }
};

第三题：二叉树的下一个结点

题目：

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

解析：

/*
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {

    }
};
*/
class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if (pNode == nullptr)
            return nullptr;
        if (pNode->right != nullptr) {
            for (pNode = pNode->right; pNode->left != nullptr; pNode = pNode->left);
            return pNode;
        }
        for (; pNode->next != nullptr && pNode->next->right == pNode; pNode = pNode->next);
        return pNode->next == nullptr ? nullptr : pNode->next;
    }
};

第四题：对称的二叉树

题目：

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

解析：

递归做法，判断两颗树是否相等，首先判断根结点是否一样，然后再依次递归判断两颗树的左子树是否相等，两棵树的右子树是否相等。这里要判断二叉树是否对称，注意题中加粗的话，那么只需要判断第一颗树的左子树和第二颗树的右子树是否相等，第一颗树的右子树和第二颗树的左子树是否相等。

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

class Solution {
public:
	bool isSymmetrical(TreeNode* pRoot)
	{
		if (pRoot == nullptr || (pRoot->left == nullptr && pRoot->right == nullptr)) return true;
		return isSY(pRoot->left, pRoot->right);
	}

	bool isSY(TreeNode* lt, TreeNode* rt) {
		if (lt == nullptr && rt == nullptr) return true;
		if ((lt != nullptr && rt == nullptr) || (lt == nullptr && rt != nullptr)) return false;
		if (lt->val != rt->val) return false;
		return isSY(lt->left, rt->right) && isSY(lt->right, rt->left);
	}
};

第五题：按之字形顺序打印二叉树

题目：

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

解析：

基于第六题的解法，对需要反转的层进行反转

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
	vector<vector<int> > Print(TreeNode* pRoot) {
		vector<vector<int> > res;
		vector<int> now;
		if (pRoot == nullptr)
			return res;
		queue<TreeNode*> seq;
		queue<TreeNode*> tmp;
		seq.push(pRoot);
		tmp.push(pRoot);
		while (!seq.empty())
		{
			auto cur = seq.front();
			seq.pop();
			if (cur == nullptr) continue;
			seq.push(cur->left);
			seq.push(cur->right);
			now.push_back(cur->val);
			if (cur == tmp.front()) {
				tmp.pop();
				cur->right != nullptr ? tmp.push(cur->right) : tmp.push(cur->left);
				res.push_back(now);
				now.clear();
			}
		}
        for (int i = 1; i < res.size(); i = i+2) {
			vector<int> arr = res[i];
			int j = 0;
			int t = arr.size() - 1;
			while (j < t)
			{
				swap(res[i][j],res[i][t]);
				j++;
				t--;
			}
		}
		return res;
	}
};

第六题：把二叉树打印成多行

题目：

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

解析：

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};
class Solution {
public:
	vector<vector<int> > Print(TreeNode* pRoot) {
		vector<vector<int> > res;
		vector<int> now;
		if (pRoot == nullptr)
            return res;
		queue<TreeNode*> seq;
		queue<TreeNode*> tmp;
		seq.push(pRoot);
		tmp.push(pRoot);
		while (!seq.empty())
		{
			auto cur = seq.front();
			seq.pop();
			if (cur == nullptr) continue;
			seq.push(cur->left);
			seq.push(cur->right);
			now.push_back(cur->val);
			if (cur == tmp.front()) {
				tmp.pop();
				cur->right != nullptr ? tmp.push(cur->right) : tmp.push(cur->left);
				res.push_back(now);
				now.clear();
			}
		}
		return res;
	}
};

学习：1、记得先判断传入的节点是否为空，若为空，直接返回