基于栈的深度优先搜索

基于手写的栈和STL栈的深度优先

//基于系统栈的二叉树的中序遍历
#include <iostream>
#include <stack>
using namespace std;
struct Node
{
    int data;
    Node* left;
    Node* right;
    Node(int val):data(val),left(NULL),right(NULL){};
};

struct Tree
{
    Node* tnode;
    Tree(Node* t):tnode(t){};
    void Add(int val,Node* t){
        if(t == NULL){
            t = new Node(val);
        }
        else{
            if(t->data > val){
                if(t->left == NULL){
                    Node* tmp = new Node(val);
                    t->left = tmp;
                }
                else{
                    Add(val,t->left);
                }
            }
            else{
                if(t->right == NULL){
                    Node* tmp = new Node(val);
                    t->right = tmp;             //千万注意别写错了
                }
                else{
                    Add(val,t->right);
                }
            }
        }
    };

};
void StackTravel(Node* t){
    stack<Node*>  s;
    Node* cur = t;
    while(cur){
        cout<<cur->data<<endl;
        if(cur->right){
            s.push(cur->right);
        }
        if(cur->left){
            cur = cur->left;
        }
        else{
            if(s.empty()){
                cur = NULL;
            }
            else{
                cur = s.top();
                s.pop();
            }
        }
    }
}
void Print(Node* t){
    if(t){
        cout<<t->data<<endl;
        Print(t->left);
        Print(t->right);
    }
}
int main(int argc, char const *argv[])
{
    int arr[10] = {5,6,0,9,3,8,1,2,7,4};
    Tree* tree = NULL;
    Node* root = NULL;
    for(int i = 0;i < 10;i++){
        if(i == 0){
            root = new Node(arr[i]);
            tree = new Tree(root);              //前面是申明，这里用之前必须开辟空间了
            tree->tnode = root;
        }
        else{                       //两条路，必须加else
        tree->Add(arr[i],root);
        }
    }
    Print(root);
    StackTravel(root);
    return 0;
}

//手写的栈的二叉树的遍历
#include <iostream>
using namespace std;
struct TreeNode
{
    int data;
    int position;
    TreeNode* left;
    TreeNode* right;
    TreeNode(){};
    TreeNode(int value,int pos):data(value),position(pos), left(NULL),right(NULL){};
};
class BinarySearchTree
{
private:
    TreeNode* tnode ;
public:
    BinarySearchTree(TreeNode* t):tnode(t){};
    ~BinarySearchTree(){delete tnode;tnode = NULL;};
    void Add(int value,int position,TreeNode* t);
    void Print(TreeNode* tnode);    //中序

};
void BinarySearchTree::Add(int value,int position,TreeNode* t){
    if(t== NULL) {
        TreeNode* root = new TreeNode(value,position);
        t = root;
    }
    else{

        if(value < t->data){
            if(t->left == NULL){
                TreeNode* tmp = new TreeNode(value,position);
                t->left = tmp;
            }
            else{
                Add(value,position,t->left);
            }

        }
        else{
            if(t->right == NULL){
                TreeNode* tmp = new TreeNode(value,position);
                t->right = tmp;
            }
            else{
                Add(value,position,t->right);
            }

        }
    }
}
void BinarySearchTree::Print(TreeNode* tnode){
    if(tnode){  //if不是while
        Print(tnode->left);
        cout<<tnode->data<<endl;
        Print(tnode->right);

    }
}

int Search(TreeNode* t,int target){
    if( t == NULL){
        return -1;
    }
    else if(t->data == target){
        return t->position;
    }
    else if( t->data > target){
        return Search(t->left,target);
    }
    else{
        return Search(t->right,target);
    }
}

//Stack定义
template <class T>
class Node      //class默认是private，struct默认是public
{
public:
    T data;
    Node<T>* next;
    Node(T val):data(val),next(NULL){};
    ~Node(){delete next;next=NULL;};

};
template<class T>
class Stack
{
    Node<T>* top;
public:
    Stack():top(NULL){};
    void Pop();
    void Push(T val);
    bool IsEmpty();
    T TopVal();
    ~Stack(){delete top;top = NULL;};

};
template<class T>
void Stack<T>::Push(T val){
    Node<T>* tmp = new Node<T>(val);
    tmp->next = top;
    top = tmp;
}
template <class T>
void Stack<T>::Pop(){
    if(top == NULL){
        cout<<"Stack is empty!"<<endl;
        return ;
    }
    else{
        Node<T>* tmp = top;
        top = top->next;
        delete tmp;
        tmp = NULL;
    }
}
template <class T>
bool Stack<T>::IsEmpty(){
    return top == NULL;
}
template <class T>
T Stack<T>::TopVal(){
    return top->data;
}

void PreOrderStack(TreeNode* t){
    Stack<TreeNode*>* s =new Stack<TreeNode*>() ;
    TreeNode* cur = t;
    while(cur){
        cout<<cur->data<<endl;
        if(cur->right){
            s->Push(cur->right);
        }
        if(cur->left){
            cur = cur->left;
        }
        else{
            if(s->IsEmpty()){
                cur = NULL;
            }
            else{
                cur = s->TopVal();
                s->Pop();
            }
        }
    }
}
int main(int argc, char const *argv[])
{
    int arr[5] = {3,6,4,2,0};
    TreeNode* root = NULL;
    BinarySearchTree* bst  = NULL;
    for(int i = 0;i < 5;i++){
        if(i == 0){
            root = new TreeNode(arr[0],i);
        }
        else{
            bst->Add(arr[i],i,root);
        }
    }
    //bst->Print(root);
    //cout<<Search(root,0)<<endl;
    PreOrderStack(root);
    return 0;
}

原文地址：https://www.cnblogs.com/ziyuemeng/p/12424013.html