【殷人昆数据结构】第五章5.3 树的子女-兄弟表示Tree代码的调试

最新推荐文章于 2021-10-08 20:54:30 发布
最新推荐文章于 2021-10-08 20:54:30 发布
阅读量274 收藏 4
点赞数
分类专栏： 数据结构笔记 文章标签： 二叉树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianty1121/article/details/108318651
版权

树的子女-兄弟表示Tree

文章目录

主函数

#include "Tree.h"
#include <fstream>
#include <cassert>
#include <iomanip>
using namespace std;

void visit(TreeNode<int> * n){
	cout << setw(4) << n->data;
}

int main(){
	Tree<int> tree(0);                   //输入结束符为0
	cout << "The Intended text of the tree is:\n";
	ifstream fin("data.txt");
	assert(fin);
	fin >> tree;
	fin.close();
	cout << tree;
	tree.Output();
	cout << "\nThe preorder of the tree is:\n";
	tree.PreOrder(visit);
	cout << "\nThe levelorder of the tree is:\n";
	tree.LevelOrder(visit);
	cout << "\nThe postorder of the tree is:\n";
	tree.PostOrder(visit);

	cout << "\n\nPress enter to exit!\n";
	char ch;
	cin.get(ch);
	return 0;
}

树结点类定义

template <typename T>struct TreeNode{
	T data;
	TreeNode<T> *firstChild, *nextSibling;
	TreeNode(T value = 0, TreeNode<T> *fc = NULL, TreeNode<T> *ns = NULL)
		:firstChild(fc), nextSibling(ns){
		data = value;
	}
};

Tree类定义

template <typename T>class Tree{
public:
	Tree(){
		root = current = NULL;
	}
	Tree(T value){
		root = current = NULL;
		RefValue = value;
	}
	bool Root(); 			//置根结点为当前结点
	TreeNode<T> *getRoot(){
		return root;
	}
	void setRoot(TreeNode<T> *rt){
		root = rt;
	}
	bool IsEmpty(){
		return root == NULL;
	}
	bool FirstChild();		//将当前结点的第一个子女置为当前结点
	bool NextSibling();		//将当前结点的下一个兄弟置为当前结点
	bool Parent();			//将当前结点的双亲置为当前结点
	bool Find(T value);		//搜索含value的结点，使之成为当前结点

	void PreOrder(void (*visit)(TreeNode<T> *t)){//前序
		TreeNode<T> *p = root;
		while (p){
			PreOrder(p, visit);
			p = p->nextSibling;
		}
	}
	void PostOrder(void (*visit)(TreeNode<T> *t)){//后序
		TreeNode<T> *p = root;
		while (p){
			PostOrder(p, visit);
			p = p->nextSibling;
		}
	}
	void LevelOrder(void (*visit)(TreeNode<T> *t)){//层次
		LevelOrder(root, visit);
	}

	//以先根次序输入树，以RefValue表示某结点没有子女或不再有兄弟
	void CreateTree(istream &in = cin){
		CreateTree(in, root);
	}
	void Output(ostream &out = cout){		//树状格式输出
		Output(root, string(), out);
	}
	void IntendedText(ostream &out = cout){	//将树用网络文本形式输出	
		IntendedText(root, string(), out);//string()是构造函数
	}
	void ShowTree(ostream &out = cout){
		ShowTree(root, out);
	}
	void reSetCurrent(){		//将current重新指向根节点
		current = root;
	}
	friend istream& operator >> (istream &in, Tree<T> &tree)
	{	tree.CreateTree(in,tree.root);
	    return in;
	}; //tree不可误作Tree
	friend ostream& operator << (ostream &out, Tree<T> &tree)
	{	tree.IntendedText(out);
	    return out;
	};
private:
	TreeNode<T> *root, *current;
	bool Find(TreeNode<T> *p, T value);		//在以p为根的树中搜索value
	void RemovesubTree(TreeNode<T> *subTree);		//删除以p为根的子树
	bool FindParent(TreeNode<T> *t, TreeNode<T> *p);
	void PreOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void PostOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void LevelOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void Output(TreeNode<T> *subTree, string str, ostream &out);
	void IntendedText(TreeNode<T> *subTree, string str, ostream &out);
	void ShowTree(TreeNode<T> *t, ostream &out);
	void CreateTree(istream& in, TreeNode<T> *& subTree);
	//以先根次序输入树，以RefValue表示某节点没有子女或不再有兄弟
	T RefValue;					//数据输入停止标志
};

Root

template <typename T> bool Tree<T>::Root(){		
//让树的根节点成为当前节点
	if (root == NULL){
		current = NULL;
		return false;
	}
	else{
		current = root;
		return true;
	}
}

Parent与FindParent函数

在这里插入图片描述

template <typename T>bool Tree<T>::Parent(){		
	TreeNode<T> *p = current;
	if (current == NULL || current == root){	
		current = NULL;
		return false;
	}
	return FindParent(root, p);	
}

template <typename T>bool Tree<T>::FindParent(TreeNode<T> *t, TreeNode<T> *p){	
	TreeNode<T> *q = t->firstChild;     
	while (q != NULL && q != p){	
		if (FindParent(q, p)){
		   return true;
		}
		q = q->nextSibling;
	}
	if (q != NULL && q == p){
		current = t;
		return true;
	}
	else{
		current = NULL;
		return false;
	}
}

FirstChild函数

template <typename T>bool Tree<T>::FirstChild(){	
	if (current && current->firstChild){
		current = current->firstChild;
		return true;
	}
	current = NULL;
	return false;
}

NextSibling

template <typename T> bool Tree<T>::NextSibling(){	
	if (current && current->nextSibling){
	  current = current->nextSibling;
	  return true;
	}
	current = NULL;
	return false;
}

PreOrder函数

template <typename T> 
void Tree<T>::PreOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){
	if (subTree){
		visit(subTree);
		subTree = subTree->firstChild; 
		while (subTree){
			PreOrder(subTree, visit);
			subTree = subTree->nextSibling;
		}
	}
}

PostOrder函数

template <typename T>void Tree<T>::PostOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){
	if (subTree){
		TreeNode<T> *p = subTree;
		p = p->firstChild; 
		while (p){
			PostOrder(p, visit);
			p = p->nextSibling;
		}
		visit(subTree);
	}
}

LevelOrder 函数——层次遍历

Queue是先进先出的。

template <typename T>void Tree<T>::LevelOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){
	SeqQueue<TreeNode<T>*> Q;
	if (subTree){
		while (subTree){
			Q.EnQueue(subTree);
			subTree = subTree->nextSibling;
		}
		while (!Q.IsEmpty()){
			Q.DeQueue(subTree);
			visit(subTree);
			subTree = subTree->firstChild;
			while (subTree){
				Q.EnQueue(subTree);
				subTree = subTree->nextSibling;
			}
		}
	}
}

Find函数

template <typename T>bool Tree<T>::Find(T value){
	if (IsEmpty()){
		return false;
	}
	return Find(root, value);
}

template <typename T>bool Tree<T>::Find(TreeNode <T> *p, T value){
	bool result = false;
	if (p->data == value){
		result = true;
		current = p;
	}
	else{
		TreeNode<T> *q = p->firstChild;
		while (q != NULL && !(result = Find(q, value))){
		//第一层递归进去还会继续向孩子结点递归，全部找不到才会继续滑翔nextSibling，找到了直接返回
			q = q->nextSibling;
		}
	}
	return result;
}

RemovesubTree函数

template<typename T>void Tree<T>::RemovesubTree(TreeNode<T> *subTree){	//若指针subTree不为空，则删除根为subTree的子树
	if (subTree){
		RemovesubTree(subTree->firstChild); 
 	    RemovesubTree(subTree->nextSibling);
 	    delete s`在这里插入代码片`ubTree;
	}
}

IntendedText 函数

template <typename T>void Tree<T>::IntendedText(TreeNode<T> *subTree, string str, ostream &out){
	TreeNode<T> *p = subTree;
	while (p){
		cout << str << p->data << endl;
		string temp = str + string("\t");
		if (p->firstChild){
			IntendedText(p->firstChild, temp, out);
		}
		p = p->nextSibling;
	}
}

🌰：

The Intended text of the tree is:
1
        2
                3
                4
        5
                6
                        7
                        8
                9
                10
        11

Output函数

//公有函数
	void Output(ostream &out = cout){		//树状格式输出
		Output(root, string(), out); //string()是构造函数，一开始为空
	}

template <typename T>void Tree<T>::Output(TreeNode<T> *subTree, string str, ostream &out){ //私有函数，调用Output必传入root
	if (subTree == root){
		current = root;
	}
	string temp;
	TreeNode<T> *p = subTree;
	while (p){ //结束条件，如果传入的东西是空，则无动作，回到有元素可打的位置
		out << str << p->data << endl;
		if (p == current && p->firstChild){
//			str = str + "└--";
//			temp = str;
			temp= str + "└--";
		}
		else if (p == current && p->nextSibling){
			current = current->nextSibling;
		}
		else if (p->firstChild && p->firstChild->nextSibling){
			temp = string("|  ") + str;
		}
		else{
			temp = string("   ") + str;
		}
		Output(p->firstChild, temp, out);
		//执行完子结点后会回归到兄弟结点继续执行
		p = p->nextSibling;
	}
}


The Output of the tree is:
1
└──2
│　　└──3
│　　└──4
└──5
│　　└──6
│　　│　　└──7
│　　│　　└──8
│　　└──9
│　　└──10
└──11

ShowTree函数

template <typename T>void Tree<T>::ShowTree(TreeNode<T> *t, ostream &out){
	if (!t){
		return;
	}
	out << '(';
	out << t->data;
	for (TreeNode<T> *p = t->firstChild; p; p = p->nextSibling){
		ShowTree(p, out); 
		//每次都输出、递归到下一层，到尾节点时再输出兄弟结点，以此类推
	}
	out << ')';
}

Createtree

template <typename T>void Tree<T>::CreateTree(istream& in, TreeNode<T> *& subTree){
	T item;
	if (in >> item){                              
		if (item != RefValue){
			subTree = new TreeNode<T>(item);		//Create Root
			assert(subTree);
			CreateTree(in, subTree->firstChild);	// Create first child tree
			CreateTree(in, subTree->nextSibling);	// Create nextSibling tree
		}
		else{
			subTree = NULL;
		}
	}
}

整一个头文件

#ifndef TREE_H
#define TREE_H
#include <iostream>
#include <string>
#include "SeqQueue.h"
using namespace std;

template <typename T>struct TreeNode{
	T data;
	TreeNode<T> *firstChild, *nextSibling;
	TreeNode(T value = 0, TreeNode<T> *fc = NULL, TreeNode<T> *ns = NULL)
		:firstChild(fc), nextSibling(ns){
		data = value;
	}
};

template <typename T>class Tree{
public:
	Tree(){
		root = current = NULL;
	}
	Tree(T value){
		root = current = NULL;
		RefValue = value;
	}
	bool Root(); 			//Öøù½áµãΪµ±Ç°½áµã
	TreeNode<T> *getRoot(){
		return root;
	}
	void setRoot(TreeNode<T> *rt){
		root = rt;
	}
	bool IsEmpty(){
		return root == NULL;
	}
	bool FirstChild();		//½«µ±Ç°½áµãµÄµÚÒ»¸ö×ÓÅ®ÖÃΪµ±Ç°½áµã
	bool NextSibling();		//½«µ±Ç°½áµãµÄÏÂÒ»¸öÐÖµÜÖÃΪµ±Ç°½áµã
	bool Parent();			//½«µ±Ç°½áµãµÄË«Ç×ÖÃΪµ±Ç°½áµã
	bool Find(T value);		//ËÑË÷º¬valueµÄ½áµã, ʹ֮³ÉΪµ±Ç°½áµã

	void PreOrder(void (*visit)(TreeNode<T> *t)){//Ç°Ðò
		TreeNode<T> *p = root;
		while (p){
			PreOrder(p, visit);
			p = p->nextSibling;
		}
	}
	void PostOrder(void (*visit)(TreeNode<T> *t)){//ºóÐò
		TreeNode<T> *p = root;
		while (p){
			PostOrder(p, visit);
			p = p->nextSibling;
		}
	}
	void LevelOrder(void (*visit)(TreeNode<T> *t)){//²ã´Î
		LevelOrder(root, visit);
	}

	//ÒÔÏȸù´ÎÐòÊäÈëÊ÷;ÒÔRefValue±íʾij½ÚµãûÓÐ×ÓÅ®»ò²»ÔÙÓÐÐÖµÜ
	void CreateTree(istream &in = cin){
		CreateTree(in, root);
	}
	void Output(ostream &out = cout){		//Ê÷×´¸ñʽÊä³ö	
		Output(root, string(), out);
	}
	void IntendedText(ostream &out = cout){	//½«Ê÷ÓÃËõ¸ñÎı¾ÐÎʽÊä³ö	
		IntendedText(root, string(), out);//string()Êǹ¹Ô캯Êý
	}
	void ShowTree(ostream &out = cout){
		ShowTree(root, out);
	}
	void reSetCurrent(){		//½«currentÖØÐÂÖ¸Ïò¸ù½Úµã	
		current = root;
	}
	friend istream& operator >> (istream &in, Tree<T> &tree)
	{	tree.CreateTree(in,tree.root);
	    return in;
	}; //tree²»¿ÉÎó×÷Tree
	friend ostream& operator << (ostream &out, Tree<T> &tree)
	{	tree.IntendedText(out);
	    return out;
	};//ÒòΪÀàÄ£°åµÄÓÑÔªº¯ÊýÊǺ¯ÊýÄ£°å£¬±ØÐëÔÚ´ËÉùÃ÷£¬ÔÚÀàÍⶨÒå
private:
	TreeNode<T> *root, *current;
	bool Find(TreeNode<T> *p, T value);		//ÔÚÒÔpΪ¸ùµÄÊ÷ÖÐËÑË÷value
	void RemovesubTree(TreeNode<T> *subTree);		//ɾ³ýÒÔpΪ¸ùµÄ×ÓÊ÷
	bool FindParent(TreeNode<T> *t, TreeNode<T> *p);
	void PreOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void PostOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void LevelOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t));
	void Output(TreeNode<T> *subTree, string str, ostream &out);
	void IntendedText(TreeNode<T> *subTree, string str, ostream &out);
	void ShowTree(TreeNode<T> *t, ostream &out);
	void CreateTree(istream& in, TreeNode<T> *& subTree);//ÒÔÏȸù´ÎÐòÊäÈëÊ÷;ÒÔRefValue±íʾij½ÚµãûÓÐ×ÓÅ®»ò²»ÔÙÓÐÐÖµÜ
	T RefValue;					//Êý¾ÝÊäÈëÍ£Ö¹±êÖ¾
};


template <typename T> bool Tree<T>::Root(){		//ÈÃÊ÷µÄ¸ù½áµã³ÉΪÊ÷µÄµ±Ç°½áµã
	if (root == NULL){
		current = NULL;
		return false;
	}
	else{
		current = root;
		return true;
	}
}

template <typename T>bool Tree<T>::Parent(){		//Öõ±Ç°½áµãµÄË«Ç×½áµãΪµ±Ç°½áµã
	TreeNode<T> *p = current;
	if (current == NULL || current == root){	// ¿ÕÊ÷»ò¸ùÎÞË«Ç×
		current = NULL;
		return false;
	}
	return FindParent (root, p);	//´Ó¸ù¿ªÊ¼ÕÒ*pµÄË«Ç×½áµã
}

template <typename T>bool Tree<T>::FindParent(TreeNode<T> *t, TreeNode<T> *p){	//ÔÚ¸ùΪ*tµÄÊ÷ÖÐÕÒ*pµÄË«Ç×, ²¢ÖÃΪµ±Ç°½áµã
	TreeNode<T> *q = t->firstChild;     //*qÊÇ*t³¤×Ó
	while (q != NULL && q != p){	//ɨÃèÐÖµÜÁ´
		if (FindParent(q, p)){
		   return true;
		}
		q = q->nextSibling;
	}
	if (q != NULL && q == p){
		current = t;
		return true;
	}
	else{
		current = NULL;
		return false;
	}
}

template <typename T>bool Tree<T>::FirstChild(){	//ÔÚÊ÷ÖÐÕÒµ±Ç°½áµãµÄ³¤×Ó, ²¢ÖÃΪµ±Ç°½áµã
	if (current && current->firstChild){
		current = current->firstChild;
		return true;
	}
	current = NULL;
	return false;
}

template <typename T> bool Tree<T>::NextSibling(){	//ÔÚÊ÷ÖÐÕÒµ±Ç°½áµãµÄÐÖµÜ, ²¢ÖÃΪµ±Ç°½áµã
	if (current && current->nextSibling){
	  current = current->nextSibling;
	  return true;
	}
	current = NULL;
	return false;
}

template <typename T> void Tree<T>::PreOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){
	if (subTree){
		visit(subTree);
		subTree = subTree->firstChild; 
		while (subTree){
			PreOrder(subTree, visit);
			subTree = subTree->nextSibling;
		}
	}
}

template <typename T>void Tree<T>::PostOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){
	if (subTree){
		TreeNode<T> *p = subTree;
		p = p->firstChild; 
		while (p){
			PostOrder(p, visit);
			p = p->nextSibling;
		}
		visit(subTree);
	}
}

template <typename T>void Tree<T>::LevelOrder(TreeNode<T> *subTree, void (*visit)(TreeNode<T> *t)){	//°´¹ã¶ÈÓÅÏÈ´ÎÐò·Ö²ã±éÀúÊ÷, Ê÷µÄ¸ù½áµãÊǵ±Ç°Ö¸Õëcurrent¡£
	SeqQueue<TreeNode<T>*> Q;
	if (subTree){
		while (subTree){
			Q.EnQueue(subTree);
			subTree = subTree->nextSibling;
		}
		while (!Q.IsEmpty()){
			Q.DeQueue(subTree);
			visit(subTree);
			subTree = subTree->firstChild;
			while (subTree){
				Q.EnQueue(subTree);
				subTree = subTree->nextSibling;
			}
		}
	}
}

template <typename T>bool Tree<T>::Find(T value){
	if (IsEmpty()){
		return false;
	}
	return Find(root, value);
}

template <typename T>bool Tree<T>::Find(TreeNode <T> *p, T value){
	bool result = false;
	if (p->data == value){
		result = true;
		current = p;
	}
	else{
		TreeNode<T> *q = p->firstChild;
		while (q != NULL && !(result = Find(q, value))){
			q = q->nextSibling;
		}
	}
	return result;
}

template<typename T>void Tree<T>::RemovesubTree(TreeNode<T> *subTree){	//˽Óк¯Êý: ÈôÖ¸ÕësubTree²»Îª¿Õ, Ôòɾ³ý¸ùΪsubTreeµÄ×ÓÊ÷
	if (subTree){
		RemovesubTree(subTree->firstChild); 
 	    RemovesubTree(subTree->nextSibling);
 	    delete subTree;
	}
}

template <typename T>void Tree<T>::IntendedText(TreeNode<T> *subTree, string str, ostream &out){
	TreeNode<T> *p = subTree;
	while (p){//Éî¶ÈÓÅÏÈ
		cout << str << p->data << endl;
		string temp = str + string("\t");//×¢Òâ±í´ïʽ×îºóÒ»Ïî¹¹ÔìÎÞÃû±ê×¼´®
		if (p->firstChild){
			IntendedText(p->firstChild, temp, out);//Éî¶ÈµÝ¹é
		}
		p = p->nextSibling;//¹ã¶ÈÑ­»·
	}
}

template <typename T>void Tree<T>::Output(TreeNode<T> *subTree, string str, ostream &out){
	if (subTree == root){
		current = root;
	}
	string temp;
	TreeNode<T> *p = subTree;
	while (p){//Éî¶ÈÓÅÏÈ
		out << str << p->data << endl;//str¿ªÊ¼ÊÇ¿Õ´®
		if (p == current && p->firstChild){
//			str = str + "©¸©¤©¤";
//			temp = str;
			temp= str + "©¸©¤©¤";
		}
		else if (p == current && p->nextSibling){
				current = current->nextSibling;
			}
			else if (p->firstChild && p->firstChild->nextSibling){
				temp = string("©¦¡¡¡¡") + str;
				}
				else{
					temp = string("¡¡¡¡¡¡") + str;
				}
		Output(p->firstChild, temp, out);//Éî¶ÈµÝ¹é
		p = p->nextSibling;//¹ã¶ÈÑ­»·
	}
}

template <typename T>void Tree<T>::ShowTree(TreeNode<T> *t, ostream &out){
	if (!t){
		return;
	}
	out << '(';
	out << t->data;
	for (TreeNode<T> *p = t->firstChild; p; p = p->nextSibling){
		ShowTree(p, out);
	}
	out << ')';
}

template <typename T>void Tree<T>::CreateTree(istream& in, TreeNode<T> *& subTree){
	T item;
	if (in >> item){                                //Á÷Õý³£Ö´ÐÐÒÔϳÌÐò
		if (item != RefValue){
			subTree = new TreeNode<T>(item);		//Create Root
			assert(subTree);
			CreateTree(in, subTree->firstChild);	// Create first child tree
			CreateTree(in, subTree->nextSibling);	// Create nextSibling tree
		}
		else{
			subTree = NULL;
		}
	}
}

#endif
率真的瓜子
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
孩子兄弟表示法实现树
07-24 1万+
因本人能力有限，参考了另一位大牛的代码，在此向他表示感谢！ vs2008运行正确，如有误，请各位大牛指正！ // CSTree.cpp : 定义控制台应用程序的入口点。 //孩子兄弟表示法实现树 #include "stdafx.h" #include using namespace std; const int MaxCSTreeSize = 20; //结点类 template cl
树的表示(2)--子女兄弟表示法
qq_40691051的博客
10-28 527
头结点： struct Node { char data; struct Node* lchild, *rsibling; }; 1、建树： 通过给定树的层次序列所有元素以及对应结点的度来构造树。例如这样一课树： R A D E B C F G ...
树的双亲表示法，孩子表示法，孩子兄弟表示法（C语言）
08-10 741
树的双亲表示法：使用顺序表 /*#include<stdio.h> #include<stdlib.h> //节点结构 typedef struct Node { char data; int parent; }Node...
树的子女-兄弟表示法的遍历操作总结
wait2024的博客
10-12 2852
方法一： 层次遍历，类似于图中的广度优先遍历。定义一个队列，先将根结点入队列，当队列不为空时循环进行如下操作：队头元素出队列，访问该元素，将它的子女结点及子女结点的所有兄弟结点入队列。代码如下： 方法二： 深度优先遍历，包括先根次序遍历和后根次序遍历。 先根次序遍历是先访问根结点，再先根递归访问它的所有子树；后根次序遍历是先后根递归遍历它的所有子树，再访问根节点。 先根次序遍历代码： 后根次...
树的孩子兄弟表示法详解
qq_38158479的博客
02-04 749
一： (1)关于原理介绍(大话数据结构那本书中介绍的很详细) (2)参考：https://blog.csdn.net/qq_25775935/article/details/88647758 二： 代码实现 #include"cstree.h" int main(void) { cstree T = NULL; T = (cstree)malloc(sizeof(csnode)); in...
树的一些概念性质
weixin_34008784的博客
01-06 607
满二叉树：深度为k且有2k-1个节点的二叉树，这种树的特点是每一层上的节点数都是最大节点数 完全二叉树：深度为k，有n个节点的二叉树，叶子结点只在最大两层上出现，左子树深度与右子树深度相等或大1，当且仅当其每一个节点都与深度为k的满二叉树中从编号1至n的结点一一对应时，就是完全二叉树 1．二叉树是度为2的有序树（ ） 【答案】× 不大于2的有序树 深度为K的完全二叉树的结点个数...
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
殷人昆 数据结构C++第二版源代码（参考）
最新发布
09-05
《殷人昆 数据结构C++第二版源代码》是一份宝贵的教学参考资料，它涵盖了数据结构在C++编程语言中的实现，对于学习C++和数据结构的程序员来说极具价值。数据结构是计算机科学的基础，它是研究如何高效存储和组织数据...
殷人昆《数据结构》电子源代码
07-16
5. **图**：图数据结构用于表示对象之间的关系，包括邻接矩阵和邻接表等表示方法，以及深度优先搜索（DFS）和广度优先搜索（BFS）等遍历算法。 6. **哈希表**：哈希表提供快速的查找、插入和删除操作，通过哈希函数...
殷人昆数据结构用面向对象方法与C++语言描述第二版扫描版
02-16
《殷人昆数据结构用面向对象方法与C++语言描述》是数据结构领域一本重要的教材，尤其对于学习C++编程的计算机科学和技术专业的学生来说，它提供了深入理解数据结构和算法的基础。本书的第二版在第一版的基础上进行了...
求 以孩子-兄弟链表表示的树 的度、深度、叶结点和边
Feynman1999的博客
05-26 2万+
孩子兄弟表示法 任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟。 //其结构可定义为 typedef struct CSNode{ char data; struct CSNode* firstchild; struct CSNode* nextsibling; }CSNode,*C
树的孩子兄弟表示法C++代码实现
Charming的博客
10-08 1328
树的孩子兄弟表示法 // 孩子兄弟表示法 #include <stdio.h> #include <iostream> using namespace std; #define ElemType char typedef struct Node{ ElemType data; struct Node * firstchild,*nextsibling; }Node,*Tree; Tree init_data2(Tree tree){ ElemTy
二叉树的建立和三种遍历方式（递归）
jian_xiaohui的博客
07-08 580
二叉树的建立和遍历 例如 给出下图： //先序是abd###c## //#代表空节点 //先序（根左右），即先遍历根节点，再遍历左节点，直到最左节点为空，接着遍历右节点 。即abdc. //中序（左根右），即先遍历左节点，直到遍历到最左，然后遍历根节点，最后再遍历右节点直到最右。即bdac. //后序（左右根），即先遍历左节点，直到遍历到最左，然后遍历右节点，直到到最右，最后再遍历根节点。即db...
孩子兄弟表示法(二叉链表树)
热门推荐
RowandJJ
06-02 5万+
考虑下面这森林： 如果用孩子兄弟表示法可以表示为： 顾名思义，孩子兄弟表示法的每个节点有两个指针域，一个指向其长子，另一个指向其兄弟. 实现： /************************************************** 树的孩子兄弟表示法(二叉链表树) by Rowandjj 2014/5/25 ***********
树、森林 p152 5-7
云淡风轻_的博客
09-18 510
5.编程求以孩子兄弟表示法存储的森林的叶子节点数 当森林以孩子兄弟表示法存储时，若结点没有孩子，则必定是叶子，总的叶子结点个数是孩子子树上的叶子树和兄弟子树上的叶节点个数之和。 typedef struct node{ ElemType data; struct node *fch,*nsib; }*Tree; int Leaves(Tree t){ if(t==NULL) return 0; if(t->fch==NULL) return 1+Leaves(t->nsib);
树的孩子兄弟表示法及遍历操作
lfbcsdn博客
11-11 1万+
代码贴上： /* @孩子兄弟表示法建立的一般树 */ #include&lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstdlib&gt; #include &lt;cstring&gt; #define OK 1 #define ERROR 0 #define FALSE 0 #define TRUE 1 #define OVER...
【数据结构】多项式加法与乘法
tianty1121的博客
07-26 1751
人类对于多项式相加的思维是这样的： P1=3X5+4X4−X3+2X−1P1 = 3X^5+4X^4-X^3\quad\quad\quad +2X-1P1=3X5+4X4−X3+2X−1 P2=2X4+X3−7X2+XP2 = \quad\quad\quad2X^4 +X^3-7X^2+XP2=2X4+X3−7X2+X ----------------------------------------------------------------- P=3X5+6X4−7X2+3X−1P = 3X^5 +
【数据结构】堆栈基本原理
tianty1121的博客
07-24 1651
什么是堆栈 计算机如何进行表达式求值？ 这个地方前缀表达式比较容易搞混，来几个???? a+b∗c−d/ea+b*c-d/ea+b∗c−d/e 的前缀表达式：−+a∗bc/de-+a*bc/de−+a∗bc/de 1+((2+3)∗4)−51+((2+3)*4)-51+((2+3)∗4)−5 的前缀表达式：−+1∗+2345- + 1 * + 2 3 4 5−+1∗+2345 这个有一个简单的方法： 如：我要将 a+b∗c+(d∗e+f)∗ga+b*c+(d*e+f)*ga+b∗c+(d∗e+f)∗g 变成
【殷人昆数据结构】第四章4.3 稀疏矩阵SparseMatrix代码的调试
tianty1121的博客
08-27 987
稀疏矩阵SparseMatrix 主函数 #include <iostream> #include "SparseMatrix.h" #include "SparseMatrix.cpp" using namespace std; int main(){ cout<<"+---------------------------------------------------------------+"<<endl; cout<<"#1 Construct
清华殷人昆数据结构笔记(c++)4
09-02
//---------------------------------小结栈、队列和优先队列是常用的数据结构，它们都是线性表的扩展形式，具有各自特定的特点和应用场景。栈适合处理嵌套结构的问题，队列适合模拟排队等待的情况，而优先队列适合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值