Add new file

BinTree/BinTree.cpp

+
+#include<iostream>
+#include<string>
+#include<string.h>
+#include<stack>
+
+using namespace std;
+
+typedef char DataType;
+
+
+class BinTreeNode {
+public:
+    DataType data;
+    BinTreeNode *leftChild;
+    BinTreeNode *rightChild;
+    BinTreeNode() {
+        leftChild = NULL;
+        rightChild = NULL;
+    }
+};
+
+class BinaryTree {
+public:
+    BinTreeNode *root;
+    //int index;
+    BinaryTree() {
+	//index = 0;
+        root = NULL; 
+    }
+    ~BinaryTree()
+    {
+        DeleteTree(); 
+    }
+    bool InSertLeft(BinTreeNode *current, DataType x);
+    bool InSertRight(BinTreeNode *current, DataType x);
+    void PreOrder(BinTreeNode *current);
+    void InOrder(BinTreeNode *current);
+    void PostOrder(BinTreeNode *current);
+    void NRPreOrder(BinTreeNode *p /*= root*/);
+
+    BinTreeNode *Find(BinTreeNode *current, DataType x);
+
+    void Destory(BinTreeNode *current);
+    void DeleteTree() {
+        Destory(root);
+        root = NULL;	
+    }
+    bool IsEmpty() {
+        return root == NULL; 
+    }
+    BinTreeNode *CreateBinTree(char *str);
+    BinTreeNode *CreateBinTree();
+    BinTreeNode *NRCreateBinTree(char *str);
+    BinTreeNode *NRCreateBinTreeStdStack(char *str);
+};
+
+/******************SeqStack class function realization Start***************************/
+template <typename T>
+class MyStack
+{
+public:
+	MyStack(int size);
+	~MyStack();
+	bool stackEmpty();//判空
+	bool stackFull();//判满
+	void clearStack();//清空
+	int stackLength();//长度
+	bool push(T elem);//压栈
+	bool pop(T &elem);//出栈
+	T stackTop();//返回栈顶
+	bool stackTop(T &elem);//返回栈顶
+	void stackTranverse();//遍历栈
+ 
+private:
+	T *m_pStack;//栈指针
+	int m_iSize;//栈容量
+	int m_iTop;//栈顶
+};
+ 
+template <typename T>
+MyStack<T>::MyStack(int size)
+{
+	m_iSize = size;
+	m_pStack = new T[m_iSize];
+	m_iTop = 0;
+}
+template <typename T>
+MyStack<T>::~MyStack()
+{
+	delete m_pStack;
+	m_pStack = NULL;
+}
+template <typename T>
+bool MyStack<T>::stackEmpty() {//判空
+	return m_iTop == 0 ? true : false;
+}
+template <typename T>
+bool MyStack<T>::stackFull() {//判满
+	return m_iTop == m_iSize ? true : false;
+}
+template <typename T>
+int MyStack<T>::stackLength() {//栈长度
+	return m_iTop;
+}
+template <typename T>
+void MyStack<T>::clearStack() {//清空
+	m_iTop = 0;
+}
+template <typename T>
+bool MyStack<T>::push(T elem) {//压栈
+	if (stackFull()) {
+		return false;
+	}
+	else {
+		m_pStack[m_iTop++] = elem;
+		return true;
+	}
+}
+template <typename T>
+bool MyStack<T>::pop(T &elem) {//出栈
+	if (stackEmpty())
+	{
+		return false;
+	}
+	else {
+		elem = m_pStack[--m_iTop];
+		return true;
+	}
+}
+template <typename T>
+bool MyStack<T>::stackTop(T &elem) {//返回栈顶元素
+	if (stackEmpty())
+	{
+		return false;
+	}
+	else {
+		elem = m_pStack[m_iTop-1];
+		return true;
+	}
+}
+
+template <typename T>
+T MyStack<T>::stackTop() {//返回栈顶元素
+	if (stackEmpty())
+	{
+	    return NULL;              //如果这里返回NULL，如果使用方法不对，容易造成段错误.
+	    //return m_pStack[m_iTop];
+	}
+	else {
+	    return m_pStack[m_iTop-1];
+	}
+}
+
+template <typename T>
+void MyStack<T>::stackTranverse() {//遍历栈
+	int i = 0;
+	for (i = 0; i < m_iTop; i++) {
+		cout << m_pStack[i];
+	}
+}
+/******************SeqStack class function realization End***************************/
+
+/******************BinaryTree class function realization Start***************************/
+bool BinaryTree::InSertLeft(BinTreeNode *current, DataType item) {
+    if(current == NULL) {
+        return false; 
+    }
+    BinTreeNode *p = new BinTreeNode;
+    p->data = item;
+    current->leftChild = p;
+    return true;
+}
+
+bool BinaryTree::InSertRight(BinTreeNode *current, DataType item) {
+    if(current == NULL) {
+        return false; 
+    }
+    BinTreeNode *p = new BinTreeNode;
+    p->data = item;
+    current->rightChild = p;
+    return true;
+}
+
+void BinaryTree::Destory(BinTreeNode *current) {
+    if(current != NULL) {
+        Destory(current->leftChild);
+        Destory(current->rightChild);
+	delete current;
+    }
+}
+
+BinTreeNode *BinaryTree::Find(BinTreeNode *current, DataType x) {
+    if(current == NULL) {
+        return NULL; 
+    }
+    if(current->data == x) {
+        return current; 
+    }
+    BinTreeNode *p = Find(current->leftChild, x);
+    if(p!=NULL) {
+        return p;
+    } else {
+        return Find(current->rightChild, x);
+    }
+}
+
+void BinaryTree::PreOrder(BinTreeNode *current) {
+    if(current != NULL) {
+        cout << current->data << " ";
+        PreOrder(current->leftChild);	
+	PreOrder(current->rightChild);
+    }
+}
+
+BinTreeNode *BinaryTree::CreateBinTree(char *str) {
+    BinTreeNode *Tree = NULL;
+    static int index = 0;
+    char value = str[index]; //可以将index放入到类的成员变量里面,创建之前记得将index = 0;这样后续再创建就不会出错.
+
+    if(str[index++] == '#') {
+        return NULL;
+    }
+
+    Tree = new BinTreeNode;
+    Tree->data = value;
+
+    Tree->leftChild = CreateBinTree(str);
+    Tree->rightChild = CreateBinTree(str);
+
+    if(str[index] == '\0') {
+        index = 0;
+    }
+
+    return Tree;
+}
+
+BinTreeNode *BinaryTree::CreateBinTree() {
+    BinTreeNode *Tree = NULL;
+    char str;
+    cin >> str;
+    if(str != '#') {
+	Tree = new BinTreeNode;
+        Tree->data = str;
+        Tree->leftChild = CreateBinTree();
+        Tree->rightChild = CreateBinTree();
+    }
+    return Tree;
+}
+
+/**************树的结构体:算法思想*********************/
+/*
+ * 首先,我们对二叉树进行扩展,然后按先序遍历的顺序输入节点的信息,然后我们设置一个标志位flag,如果flag=0,创建当前节点的左孩子节点,当flag=1时，创建当前节点的右孩子节点.具体的分为以下四种情况:
+ *
+ * 1.当前要创建的节点值为'#'，并且flag=1,说明当前节点的父节点的左右孩子已经创建完毕,应将栈顶元素出栈，如果出栈的元素与栈顶的元素的右孩子相同,说明当前节点的父节点的左右孩子也创建完毕.栈顶元素继续出栈，直到栈顶的元素的右孩子和出栈的元素不相同.
+ *
+ * 2.当前要创建的节点值'#',并且flag=0,说明当前节点的父节点的左孩子已经创建完毕,转向创建右孩子,把flag置为1；
+ *
+ * 3.当前要创建的节点值不等于'#'，并且flag=0,创建当前节点　并作为栈顶元素的左孩子,同时把当前节点入栈.(保存节点，创建右孩子).
+ *
+ * 4.当前要创建的节点值不等于'#'，并且flag=1,创建当前节点并作为栈顶元素的右孩子.同时把当前节点入栈.
+ *
+ * 1) char Tsrc[]={"ABC##D##E#F#G##"};         	      
+ *
+ *                A
+ *               / \
+ *              /   \
+ *             B     E
+ *            / \    /
+ *           C   D  F
+ *         	     \
+ *         	      G
+ *         	      
+ * 2) char Tsrc[]={"ABDG##H###CE#I##F##"};         	      
+ *
+ *                        A
+ *                       / \
+ *                      /   \
+ *                     /     \
+ *                    /       \
+ *                   /         \
+ *                  B           C 
+ *                 / \         / \
+ *                /   \       /   \
+ *               /     \     /     \
+ *              D       #   E       F
+ *             / \ 	   / \     / \
+ *            /   \ 	  /   \   /   \
+ *           G     H     #     I #     #
+ *          / \   / \         / \
+ *         #   # #   #       #   #
+ *
+ *
+ */
+
+BinTreeNode *BinaryTree::NRCreateBinTreeStdStack(char *str) {
+    int flag=0;
+    char *p = str;
+
+    stack<BinTreeNode*>s;
+    BinTreeNode *pRoot = NULL;
+    BinTreeNode *curNode = NULL;
+    BinTreeNode *newNode = NULL;
+
+    newNode = new BinTreeNode;
+    if(newNode == NULL)
+    {
+        return NULL;
+    }
+    newNode->data = *p++;
+
+    pRoot = newNode;
+    s.push(pRoot);
+
+    //while (!s.empty()) {
+    while (*p != '\0') {
+	if(*p == '#' && flag == 0) {
+                //3. 当前要创建的节点值'#',并且flag=0,说明当前节点的父节点的左孩子已经创建完毕,转向创建右孩子,把flag置为1；
+	    flag = 1;
+	} else if (*p == '#' && flag == 1) {
+                //4. 当前要创建的节点值为'#'，并且flag=1,说明当前节点的父节点的左右孩子已经创建完毕,应将栈顶元素出栈，
+            curNode = s.top();
+	    s.pop();
+		//5. 如果出栈的元素与栈顶的元素的右孩子相同,说明当前节点的父节点的左右孩子也创建完毕.栈顶元素继续出栈，直到栈顶的元素的右孩子和出栈的元素不相同.
+            //while(s.top() !=NULL && s.top()->rightChild == curNode) //如果堆栈为空时返回NULL,s.top()这里就会发生段错误
+            while(!s.empty() && s.top()->rightChild == curNode) //如果堆栈为空时返回NULL,这里就会发生段错误
+            {
+                curNode = s.top();
+	        s.pop();
+            }
+	} else {
+            newNode = new BinTreeNode;
+            if(newNode == NULL)
+            {
+                return NULL;
+            }
+	    newNode->data = *p;
+	    if(flag == 0)
+	    {
+		//1. 如果flag=0,创建当前节点的左孩子节点,同时把当前节点入栈.
+	        s.top()->leftChild = newNode;
+		s.push(newNode);
+	    } else {
+		//2. 当flag=1时，创建当前节点的右孩子节点,同时把当前节点入栈.
+	        s.top()->rightChild = newNode;
+		flag = 0;
+		s.push(newNode);
+	    }
+	}
+        p++;
+    }
+    return pRoot;
+}
+BinTreeNode *BinaryTree::NRCreateBinTree(char *str) {
+#if 1
+    BinTreeNode *root = NULL;
+    BinTreeNode *newnode = NULL;
+    BinTreeNode *tmpnode = NULL;
+    MyStack<BinTreeNode*> *pStack = new MyStack<BinTreeNode*>(100);
+
+    int flag=0;
+    char *p = str;
+
+    newnode = new BinTreeNode;
+    if(newnode == NULL)
+    {
+        return NULL;
+    }
+    newnode->data = *p;
+    p++;
+    root = newnode;
+    pStack->push(newnode);
+
+    //while(p!= '\0' && !pStack->stackEmpty()) {
+    while(*p != '\0') {
+	if(*p == '#' && flag == 0) {
+                //3. 当前要创建的节点值'#',并且flag=0,说明当前节点的父节点的左孩子已经创建完毕,转向创建右孩子,把flag置为1；
+	    flag = 1;
+	} else if (*p == '#' && flag == 1) {
+                //4. 当前要创建的节点值为'#'，并且flag=1,说明当前节点的父节点的左右孩子已经创建完毕,应将栈顶元素出栈，
+            pStack->pop(tmpnode);
+		//5. 如果出栈的元素与栈顶的元素的右孩子相同,说明当前节点的父节点的左右孩子也创建完毕.栈顶元素继续出栈，直到栈顶的元素的右孩子和出栈的元素不相同.
+            while(!pStack->stackEmpty() && pStack->stackTop()->rightChild == tmpnode) //如果堆栈为空时返回NULL,这里就会发生段错误
+            {
+                pStack->pop(tmpnode);
+            }
+	} else {
+            newnode = new BinTreeNode;
+            if(newnode == NULL)
+            {
+                return NULL;
+            }
+	    newnode->data = *p;
+	    if(flag == 0)
+	    {
+		//1. 如果flag=0,创建当前节点的左孩子节点,同时把当前节点入栈.
+	        pStack->stackTop()->leftChild = newnode;
+		pStack->push(newnode);
+	    } else {
+		//2. 当flag=1时，创建当前节点的右孩子节点,同时把当前节点入栈.
+	        pStack->stackTop()->rightChild = newnode;
+		flag = 0;
+		pStack->push(newnode);
+	    }
+	}
+        p++;
+    }
+    return root;
+#elif 0
+    BinTreeNode *stack[100],*root,*newnode,*t; //stack[N]定义堆栈；
+    int flag=0,top=0;
+    char *p = str;
+
+    //newnode=(BinTreeNode*)malloc(sizeof(BinTreeNode*));
+    newnode = new BinTreeNode;
+    if(newnode == NULL)
+    {
+        return NULL;
+    }
+    newnode->data=*p;
+    p++;
+    newnode->leftChild = NULL;
+    newnode->rightChild = NULL;
+    stack[top++] = newnode;
+    //根节点先入栈
+    root = newnode;
+    while(*p!='\0')
+    {
+        if(*p == '#' && flag == 0)      
+        {
+            flag=1;
+        }
+        else if(*p == '#' && flag == 1)
+        {
+            t=stack[--top];
+            while(stack[top-1]->rightChild == t)
+            {
+                t=stack[--top];
+            }
+        }
+        else
+        {
+            //newnode=(BinTreeNode*)malloc(sizeof(BinTreeNode*));
+            newnode = new BinTreeNode;
+            if(newnode == NULL)
+            {
+                return NULL;
+            }
+            newnode->data = *p;
+            if(flag == 0)
+            {
+                stack[top-1]->leftChild = newnode;
+                stack[top++] = newnode;
+            }
+            else
+            {
+                stack[top-1]->rightChild = newnode;
+                flag=0;
+                stack[top++] = newnode;
+            }
+
+        }
+        p++;
+    }
+    return root;
+#else
+    BinTreeNode *stack[100],*root,*newnode,*t,*m; //stack[N]定义堆栈；
+    MyStack<BinTreeNode*> *pStack = new MyStack<BinTreeNode*>(100);
+
+    int flag=0,top=0;
+    char *p = str;
+
+    //newnode=(BinTreeNode*)malloc(sizeof(BinTreeNode*));
+    newnode = new BinTreeNode;
+    if(newnode == NULL)
+    {
+        return NULL;
+    }
+    newnode->data=*p;
+    p++;
+    newnode->leftChild = NULL;
+    newnode->rightChild = NULL;
+    //stack[top++] = newnode;
+    pStack->push(newnode);
+    //根节点先入栈
+    root = newnode;
+    while(*p!='\0')
+    {
+        if(*p == '#' && flag == 0)      
+        {
+            flag=1;
+        }
+        else if(*p == '#' && flag == 1)
+        {
+            //t=stack[--top];
+	    pStack->pop(t);
+	    pStack->stackTop(m);
+            //while(stack[top-1]->rightChild == t)
+            while(m->rightChild == t)
+            {
+                //t=stack[--top];
+	        pStack->pop(t);
+	        pStack->stackTop(m);
+            }
+        }
+        else
+        {
+            //newnode=(BinTreeNode*)malloc(sizeof(BinTreeNode*));
+            newnode = new BinTreeNode;
+            if(newnode == NULL)
+            {
+                return NULL;
+            }
+            newnode->data = *p;
+            if(flag == 0)
+            {
+               // stack[top-1]->leftChild = newnode;
+	       pStack->stackTop(m);
+	       m->leftChild = newnode;
+               //stack[top++] = newnode;
+	       pStack->push(newnode);
+            }
+            else
+            {
+                //stack[top-1]->rightChild = newnode;
+	        pStack->stackTop(m);
+		m->rightChild = newnode;
+                flag=0;
+                //stack[top++] = newnode;
+	        pStack->push(newnode);
+            }
+
+        }
+        p++;
+    }
+    delete pStack;
+    pStack = NULL;
+    return root;
+#endif
+}
+
+void BinaryTree::NRPreOrder(BinTreeNode *p /*= root*/) {
+    MyStack<BinTreeNode*> *pStack = new MyStack<BinTreeNode*>(100);
+    while(p || !pStack->stackEmpty()) {
+        if(p) {
+	    cout << p->data << " ";
+	    pStack->push(p);          //预留p指针在栈中
+	    p = p->leftChild;
+	} else {
+	    pStack->pop(p);
+	    p = p->rightChild;         //左子树为空，进右子树
+	}
+    }
+}
+/******************BinaryTree class function realization end***************************/
+
+/******************NRecurTree class function realization begin***************************/
+/******************NRecurTree class function realization end***************************/
+#define N 200
+int main()
+{	
+#if 1
+    char str[1000] = { 0 };
+    cin.getline(str, 1000);
+    cout << str << endl;
+#else
+    char str[N] = {"ABDG##H###CE#I##F##"};
+#endif
+    char *p;
+    p = str;
+
+    BinaryTree Tree;
+    //Tree.root = Tree.CreateBinTree();
+    Tree.root = Tree.CreateBinTree(p);
+    Tree.root = Tree.CreateBinTree(p);
+    Tree.root = Tree.CreateBinTree(p);
+    //Tree.root = Tree.NRCreateBinTree(p);
+    //Tree.root = Tree.NRCreateBinTree(str);
+    //Tree.root = Tree.NRCreateBinTreeStdStack(str);
+    Tree.PreOrder(Tree.root);
+    cout << endl;
+    Tree.NRPreOrder(Tree.root);
+    cout << endl;
+
+    return EXIT_SUCCESS;
+}