问一下一个数据结构的简单题目，有关树的题目 ,不清楚一些语句的具体意思。。。。。。谢谢！！！。。。。。。。。。。。。。。。。。。。。。。。。

klmn111aaa 2014-07-07 01:17:11
Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},
1
\
2
/
3
return [1,2,3].
首先将root入栈，循环过程中，读取栈顶元素，pop，然后分别将右子树，左子树分别入栈。循环直至栈空
递归的意思明白，但是感觉很多地方不明白，
比如：
不太清楚下面哪里体现了先右子树，后左子树，怎么感觉是先做后右了？
哪里体现了出栈？
而且这个data和val的区别？
感觉还有很多地方不明白，能麻烦详细解释下这个程序么？。。。谢谢
/**

 * Definition for binary tree

 * struct TreeNode {

 *	 int val;

 *	 TreeNode *left;

 *	 TreeNode *right;

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

 * };

 */

class Solution {

public:

  void Traversal(TreeNode *root,vector<int> &data)

  {

    if(root==NULL)

      return;

    data.push_back(root->val);

    Traversal(root->left,data);

    Traversal(root->right,data);

  }

  vector<int> preorderTraversal(TreeNode *root) {

    vector<int> data;

    Traversal(root,data);

    return data;

  }

};
...全文
330 25 打赏 收藏 转发到动态 举报
写回复
用AI写文章
25 条回复
切换为时间正序
请发表友善的回复…
发表回复
klmn111aaa 2014-07-15
  • 打赏
  • 举报
 回复
引用 13 楼 zhao4zhong1 的回复:
仅供参考
#include <iostream>
#include <stack>
#include <queue>
#include <locale.h>
using namespace std;
typedef struct BiTNode {//二叉树结点
    char data;                      //数据
    struct BiTNode *lchild,*rchild; //左右孩子指针
} BiTNode,*BiTree;
int CreateBiTree(BiTree &T) {//按先序序列创建二叉树
    char data;
    scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
    if (data == '#') {
        T = NULL;
    } else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = data;         //生成根结点
        CreateBiTree(T->lchild);//构造左子树
        CreateBiTree(T->rchild);//构造右子树
    }
    return 0;
}
void Visit(BiTree T) {//输出
    if (T->data != '#') {
        printf("%c ",T->data);
    }
}
void PreOrder(BiTree T) {//先序遍历
    if (T != NULL) {
        Visit(T);               //访问根节点
        PreOrder(T->lchild);    //访问左子结点
        PreOrder(T->rchild);    //访问右子结点
    }
}
void InOrder(BiTree T) {//中序遍历
    if (T != NULL) {
        InOrder(T->lchild);     //访问左子结点
        Visit(T);               //访问根节点
        InOrder(T->rchild);     //访问右子结点
    }
}
void PostOrder(BiTree T) {//后序遍历
    if (T != NULL) {
        PostOrder(T->lchild);   //访问左子结点
        PostOrder(T->rchild);   //访问右子结点
        Visit(T);               //访问根节点
    }
}
void PreOrder2(BiTree T) {//先序遍历(非递归)
//访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            printf("%c ",p->data);  //访问根节点
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}
void InOrder2(BiTree T) {//中序遍历(非递归)
//T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
//先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈，访问根节点
            printf("%c ",p->data);
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}

typedef struct BiTNodePost{
    BiTree biTree;
    char tag;
} BiTNodePost,*BiTreePost;
void PostOrder2(BiTree T) {//后序遍历(非递归)
    stack<BiTreePost> stack;
    BiTree p = T;//p是遍历指针
    BiTreePost BT;
    while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环
        while (p != NULL) {//遍历左子树
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            BT->tag = 'L';//访问过左子树
            stack.push(BT);
            p = p->lchild;
        }
        while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点
            BT = stack.top();
            stack.pop();//退栈
            printf("%c ",BT->biTree->data);
        }
        if (!stack.empty()) {//遍历右子树
            BT = stack.top();
            BT->tag = 'R';//访问过右子树
            p = BT->biTree;
            p = p->rchild;
        }
    }
}

void LevelOrder(BiTree T) {//层次遍历
    if (T == NULL) return;
    BiTree p = T;
    queue<BiTree> queue;//队列
    queue.push(p);//根节点入队
    while (!queue.empty()) {    //队列不空循环
        p = queue.front();      //对头元素出队
        printf("%c ",p->data);  //访问p指向的结点
        queue.pop();            //退出队列
        if (p->lchild != NULL) {//左子树不空，将左子树入队
            queue.push(p->lchild);
        }
        if (p->rchild != NULL) {//右子树不空，将右子树入队
            queue.push(p->rchild);
        }
    }
}
int main() {
    BiTree T;

    setlocale(LC_ALL,"chs");
    CreateBiTree(T);

    printf("先序遍历        ：");PreOrder  (T);printf("\n");
    printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");
                                               printf("\n");
    printf("中序遍历        ：");InOrder   (T);printf("\n");
    printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");
                                               printf("\n");
    printf("后序遍历        ：");PostOrder (T);printf("\n");
    printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");
                                               printf("\n");
    printf("层次遍历        ：");LevelOrder(T);printf("\n");

    return 0;
}
//ABC##DE#G##F###
//先序遍历        ：A B C D E G F
//先序遍历(非递归)：A B C D E G F
//
//中序遍历        ：C B E G D F A
//中序遍历(非递归)：C B E G D F A
//
//后序遍历        ：C G E F D B A
//后序遍历(非递归)：C G E F D B A
//
//层次遍历        ：A B C D E F G
//

///       A
///      /
///     B
///    / \
///   C   D
///      / \
///     E   F
///      \
///       G
“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出
引用 13 楼 zhao4zhong1 的回复:
仅供参考
#include <iostream>
#include <stack>
#include <queue>
#include <locale.h>
using namespace std;
typedef struct BiTNode {//二叉树结点
    char data;                      //数据
    struct BiTNode *lchild,*rchild; //左右孩子指针
} BiTNode,*BiTree;
int CreateBiTree(BiTree &T) {//按先序序列创建二叉树
    char data;
    scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
    if (data == '#') {
        T = NULL;
    } else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = data;         //生成根结点
        CreateBiTree(T->lchild);//构造左子树
        CreateBiTree(T->rchild);//构造右子树
    }
    return 0;
}
void Visit(BiTree T) {//输出
    if (T->data != '#') {
        printf("%c ",T->data);
    }
}
void PreOrder(BiTree T) {//先序遍历
    if (T != NULL) {
        Visit(T);               //访问根节点
        PreOrder(T->lchild);    //访问左子结点
        PreOrder(T->rchild);    //访问右子结点
    }
}
void InOrder(BiTree T) {//中序遍历
    if (T != NULL) {
        InOrder(T->lchild);     //访问左子结点
        Visit(T);               //访问根节点
        InOrder(T->rchild);     //访问右子结点
    }
}
void PostOrder(BiTree T) {//后序遍历
    if (T != NULL) {
        PostOrder(T->lchild);   //访问左子结点
        PostOrder(T->rchild);   //访问右子结点
        Visit(T);               //访问根节点
    }
}
void PreOrder2(BiTree T) {//先序遍历(非递归)
//访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            printf("%c ",p->data);  //访问根节点
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}
void InOrder2(BiTree T) {//中序遍历(非递归)
//T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
//先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈，访问根节点
            printf("%c ",p->data);
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}

typedef struct BiTNodePost{
    BiTree biTree;
    char tag;
} BiTNodePost,*BiTreePost;
void PostOrder2(BiTree T) {//后序遍历(非递归)
    stack<BiTreePost> stack;
    BiTree p = T;//p是遍历指针
    BiTreePost BT;
    while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环
        while (p != NULL) {//遍历左子树
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            BT->tag = 'L';//访问过左子树
            stack.push(BT);
            p = p->lchild;
        }
        while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点
            BT = stack.top();
            stack.pop();//退栈
            printf("%c ",BT->biTree->data);
        }
        if (!stack.empty()) {//遍历右子树
            BT = stack.top();
            BT->tag = 'R';//访问过右子树
            p = BT->biTree;
            p = p->rchild;
        }
    }
}

void LevelOrder(BiTree T) {//层次遍历
    if (T == NULL) return;
    BiTree p = T;
    queue<BiTree> queue;//队列
    queue.push(p);//根节点入队
    while (!queue.empty()) {    //队列不空循环
        p = queue.front();      //对头元素出队
        printf("%c ",p->data);  //访问p指向的结点
        queue.pop();            //退出队列
        if (p->lchild != NULL) {//左子树不空，将左子树入队
            queue.push(p->lchild);
        }
        if (p->rchild != NULL) {//右子树不空，将右子树入队
            queue.push(p->rchild);
        }
    }
}
int main() {
    BiTree T;

    setlocale(LC_ALL,"chs");
    CreateBiTree(T);

    printf("先序遍历        ：");PreOrder  (T);printf("\n");
    printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");
                                               printf("\n");
    printf("中序遍历        ：");InOrder   (T);printf("\n");
    printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");
                                               printf("\n");
    printf("后序遍历        ：");PostOrder (T);printf("\n");
    printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");
                                               printf("\n");
    printf("层次遍历        ：");LevelOrder(T);printf("\n");

    return 0;
}
//ABC##DE#G##F###
//先序遍历        ：A B C D E G F
//先序遍历(非递归)：A B C D E G F
//
//中序遍历        ：C B E G D F A
//中序遍历(非递归)：C B E G D F A
//
//后序遍历        ：C G E F D B A
//后序遍历(非递归)：C G E F D B A
//
//层次遍历        ：A B C D E F G
//

///       A
///      /
///     B
///    / \
///   C   D
///      / \
///     E   F
///      \
///       G
“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出
同样感谢 热心回复~
klmn111aaa 2014-07-15
  • 打赏
  • 举报
 回复
引用 15 楼 fetag 的回复:
[quote=引用 13 楼 zhao4zhong1 的回复:] 仅供参考[code=c]#include <iostream> #include <stack>
我就喜欢抽你脸！偷人家的代码，连个标注都没有，还能再无耻些吗？ http://blog.csdn.net/sjf0115/article/details/8645991[/quote] 谢谢，看到了，很详细~
klmn111aaa 2014-07-15
  • 打赏
  • 举报
 回复
引用 14 楼 program2050 的回复:
推荐一篇不错的文章《浅析递归函数与函数调用栈》 就是二叉树的。 《C/C++ 递归方式实现二叉树》 《C++非递归方式实现二叉树》
谢谢 学习中
赵4老师 2014-07-15
  • 打赏
  • 举报
 回复
引用 20 楼 fetag 的回复:
[quote=引用 19 楼 zhao4zhong1 的回复:] 况且我剽窃以后也没加“本代码zhao4zhong1版权所有，引用请注明”。
偷完人东西，还狡辩说自己没有撒泡尿写上：赵四神棍到此一游。所以这不算偷。 [/quote] 被阁下不耻是我的荣幸！
Zephyr风暴之锤 2014-07-15
  • 打赏
  • 举报
 回复
引用 19 楼 zhao4zhong1 的回复:
况且我剽窃以后也没加“本代码zhao4zhong1版权所有，引用请注明”。
赵老师莫生气。
独孤过儿 2014-07-15
  • 打赏
  • 举报
 回复
引用 19 楼 zhao4zhong1 的回复:
况且我剽窃以后也没加“本代码zhao4zhong1版权所有，引用请注明”。
偷完人东西，还狡辩说自己没有撒泡尿写上：赵四神棍到此一游。所以这不算偷。
赵4老师 2014-07-15
  • 打赏
  • 举报
 回复
况且我剽窃以后也没加“本代码zhao4zhong1版权所有，引用请注明”。
赵4老师 2014-07-15
  • 打赏
  • 举报
 回复
引用 17 楼 fetag 的回复:
[quote=引用 16 楼 zhao4zhong1 的回复:] [quote=引用 15 楼 fetag 的回复:] [quote=引用 13 楼 zhao4zhong1 的回复:] 仅供参考[code=c]#include <iostream> #include <stack>
我就喜欢抽你脸！偷人家的代码，连个标注都没有，还能再无耻些吗？ http://blog.csdn.net/sjf0115/article/details/8645991[/quote] 莫非阁下的代码都是您老亲自一指禅戳出来的？ 五十步笑百步。[/quote] 我至少知道引用别人的要加上标注。不像某些东西，就知道剽窃[/quote] 我还知道剽窃以后修正几处bug。 可惜你的“慧眼”只看出我剽窃，没看出我修正的几处bug。
独孤过儿 2014-07-15
  • 打赏
  • 举报
 回复
引用 16 楼 zhao4zhong1 的回复:
[quote=引用 15 楼 fetag 的回复:] [quote=引用 13 楼 zhao4zhong1 的回复:] 仅供参考[code=c]#include <iostream> #include <stack>
我就喜欢抽你脸！偷人家的代码，连个标注都没有，还能再无耻些吗？ http://blog.csdn.net/sjf0115/article/details/8645991[/quote] 莫非阁下的代码都是您老亲自一指禅戳出来的？ 五十步笑百步。[/quote] 我至少知道引用别人的要加上标注。不像某些东西，就知道剽窃
赵4老师 2014-07-15
  • 打赏
  • 举报
 回复
引用 15 楼 fetag 的回复:
[quote=引用 13 楼 zhao4zhong1 的回复:] 仅供参考[code=c]#include <iostream> #include <stack>
我就喜欢抽你脸！偷人家的代码，连个标注都没有，还能再无耻些吗？ http://blog.csdn.net/sjf0115/article/details/8645991[/quote] 莫非阁下的代码都是您老亲自一指禅戳出来的？ 五十步笑百步。
独孤过儿 2014-07-15
  • 打赏
  • 举报
 回复
引用 13 楼 zhao4zhong1 的回复:
仅供参考[code=c]#include <iostream> #include <stack>
我就喜欢抽你脸！偷人家的代码，连个标注都没有，还能再无耻些吗？ http://blog.csdn.net/sjf0115/article/details/8645991
赵4老师 2014-07-09
  • 打赏
  • 举报
 回复
仅供参考
#include <iostream>
#include <stack>
#include <queue>
#include <locale.h>
using namespace std;
typedef struct BiTNode {//二叉树结点
    char data;                      //数据
    struct BiTNode *lchild,*rchild; //左右孩子指针
} BiTNode,*BiTree;
int CreateBiTree(BiTree &T) {//按先序序列创建二叉树
    char data;
    scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
    if (data == '#') {
        T = NULL;
    } else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = data;         //生成根结点
        CreateBiTree(T->lchild);//构造左子树
        CreateBiTree(T->rchild);//构造右子树
    }
    return 0;
}
void Visit(BiTree T) {//输出
    if (T->data != '#') {
        printf("%c ",T->data);
    }
}
void PreOrder(BiTree T) {//先序遍历
    if (T != NULL) {
        Visit(T);               //访问根节点
        PreOrder(T->lchild);    //访问左子结点
        PreOrder(T->rchild);    //访问右子结点
    }
}
void InOrder(BiTree T) {//中序遍历
    if (T != NULL) {
        InOrder(T->lchild);     //访问左子结点
        Visit(T);               //访问根节点
        InOrder(T->rchild);     //访问右子结点
    }
}
void PostOrder(BiTree T) {//后序遍历
    if (T != NULL) {
        PostOrder(T->lchild);   //访问左子结点
        PostOrder(T->rchild);   //访问右子结点
        Visit(T);               //访问根节点
    }
}
void PreOrder2(BiTree T) {//先序遍历(非递归)
//访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            printf("%c ",p->data);  //访问根节点
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}
void InOrder2(BiTree T) {//中序遍历(非递归)
//T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
//先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while (p || !stack.empty()) {   //栈不空或者p不空时循环
        if (p != NULL) {
            stack.push(p);          //存入栈中
            p = p->lchild;          //遍历左子树
        } else {
            p = stack.top();        //退栈，访问根节点
            printf("%c ",p->data);
            stack.pop();
            p = p->rchild;          //访问右子树
        }
    }
}

typedef struct BiTNodePost{
    BiTree biTree;
    char tag;
} BiTNodePost,*BiTreePost;
void PostOrder2(BiTree T) {//后序遍历(非递归)
    stack<BiTreePost> stack;
    BiTree p = T;//p是遍历指针
    BiTreePost BT;
    while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环
        while (p != NULL) {//遍历左子树
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            BT->tag = 'L';//访问过左子树
            stack.push(BT);
            p = p->lchild;
        }
        while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点
            BT = stack.top();
            stack.pop();//退栈
            printf("%c ",BT->biTree->data);
        }
        if (!stack.empty()) {//遍历右子树
            BT = stack.top();
            BT->tag = 'R';//访问过右子树
            p = BT->biTree;
            p = p->rchild;
        }
    }
}

void LevelOrder(BiTree T) {//层次遍历
    if (T == NULL) return;
    BiTree p = T;
    queue<BiTree> queue;//队列
    queue.push(p);//根节点入队
    while (!queue.empty()) {    //队列不空循环
        p = queue.front();      //对头元素出队
        printf("%c ",p->data);  //访问p指向的结点
        queue.pop();            //退出队列
        if (p->lchild != NULL) {//左子树不空，将左子树入队
            queue.push(p->lchild);
        }
        if (p->rchild != NULL) {//右子树不空，将右子树入队
            queue.push(p->rchild);
        }
    }
}
int main() {
    BiTree T;

    setlocale(LC_ALL,"chs");
    CreateBiTree(T);

    printf("先序遍历        ：");PreOrder  (T);printf("\n");
    printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");
                                               printf("\n");
    printf("中序遍历        ：");InOrder   (T);printf("\n");
    printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");
                                               printf("\n");
    printf("后序遍历        ：");PostOrder (T);printf("\n");
    printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");
                                               printf("\n");
    printf("层次遍历        ：");LevelOrder(T);printf("\n");

    return 0;
}
//ABC##DE#G##F###
//先序遍历        ：A B C D E G F
//先序遍历(非递归)：A B C D E G F
//
//中序遍历        ：C B E G D F A
//中序遍历(非递归)：C B E G D F A
//
//后序遍历        ：C G E F D B A
//后序遍历(非递归)：C G E F D B A
//
//层次遍历        ：A B C D E F G
//

///       A
///      /
///     B
///    / \
///   C   D
///      / \
///     E   F
///      \
///       G
“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出
modyaj 2014-07-09
  • 打赏
  • 举报
 回复
递归调用可以好好研究下！有些简单点的 有些还是比较难以理解！之前的只是个人看法。。。
modyaj 2014-07-08
  • 打赏
  • 举报
 回复
引用 4 楼 klmn111aaa 的回复:
[quote=引用 1 楼 modyaj 的回复:] 1.不是中序遍历么！ 2.递归本身就能体现 3.data是vector<int>类型的 ，至少和val相比 他十个数组！ 不知道是不是这个意思 、、、、、、、、、、、、、、、、、、、、、 你还不如自己一步一步的调试一下，对每一步得到的值和你推理的结果做比较，你会明白很多！！
是前序遍历吧？ 另外 第二个函数和第一个是什么关系？很混乱啊，这个程序是传上网的那种，本地不会调试啊。。。[/quote] 是前序 这里说错了 第二个函数调用第一个函数，第二个函数只是调用而已，整个功能全靠第一个完成（应该说90%） （ps：这两个函数的关系就像平时常见的快排函数的关系！） 栈体现在函数调用上，比如函数A调用函数B，函数B调用函数C，那么函数结束返回的时候先退出C，然后退出B ，最后退出C，这本身就是栈的顺序！此时对你的数据进行操作（data数组），操作最终也体现在栈的顺序上！
klmn111aaa 2014-07-08
  • 打赏
  • 举报
 回复
引用 10 楼 modyaj 的回复:
[quote=引用 4 楼 klmn111aaa 的回复:] [quote=引用 1 楼 modyaj 的回复:] 1.不是中序遍历么！ 2.递归本身就能体现 3.data是vector<int>类型的 ，至少和val相比 他十个数组！ 不知道是不是这个意思 、、、、、、、、、、、、、、、、、、、、、 你还不如自己一步一步的调试一下，对每一步得到的值和你推理的结果做比较，你会明白很多！！
是前序遍历吧？ 另外 第二个函数和第一个是什么关系？很混乱啊，这个程序是传上网的那种，本地不会调试啊。。。[/quote] 是前序 这里说错了 第二个函数调用第一个函数，第二个函数只是调用而已，整个功能全靠第一个完成（应该说90%） （ps：这两个函数的关系就像平时常见的快排函数的关系！） 栈体现在函数调用上，比如函数A调用函数B，函数B调用函数C，那么函数结束返回的时候先退出C，然后退出B ，最后退出C，这本身就是栈的顺序！此时对你的数据进行操作（data数组），操作最终也体现在栈的顺序上！[/quote] 我觉得这个可以不看成栈吧？如果看成栈应该还要考虑出站，就当成把前序遍历压到数组里就行了
klmn111aaa 2014-07-07
  • 打赏
  • 举报
 回复
引用 8 楼 klmn111aaa 的回复:
这个程序只体现了 前序遍历 应该是压成一个数组对吧？
好像明白了 就是这个意思。。。
klmn111aaa 2014-07-07
  • 打赏
  • 举报
 回复
这个程序只体现了 前序遍历 应该是压成一个数组对吧？
csdn19891 2014-07-07
  • 打赏
  • 举报
 回复
请问哪里体现了出栈？只体现了前序遍历啊？
class Solution {  
public:  
vector<int> v;  
    vector<int> preorderTraversal(TreeNode *root) {  
        preorder(root);  
        return v;  
    }  
      
    void preorder(TreeNode *root)  
    {  
        if(root !=NULL)  
        {  
            v.push_back(root->val);  
            preorder(root->left);  
            preorder(root->right);  
        }  
    }  
};
klmn111aaa 2014-07-07
  • 打赏
  • 举报
 回复
好像没有栈吧？请问第二个函数和第一个是什么关系？很混乱啊，能给加个注释么？谢谢
加载更多回复（5）
Mysql 基础练习大全(建表到基本查询)​
查询语法示例：MySQL查询练习可以提供一系列查询语法示例，包括SELECT语句的基本用法、使用WHERE子句进行条件过滤、使用ORDER BY子句进行排序、使用GROUP BY子句进行分组、使用JOIN进行表连接等。每个示例都会提供一个具体的问题或需求，并给出相应的查询语句供学习和练习。 练习题目：MySQL查询练习可以提供一系列练习题目，要求学员根据给定的问题或需求编写相应的查询语句。题目可以涵盖不同的查询场景，如从单个表中检索数据、多表连接查询、嵌套查询、聚合函数的使用等。每个练习题目都可以提供相应的数据库表结构和示例数据，以便学员可以在实际环境中进行查询练习。 答案和解析：MySQL查询练习可以提供每个练习题目的答案和解析。答案可以包括正确的查询语句，以及查询结果的示例。解析可以解释查询语句的思路和步骤，帮助学员理解查询的原理和实现方法。通过提供答案和解析，学员可以对比自己的查询结果，检查和纠正错误，并加深对查询语法和技巧的理解。 进阶练习：MySQL查询练习可以提供一些进阶的练习题目，挑战学员的查询能力。这些练习题目可以涉及更复杂的查询场景，如子查询、窗口函数的使用、跨
考研数据结构复试题目整理
数据结构复试题目自整理 说复试题目过于牵强，只是自己整理的一些知识点而已，为了便于理解和背诵，有些部分定义和说明尽量简明扼要，如有错误请多多指教！（不可转载） 只涉及简答形式，代码未总结（有用点点赞啊啊我升到3级就可以自定义标签了谢谢~） 1.大O什么意思？ 在时间复杂度中，一个算法中所有语句被重复执行的次数记为T（n）,时间复杂度用来分析T（n）的数量级，也就是算法中基本语句被执行的次数，O的含义就是表示基本语句的数量级也就是算法的数量级。 在空间复杂度中，同样用O来表示基本运算所耗费的存储空间。 2.简
数据库面试SQL编写题目精讲
数据库管理员（Database Administrator，简称DBA），是从事管理和维护数据库管理系统(DBMS)的相关工作人员的统称，属于运维工程师的一个分支，主要负责业务数据库从设计、测试到部署交付的全生命周期管理。...
C语言数据结构考试测试题目，题库+答案解析
C语言数据结构考试试题，题库+答案解析。数据结构中评价算法的两个重要指标是（ ）。设n为正整数。试确定下列各程序段中前置以记号@的语句的频度：线性表若采用顺序存储结构时，要求内存中可用存储单元的地址( )。单链表中，增加一个头结点的目的是为了（ ）)向一个栈顶指针为top的链栈中插入一个p所指向的结点时，其操作步骤为（ ）。有两个串p和q，求q在p中首次出现的位置的运算称为（ ）。广义表（a,(b,c),d,e）的表尾为 ___________。由3个结点可以构造出（ ）种不同
云南专升本-数据结构知识总结和常考例题（一）
数据结构 数据结构是一门研究非数值计算程序中操作对象，以及这些对象之间关系 和操作的学科。 文章目录数据结构一、数据结构的基本概念抽象数据类型算法二、线性表顺序表链表三、栈和队列栈(stack)队列(Queue) 一、数据结构的基本概念 数据是对客观事物的符号表示。 数据元素是数据的 基本 单位。 数据项是元素的 最小 单位。 数据对象是性质相同的数据元素的集合，是数据的子集。 数据项<数据元素<数据对象<数据 示例： 抽象数据类型 抽象数类型可以使用一个三
C++ 语言

64,647

社区成员

250,476

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章