c++多态实现树

本篇文章为笔者的读书笔记，未经允许请勿转载。如果对你有帮助记得点个赞(●’◡’●)
本文主要利用c++的多态特性来实现树，遍历利用了两种方式，一种是递归，另一种是非递归（栈的实现）；
后面会讲到非递归方式的图形式呈现；

源码如下：

stdafx.h

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>



// TODO:  在此处引用程序需要的其他头文件
#include<vector>
#include<string>
#include<iostream>
#include "baseClass.h"
#include "Tree.h"
#include "treeNode.h"
using namespace std;

main

#include "stdafx.h"
/*
A
 B
  D
  E
 C
  F
*/
void text()
{
	auto a = new TreeNode ("A",0);
	auto b = new TreeNode("B",1);
	auto c = new TreeNode("C",1);

	auto d = new TreeNode("D",2);
	auto e = new TreeNode("E",2);
	
	auto f = new TreeNode("F",2);
	//A里添加bc两个子节点
	a->addChild(b);
	a->addChild(c);

	b->addChild(d);
	//b->removeChild(d);
	b->addChild(e);

	c->addChild(f);
	Tree root(a);
	
	root.recursiveTraverse();//递归遍历
	cout << "---------------------" << endl;
	root.stackTraverse();//非递归遍历
}
int _tmain(int argc, _TCHAR* argv[])
{
	text();
	system("pause");
	return 0;
}

baseClass.h

#pragma once
#include<vector>
#include<string>
using namespace std;//头文件不推荐直接std，这里方便书写。

class NODE//虚基类
{
	//因为是多态实现，所以虚基类不用写成员变量
public:
	//虚析构的执行顺序是先子类后自身
	virtual ~NODE() = default;

	//添加子节点
	virtual void addChild(NODE* node) = 0;
	//移除子节点
	virtual void removeChild(NODE* node) = 0;
	//获取全部子节点，
	virtual vector<NODE*> getChildren() = 0;
	//获取节点名称
	virtual string getName() = 0;
	//获取节点深度
	virtual int getDepth() = 0;
};

TreeNode.h

#pragma once
#include "baseClass.h"
class TreeNode :public NODE
{
	int dep;
	string str;
	vector<NODE*> vec;
public:
	//构造
	TreeNode(string str,int depth) :str(str),dep(depth){}
	//析构
	~TreeNode() = default;

	//继承Node
	virtual void addChild(NODE* node)override;
	virtual void removeChild(NODE* node)override;
	virtual vector<NODE*> getChildren()override;
	virtual string getName()override;
	virtual int getDepth()override;
};

TreeNode.cpp

#include "stdafx.h"
#include "TreeNode.h"
//TreeNode
void TreeNode::addChild(NODE* node)
{
	vec.push_back(node);
}

void TreeNode::removeChild(NODE* node)
{
	auto it = find(vec.begin(), vec.end(), node);
	if (it != vec.end())
	{
		vec.erase(it);
	}
}

std::vector<NODE*> TreeNode::getChildren()
{
	return vec;
}

std::string TreeNode::getName()
{
	return str;
}


int TreeNode::getDepth()
{
	return dep;
}

Tree.h

#pragma once
#include "baseClass.h"
class Tree
{
	NODE* root;
public:
	//构造函数，（多态的实现）
	Tree(NODE* root) :root(root){};
	//析构函数
	~Tree() = default;
	//非递归遍历
	void stackTraverse();
	//递归遍历子树
	void recursiveTraverse();
private:
	//递归遍历
	void _traverse(NODE* node, int depth);
};
};

Tree.cpp

#include "stdafx.h"
#include "Tree.h"
#include<stack>


void Tree::stackTraverse()
{
	stack<NODE*> st;//定义一个栈对象
	st.push(root);//从根节点开始

	//先出后入
	while (!st.empty())//empty为空返回1
	{
		
		NODE* temp = st.top();//获取栈顶元素
		st.pop();//出栈

		for (size_t i = 0; i < temp->getDepth();i++)
		{
			cout << " ";
		}
		cout<<temp->getName()<<endl;//遍历节点名字

		for (auto e : temp->getChildren())//入栈
		{
			if (e != nullptr)
			{
				st.push(e);
			}
		}
	}
}
void Tree::recursiveTraverse()
{
	_traverse(root, 0);
}

void Tree::_traverse(NODE* node, int depth)
{
	//递归返回条件
	if (node == nullptr) return;

	for (size_t i = 0; i < depth;i++)
	{
		cout << " ";
	}
	//输出节点的名称
	cout << node->getName() << endl;

	//递归
	for (auto e : node->getChildren())
	{
		_traverse(e,depth+1);
	}
}

运行结果如下:

A
 B
  D
  E
 C
  F
---------------------
A
 C
  F
 B
  E
  D

非循环遍历详解（栈的实现）