算法基础__第4课（二叉树前中后序非递归遍历、层次遍历、二叉树的序列化与反序列化、二叉树的后继节点、二叉搜索树的后继节点、折纸问题）

最新推荐文章于 2021-12-22 18:59:32 发布
最新推荐文章于 2021-12-22 18:59:32 发布
阅读量262 收藏
点赞数
分类专栏： 算法专题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39804483/article/details/91593436
版权 
1. 二叉树的锯齿形层次遍历
给出一棵二叉树，返回其节点值的锯齿形层次遍历（先从左往右，下一层再从右往左，层与层之间交替进行） 

样例
样例 1:

输入:{1,2,3}
输出:[[1],[3,2]]
解释:
    1
   / \
  2   3
它将被序列化为 {1,2,3}
样例 2:

输入:{3,9,20,#,#,15,7}
输出:[[3],[20,9],[15,7]]
解释:
    3
   / \
  9  20
    /  \
   15   7
它将被序列化为 {3,9,20,#,#,15,7}
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: A list of lists of integer include the zigzag level order traversal of 
its nodes' values.
     */
     deque<TreeNode*> d;//
    vector<vector<int>> zigzagLevelOrder(TreeNode * root) {
        // write your code here
     vector<vector<int>> res;
     if(root == NULL)
        return res;
     d.push_back(root);
     int index = 0;
     while(!d.empty())
    {
        int t = d.size();
        vector<int> vt;
        if(index%2 == 0)
        {
            for (int i = 0; i < t; i++)
            {
                /* code */
                TreeNode * oushu = d.front();
                vt.push_back(oushu->val);
                d.pop_front();
                if(oushu->left)
                d.push_back(oushu->left);
                if(oushu->right)
                d.push_back(oushu->right);
            }
        }
        else
        {
              for (int i = 0; i < t; i++)
            {
                /* code */
                TreeNode * jishu = d.back();
                vt.push_back(jishu->val);
                d.pop_back();
                if(jishu->right)
                d.push_front(jishu->right);
                 if(jishu->left)
                d.push_front(jishu->left);
            }
        }
        index++;
          res.push_back(vt);  
    }
     return res;
    }
};
前序遍历
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    vector<int> res;
    /**
     * @param root: A Tree
     * @return: Preorder in ArrayList which contains node values.
     */
    vector<int> preorderTraversal(TreeNode * root) {
        // write your code here
       //Preorder(root);
      PreorderNoCur(root);
       return res;
    }
    //非递归遍历
    void PreorderNoCur(TreeNode *root)
    {
       if(!root)
        return ;
        std::stack<TreeNode*> s ;
        s.push(root);
        while(!s.empty())
        {
            TreeNode *t = s.top();
            s.pop();
            res.push_back(t->val);
            if(t->right)
            s.push(t->right);
            if(t->left)
            s.push(t->left);
        }
        
    }
    
    
} ;

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
vector<int> res;
    /**
     * @param root: A Tree
     * @return: Inorder in ArrayList which contains node values.
     */
    vector<int> inorderTraversal(TreeNode * root) {
        // write your code here
        InorderNocur(root);
        return res;
    }
        void Inorder(TreeNode *root)
      {
          if(root)
          {
              Inorder(root->left);
              res.push_back(root->val);
              Inorder(root->right);
          }
          
      }
     //非递归遍历
     void InorderNocur(TreeNode *root)
     {
         std::stack<TreeNode*> stk ;
         
         if(root)
         {
             TreeNode *head = root;
            while(!stk.empty() ||head)
            {
                while(head)//一直往左边走
                {
                    stk.push(head);
                    head = head->left;
                }
                if(!stk.empty())
                {
                    head = stk.top();
                    res.push_back(head->val);
                    stk.pop();
                    head = head->right;
                }
            }
         }
     }
};
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    vector<int> res;
    /**
     * @param root: A Tree
     * @return: Postorder in ArrayList which contains node values.
     */
    vector<int> postorderTraversal(TreeNode * root) {
        // write your code here
        //二叉树的遍历 非递归遍历
        if(!root)
         return res;
        std::stack<TreeNode *> stk;
        TreeNode *head =  root, *pLast = NULL;
        while(head)
        {
            stk.push(head);
            head = head->left;
        }//一直朝着左边走
        while(!stk.empty())
        {
            TreeNode *r = stk.top();
            stk.pop();
            if(r->right == NULL || r->right == pLast)//标记是否被访问过
            {
                //因为两次经过同一个节点，需要标记是否被访问
                res.push_back(r->val);
                pLast = r;
            }//记录最近访问的节点
            else
            {
                stk.push(r);
                r = r->right;
                while(r)
                {
                    stk.push(r);
                    r = r->left;
                }
            }
            
        }
       return res; 
    }
};
设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同
样的二叉树被称为“反序列化”。

如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符
串反序列化为原来的树结构。

样例
样例 1：

输入：{3,9,20,#,#,15,7}
输出：{3,9,20,#,#,15,7}
解释：
二叉树 {3,9,20,#,#,15,7}，表示如下的树结构：
	  3
	 / \
	9  20
	  /  \
	 15   7
它将被序列化为 {3,9,20,#,#,15,7}
样例 2：

输入：{1,2,3}
输出：{1,2,3}
解释：
二叉树 {1,2,3}，表示如下的树结构：
   1
  / \
 2   3
它将被序列化为 {1,2,3}
我们的数据是进行 BFS 遍历得到的。当你测试结果 Wrong Answer 时，你可以作为输入调试你的代码。

你可以采用其他的方法进行序列化和反序列化。

注意事项
对二进制树进行反序列化或序列化的方式没有限制，LintCode 将您的 serialize 输出作为 deserialize 的
输入，它不会检查序列化的结果。

 

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * This method will be invoked first, you should design your own algorithm 
     * to serialize a binary tree which denote by a root node to a string which
     * can be easily deserialized by your own "deserialize" method later.
     */
     //按照满二叉树的特征遍历二叉树
    string serialize(TreeNode * root) {
        // write your code here
        preOrderA(root);
        return toString();
    }
    std::vector<string>res;
    //std::stack<TreeNode*> stk;
    void  preOrderA(TreeNode* root)
    {
     if(root == NULL) 
     {
        res.push_back("#");  
        return;
     }
     else
     {
         res.push_back(to_string(root->val));
         preOrderA(root->left);
         preOrderA(root->right);
     }
    }
     TreeNode * preOrderB(vector<string> arr, int &i)
    {
     if(arr[i] == "#") 
     {
          i++;//这个非常重要
        return NULL;
     }
     else
     {
         TreeNode * root =  new TreeNode(stoi(arr[i]));
         i++;//注意这里每次遍历都会导致数组下标的变化
         root->left = preOrderB(arr,  i);
         root->right =  preOrderB(arr, i);
         return root;
     }
    }
    string toString()
    {
        string  str = "";
        for (int i = 0; i < res.size(); i++) {
            /* code */
         str += res[i] +"?";
        }//最后一个位置多一个问号？
        return str;
    }
    /**
     * This method will be invoked second, the argument data is what exactly
     * you serialized at method "serialize", that means the data is not given by
     * system, it's given by your own serialize method. So the format of data is
     * designed by yourself, and deserialize it here as you serialize it in 
     * "serialize" method.
     */
    TreeNode * deserialize(string &data)
    {
        // write your code here
        vector<string> ret = splitString(data);
        int i = 0;
        return preOrderB(ret,i);
    }
    vector<string> splitString(string &data)
    {
        vector<string> ret;
        string :: size_type pos1 = 0, pos2 = 0;
        while(data.find("?",pos1) != string::npos)
        {
            pos2 = data.find("?", pos1);
            ret.push_back((data.substr(pos1, pos2 - pos1)));
            pos1  = pos2 + 1;
        }
        if(pos1 != data.size())
        {
            ret.push_back((data.substr(pos1)));
        }
        return ret;
    }
};
在二叉树中找到一个节点的后继节点
【题目】 现在有一种新的二叉树节点类型如下:
public class Node { public int value; public Node left; public Node right; public Node parent;
public Node(int data) { this.value = data; }
}
该结构比普通二叉树节点结构多了一个指向父节点的parent指针。假 设有一 棵Node类型的节点组成的二叉树，
树中每个节点的parent指针 都正确地指向 自己的父节点，头节点的parent指向null。只给一个在 二叉树中的
某个节点 node，请实现返回node的后继节点的函数。在二 叉树的中序遍历的序列中， node的下一个节点叫作
node的后继节点。
class Solution
{
public:
    TreeNode *res = NULL;
    TreeNode * findSuccessor(TreeNode *p)
    {
        if (p == NULL)
            return res;
        TreeNode *q = p;
        if(q->right)
        {
            q = q->right;
            while (q->left)
            {
                q = q->left;
            }
            res = q;
            return res;
        }
        else
        {
            proccess( p);
        }
        return res;
    }
    void  proccess(TreeNode *p)
    {
        TreeNode *q = p;
        TreeNode *parent = q->parent;
        while (parent!= NULL && parent->left != q)
        {
            q = q->parent;
            parent = q->parent;
        }
        res = parent;
    }
};

二叉搜索树的后继节点
class Solution{
public:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        // write your code here
        if(p == NULL)
            return NULL;
        inorder(root);
        int index = 0;
        int  aim = p->val;
        for (int i = 0; i <res.size(); i++)
        {
            /* code */
            if(aim == res[i]->val)
            {
                index = i+1;
                // cout << index <<endl;
                break;
            }
        }
        if (index == res.size()) {
            return NULL;
        }
        else
            return  res[index];
    }
    std::vector<TreeNode*> res ;
    void inorder(TreeNode *root)
    {
        if(root == NULL)
            return;
        inorder(root->left);
        res.push_back(root);
        inorder(root->right);
        
        
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */


class Solution{
public:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode *res = NULL;
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        // write your code here
        if(p == NULL)
            return NULL;
        find(root, p);
        return res;
        
    }
    void  find(TreeNode *root,TreeNode *p)
    {
        if(p->right)//要在子节点中寻找
        {
            TreeNode  * pp = p->right;
            while(pp->left)
            {
                pp = pp->left;
            }
            res = pp;
            return;
        }
        else
        {//要在父节点中寻找
            proccess(root, p);
        }
    }
    void  proccess(TreeNode * root, TreeNode *p)
    {
        if(root == NULL)
        {
            return ;
        }
        if(root->val > p->val)//遍历左子树
        {
            res = root;//找到离p节点最近的比p的val值大的节点
            proccess(root->left, p);
        }
        else if(root->val < p->val)
        {
            proccess(root->right, p);
        }
        else
        {
            return ;
        }
    }
};
折纸问题

题目

请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后展开。此时折痕是凹下去的，即折
痕突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折2次，压出折痕后展开，此时有三条折痕，从上
到下依次是下折痕,下折痕和上折痕。给定一个输入参数N，代表纸条都从下边向上方连续对折N次，请从上到下打
印所有折痕的方向。例如 :

N = 1时,打印 : 　down
N = 2时,打印 : 　down down up

解析

可以用一张纸条自己折一下，会发现:

第一次折的时候，只有一条折痕，往里凸的，记为1down。
第二次折的时候，发现1down的上方为往里凸，记为2down，而下方为往外凸，记为2up。
第三次折的时候，发现2dowm的上方往里凸，记为3down，2down的下方往外凸，记为3up； 而2up的上方往里凸，
记为3down，2up的下方往外凸，记为3up；
从上面折痕可以发现新的折痕的上面总是为down，下面总是为up，所以我们可以构造出一颗二叉树，具体看下图
所以当前结点左子树总是down(true),右子树为up(false)，所以我们只要按照中序遍历这颗二叉树就解决问题
了。
 class PaperFloding {//相当于中序遍历
 public:
     //打印的所有折痕方向的函数
     void printAllFolds(int N){
         printProcess(1,N,true);// 根节点的是down(第一次折的时候是往下的(往里凸))
     }
     
     void printProcess(int i, int N, bool down) {
         if(i > N){ //终止条件(相当于结点为null)
             return;
         }
         printProcess(i+1, N, true);// 相当于往左子树跑(因为左子树永远是down(下))
         string s =  down? "down " :"up ";
         cout << s;
         printProcess(i+1, N, false); //往右子树跑
     }
     
     
     void mains() {
         int N = 4;
         printAllFolds(N);
     }
 };

 

吴珝君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树系列之二叉树非递归实现遍历、序列号反序列化
qq_42395311的博客
06-07 439
大学里面学习过的树，现在都快忘没了。打算写一个系列关于树的知识结构，并用java代码加以实现，这个系列会包含二叉树、平衡二叉树、B-树、B+树、红黑树。...
二叉树序列化与反序列化 （非递归）
liu625286477的专栏
04-11 868
本文中的二叉树序列化与反序列化均采用层次遍历非递归的方式完成。 空节点用‘#’隔开，节点与节点之间用空格隔开。 节点类： class TreeNode { int val = 0; TreeNode1 left = null; TreeNode1 right = null; public TreeNode1(int val) { th
递归与非递归实现二叉树的序列化与反序列化
VanGotoBilibili的博客
03-21 1759
序列化 思路 如果子节点为空，用null表示。如果不用null表示会无法确定位置！ 序列化的时候和遍历的时候差不多，也是用递归。这里只写一种方法，因为前序，中序，后序只不过是顺序不一样而已，调换一下ans.add的顺序即可。 代码 public static Queue<String> preSerial(Node head){ Queue<String>ans=new LinkedList<>(); pres(head,ans); return ans; } pu
二叉树反序列化 非递归实现
weixin_39255587的博客
05-28 198
生成随机二叉树并彩色打印参考这个链接 前序遍历时间复杂度O(N), 额外空间复杂度O(lgN)的解法 前序遍历的序列化和非序列化 递归实现 # 前序序列化 def serializeTree(head): if not head: return [None] strLeft = serializeTree(head.left) strRight = serializeTree(head.right) return [head.val]+strLeft+strR
剑指Offer之非递归实现二叉树的前，中，后 序以及层次遍历和序列化，反序列化
weibozhouchao的博客
11-12 133
先序思路： 先将头节点放入栈中，弹出打印，然后判断当前节点的右节点是否为空，不为空，放入栈中，然后再将当前节点的左节点放入栈中，因为放入的顺序是先右再左，利用了栈的特殊性，便实现了二叉树的非递归先序遍历 public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list=...
后序遍历二叉树非递归算法的推导及形式化证明
11-27
后序遍历二叉树非递归算法的推导及形式化证明，难得的期刊论文资料，对研究二叉树的非递归性遍历有很大帮助
Python实现的序列化和反序列化二叉树算法示例
09-19
在实际应用中，序列化和反序列化二叉树的算法可以帮助我们在存储和传输二叉树数据时保持其结构不变。例如，当需要将二叉树保存到文件或在网络上传输时，这些方法非常有用。同时，这样的实现也便于测试和调试，因为...
先序遍历二叉树的递归实现与非递归实现深入解析
09-05
在二叉树数据结构中，先序遍历是一种基础且重要的操作，广泛应用于数据结构的算法设计和分析。本文将深入探讨先序遍历的两种实现方式：递归实现和非递归实现。 1、递归实现： 递归方法是通过函数自身调用来完成遍历...
线索二叉树(中序、先序和后序及遍历)
12-21
目录链式存储线索二叉树中序线索二叉树中序线索化实现实现的代码过程中序线索二叉树的遍历遍历代码中序线索二叉树可运行代码先序线索二叉树先序...后序线索化实现后序线索二叉树的遍历遍历代码后序线索二叉树可运行代码...
层序遍历二叉树与二叉树序列化
qq_36150323的博客
02-27 419
链接：https://www.nowcoder.com/courses/1/7/5 来源：牛客网有一棵二叉树，请设计一个算法，按照层次打印这棵二叉树。 给定二叉树的根结点root，请返回打印结果，结果按照每一层一个数组进行储存，所有数组的顺序按照层数从上往下，且每一层的数组内元素按照从左往右排列。保证结点数小于等于500。“` /* struct TreeNode { int va
二叉树的序列化和反序列化C#版本（前序序列，包括递归和非递归实现）
Christina_Rika的博客
06-17 547
二叉树的序列化和反序列化 二叉树是有结点指针将多个结点关联起来的抽象数据结构，是存在于内存中的，不能进行持久化；如果要将一颗二叉树持久化保存在磁盘文件中，需要将其转换成序列并储存在文件中。 这里讨论如何将二叉树生成前序序列字符串，然后读取前序序列，反序列化并生还原二叉树。 所谓的序列化是指遍历一遍二叉树，产生一个字符串序列，但与一般的前序序列不同，这里要用字符‘#’来记录空的结点。 如： 前序...
二叉树的非递归遍历以及序列化和反序列化
qq_45151553的博客
08-23 210
#include <iostream> #include <queue> #include <stack> using namespace std; struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),right(NULL){} }; //二叉树的层次遍历,非递归 void LayerTraverse(Tre
二叉树的按行层序遍历及序列化和反序列化
weixin_30399155的博客
05-03 318
1.二叉树的序列化 序列化：如图，按前序进行序列化可得到字符串1!2!3!4!-1!-1!5!-1!-1!3!-1!-1!，其中!表示一个值的结束，-1表示该节点为空。 反序列化：序列化的逆操作。 附代码 TreeNode* PreMakeTree(TreeNode* root,int value[]) { // ifsizeof(data)/sizeof(int) ...
二叉树的序列化和反序列化-前序遍历 非递归
tfdev的博客
12-22 448
二叉树的序列化和反序列化-前序遍历 非递归版本
序列化二叉树&&二叉搜索树的第k个结点
weixin_41676282的博客
06-12 3890
序列化二叉树 请实现两个函数，分别用来序列化和反序列化二叉树 解题思路 采用层序遍历，遍历二叉树时碰到null指针时，这些null指针被序列化为一个特殊的字符“#”。另外，结点之间的数值用逗号隔开 代码 import java.util.LinkedList; import java.util.Queue; /** * 剑指offer一刷：序列化二叉树 * * @author User ...
[LeetCode297] 二叉树的序列化和反序列化（后序遍历解法）
StormWangxhu的博客
12-01 574
解法 package com.wangxiaohu; import java.util.LinkedList; /** * 题目：297，解法 2 * leetcode297:https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/submissions/ */ public class LeetCode297_1 { /** * 后序遍历序列化 * * @param r
6、从尾到头打印链表
qq_34405786的博客
04-15 182
题目描述 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 思路 思路一：“从未到头”输出 = “后入先出” 栈，建立一个栈，遍历链表压入栈，再弹出 思路二：递归打印下一个结点；递归的实质就是栈 思路三： 调用库函数，1、vertor自带函数，头插insert(res.begin(),val)（好像效率不高);2、尾插push_back(),再用reverse()反转 ...
剑指offer 从尾到头打印链表
qq_36602048的博客
10-04 78
时间限制：1秒空间限制：32768K热度指数：1086187 本题知识点：链表 题目描述 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 题目链接：题目链接 思路1：先把链表的数存入vector，再反转vector。要求熟悉reverse函数（如果不熟悉，自己手写也ok）。 /** * struct ListNode { * int val; *...
《剑指offer》学习笔记_面试题6_从尾到头打印链表
bqw的博客
03-13 229
题目描述 输入一个链表的头结点，从尾到头反过来打印出每个节点的值。 思路 递归。 C++实现 class Solution { public: vector&lt;int&gt; res; vector&lt;int&gt; printListFromTailToHead(ListNode* head) { if(head==NULL)...
算法：c语言输入字符序列，建立二叉树；按先序、中序、后序遍历二叉树（三种递归算法和中序遍历的非递归算法）；
最新发布
04-29
以下是C语言实现输入字符序列，建立二叉树，并按照先序、中序、后序递归遍历二叉树的算法： ```c #include #include typedef struct TreeNode { char data; struct TreeNode *left; struct TreeNode *right; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值