一个应用二叉搜索树实现的字典，并存储结构于文件中 (转)

最新推荐文章于 2023-02-21 17:56:33 发布
转载 最新推荐文章于 2023-02-21 17:56:33 发布 · 67 阅读 · 0
文章标签：

#开发工具

本文介绍了一个使用二叉搜索树实现的高效字典结构，该字典能够快速读取大量词汇并进行频率排序。文章详细描述了字典的设计理念、主要功能以及进一步改进的方向。
一个应用二叉搜索树实现的字典，并存储结构于文件中 (转)[@more@]

  Super Power Dictionary

C.Third Edition

 
 
This is the third edition of my dictionary and it is very, very powerful now! Read in 20K words from a 2.3M text

 
 
 
file only uses less than 2seconds. However, ranking them will take 41seconds! As it need to track each node from

 
 
 
"WordTree" from "big to small" by "Frequency" and "rank" them by this sequence and then copy each node to a node

 
 
 
of "RankTree" then "insert" the new rankTree node into ranktree.

 
 
 
1。 Basic idea: I found out some mistakes in "ranking" functions. And it is really a hardtime to debug for a 

 
 
 
whole day in lab(almost 8hours from 10:00AM to 18:30PM).

 
 
 
2。 Program design: The biggest problem is still how to walk round the "key" problem of RankTree by using "frequency"

 
 
 
as key to compare and at same keep all ancester class with their original functions.　

 
 
 
3。 Major function：

 
 
 
A. void traverse(...); 

 
 
 
I add one more parameters to let "RankTree Forest" to start traversing from its own "root". 

 
 
 
B. void insertRank(Tree* node, void* userPtr)

 
 
 
This is a special "callback" function to construct "RankTree" forest by "traversing" each node of

 
 
 
"WordTree".

 
 
 
C. void Tree::maxWalk(...);

 
 
 
There are two format of this new MAXORDER way of traversing. Actually it is so-called "from big to small"

 
 
 
exactly opposite to "MIDORDER".　

 
 
 
4。 Further improvement：

 
 
 
A. I have to go soon, so, no more time.

 
 
 
B. Still need improve.

 
 
 
C. Ranking counting and WordTree counting is differed by one, and I have not found the bug.

 
 
 
D. I hope I can rewrite the basic string-related part to enable the dictionary to read Chinese.

 
 
 

 
 
 

 
 
 
#include #include #include #include #include 

 
 
 
using namespace std;

 
 
 
const char* DefaultBackup = "c:nickback.txt"; const MaxWordLength = 255;

 
 
 
enum TraverseOrder { PREORDER, MIDORDER, POSTORDER, MAXORDER };

 
 
 
class Tree { private: Tree* pLeft; Tree* pRight; Tree* pParent; char* pName; int index; static int treeCounter; static Tree* pRoot; int freq; int rank; void maxWalk(Tree* node, void (*visit)(Tree* node)); void preWalk(Tree* node, void (*visit)(Tree* node)); void midWalk(Tree* node, void (*visit)(Tree* node)); void postWalk(Tree* node, void (*visit)(Tree* node)); void maxWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr); void preWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr); void midWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr); void postWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr); protected: void* pKey; public: void decCount() {treeCounter --;} const int getRank() { return rank;} void setRank(const int newRank) { rank = newRank;} const int getFreq() {return freq;} void setFreq(const int newFreq) { freq = newFreq;} void setFreq() {freq++;} Tree* left(); Tree* right(); Tree* parent(); virtual void* key(); virtual void setKey(void* newKey); void setRoot(Tree* node); const char* name(); const int getIndex(); void setLeft(Tree* leftSon); void setRight(Tree* rightSon); void setParent(Tree* father); void setIndex(const int number); virtual int compare(const void* otherKey); void setName(const char *str); void giveBirth(); virtual bool operator>(Tree&); virtual bool operator==(Tree&); virtual bool operator 

 
void visitRank(Tree* node, void* userPtr);

 
 
 
void defaultVisit(Tree* node);

 
 
 
void insertRank(Tree* node, void* userPtr);

 
 
 
class BinaryTree: public Tree { private: 

 
 
 
public: virtual void remove(BinaryTree* node); virtual BinaryTree* next(); virtual BinaryTree* prev(); virtual bool insert(BinaryTree* node, BinaryTree* start=(BinaryTree*)root()); virtual ~BinaryTree();

 
 
 
};

 
 
 
class WordTree: public BinaryTree { private: static int wordLength; static int wordCounter; WordTree* addNode(WordTree* node, FILE** stream); 

 
 
 
protected: void setWordCounter(); void readWord(FILE** file); void addWord(char* buffer);

 
 
 
public: WordTree* searchWord(WordTree* node, const char* buffer); WordTree* readNode(WordTree* node, FILE** stream); WordTree* readFromFile(const char* fileName); void saveNode(WordTree* node, FILE** stream); virtual int compare(const void *otherKey); void setWordLength(const int newLength); static const int getWordLength(); virtual void setKey(void* newKey); virtual bool operator>(Tree&); virtual bool operator==(Tree&); virtual bool operator 

 
class RankTree: public WordTree { private: 

 
 
 
protected: 

 
 
 
public: virtual bool operator>(Tree& node); virtual bool operator 

 
}; 

 
 
 
int count=0;

 
 
 
int main() { WordTree *ptr = new WordTree; char choice[6], fileName[30]; long start =0;

 
 
 
ptr = ptr->readFromFile(DefaultBackup); cout<>choice; while (strcmp(choice, "quit")!=0&&strcmp(choice, "input")!=0) { cout<>choice; } if (strcmp(choice, "quit")==0) { cout<wordCount()<>fileName; while (strcmp(fileName, "quit")!=0) { start = time(0); ptr->openFile(fileName); cout< 

 
cin>>fileName; } cout<count()<

 

 
 
 
cin>>choice; if (strcmp(choice, "yes")==0) { ptr->traverse(defaultVisit, PREORDER); }

 
 
 
cout<>choice; if (strcmp(choice, "yes")==0) { start = time(0); int rankCount =0; RankTree *rankPtr = new RankTree; rankPtr->setFreq(ptr->getFreq()); rankPtr->setName((char*)ptr->key()); 

 
 
 
ptr->traverse(insertRank, (void*)rankPtr);

 
 
 
rankPtr->traverse(visitRank, (void*)(&rankCount), MAXORDER, rankPtr); cout<>choice; if (strcmp(choice, "yes")==0) { rankPtr->traverse(defaultVisit, MAXORDER, rankPtr); } cout<count()<wordCount(); ptr->saveToFile(DefaultBackup); } }

 
 
 
return 0; } 

 
 
 
int WordTree::wordCounter = 0; int WordTree::wordLength = 20; 

 
 
 
void insertRank(Tree* node, void* userPtr) { RankTree* rankPtr;// rankPtr = (RankTree*)(((RankTree*)userPtr)->searchWord((RankTree*)userPtr,(char*)node->key())); if (rankPtr == NULL) { rankPtr = new RankTree; rankPtr->setName((char*)node->key()); 

 
 
 
rankPtr->setFreq(node->getFreq()); ((RankTree*)(userPtr))->insert(rankPtr, (RankTree*)userPtr); } }

 
 
 
RankTree::RankTree() { decCount(); }

 
 
 
void visitRank(Tree* node, void* userPtr) { node->setRank(*(int*)(userPtr)); *(int*)(userPtr) +=1; } 

 
 
 
bool RankTree::operator 

 
bool RankTree::operator >(Tree& node) { int result; result = getFreq() - node.getFreq(); if (result !=0) { return (result>0); } else { return (strcmp((char*)key(), (char*)node.key())>0); } } 

 
 
 
void RankTree::setRankTree(WordTree* wordRoot) { RankTree* ptr;

 
 
 
if (wordRoot!=NULL) { if (this->root()!=NULL) { ptr = new RankTree; ptr->setFreq(wordRoot->getFreq()); ptr->setKey((void*)wordRoot->key()); ptr->insert(ptr); } else { this->setRoot(this); this->setFreq(wordRoot->getFreq()); this->setKey((void*)wordRoot->key()); } 

 
 
 
setRankTree((WordTree*)wordRoot->left()); setRankTree((WordTree*)wordRoot->right()); } 

 
 
 
} 

 
 
 
BinaryTree::~BinaryTree() {

 
 
 
} 

 
 
 
WordTree::~WordTree() { 

 
 
 
}

 
 
 
void WordTree::setWordCounter() { wordCounter ++; }

 
 
 
const int WordTree::getWordLength() { return wordLength; }

 
 
 
WordTree* WordTree::addNode(WordTree* node, FILE** stream) { char buffer[MaxWordLength]; int index, pIndex, number; WordTree *domino; char *ptr=buffer, ch; 

 
 
 
fread((void*)(&index), sizeof(int), 1, *stream); fread((void*)(&pIndex), sizeof(int), 1, *stream); 

 
 
 
if (index==-1&&pIndex==-1) { return NULL; }

 
 
 
do { ch = fgetc(*stream); *ptr = ch; ptr++; } while(ch!=''); fread((void*)(&number), sizeof(int), 1, *stream); setWordCounter(); //add a word

 
 
 
if (pIndex== -1) //this is root { node->setIndex(index); node->setFreq(number); node->setName(buffer); node->setRoot(node); return node; }

 
 
 
while (pIndex!=node->getIndex()) { if (node->parent()==NULL) { return NULL; } node= (WordTree*)node->parent(); } 

 
 
 
if (node!=NULL&&pIndex==node->getIndex()) { domino = new WordTree; domino->setIndex(index); domino->setName(buffer); domino->setFreq(number); domino->setParent(node); if (*dominosetLeft(domino); } else { node->setRight(domino); } 

 
 
 
return domino; } else { return NULL; } } 

 
 
 
WordTree* WordTree::readNode(WordTree* node, FILE** stream) { WordTree* domino = node;

 
 
 
while (domino!=NULL) { domino = addNode(domino, stream); } return (WordTree*)node->root(); //this is ugly as I have to remove those sentinal }

 
 
 
WordTree* WordTree::readFromFile(const char* fileName) { FILE* stream;

 
 
 
if ((stream=fopen(fileName, "r+b"))==NULL) { cout< 

 
void WordTree::saveNode(WordTree* node, FILE** stream) { int first, second, number;

 
 
 
first = node->getIndex(); number = getFreq();

 
 
 
fwrite((void*)(&first), sizeof(int), 1, *stream); if (node->parent()==NULL) { second = -1; } else { second = node->parent()->getIndex(); } fwrite((void*)(&second), sizeof(int), 1, *stream); fwrite((void*)(node->name()),sizeof(char), strlen(node->name()), *stream); fputc('', *stream);//I have to put this '/n' otherwise there is always problem! fwrite((void*)(&number), sizeof(int), 1, *stream); }

 
 
 
void traverseTree(WordTree* node, FILE** stream) { if (node!=NULL) { node->saveNode(node, stream); traverseTree((WordTree*)node->left(), stream); traverseTree((WordTree*)node->right(), stream); } }

 
 
 
void writeEnd(FILE** stream) { int temp1=-1, temp2=-1; fwrite((void*)(&temp1), sizeof(int), 1, *stream); fwrite((void*)(&temp2), sizeof(int), 1, *stream); }

 
 
 
void WordTree::saveToFile(const char* fileName) { void traverseTree(WordTree* node, FILE ** stream); void writeEnd(FILE** stream);

 
 
 
WordTree *domino; 

 
 
 
FILE * stream; 

 
 
 
if ((stream=fopen("c:nickback.txt", "w+b"))==NULL) { cout< 

 
const int Tree::count() { return treeCounter; }

 
 
 
void WordTree::setWordLength(const int newLength) { if (newLength>MaxWordLength) { cout< 

 
int WordTree::compare(const void*otherKey) { return strcmp((char*)key(), (char*)otherKey); }

 
 
 
int WordTree::wordCount() { return wordCounter; }

 
 
 
WordTree::WordTree() { 

 
 
 
}

 
 
 
void WordTree::openFile(const char* fileName) { FILE * stream; if ((stream=fopen(fileName, "r+b"))==NULL) { cout< 

 
void WordTree::readWord(FILE **stream) { char buffer[MaxWordLength]; char *ptr = buffer; char ch; int counter =0;

 
 
 
while (!feof(*stream)) { ptr = buffer; counter = 0; ch = toupper(fgetc(*stream)); while (isalnum(ch)&&!feof(*stream)&&counter

 
if (ptr!=buffer) { *ptr=''; addWord(buffer); } } }

 
 
 
WordTree* WordTree::searchWord(WordTree* node, const char* buffer) { int result; if (node!=NULL) { result = strcmp((char*)(node->key()), buffer); if (result ==0) { return node; } else { if (result < 0) { return searchWord((WordTree*)node->right(), buffer); } else { return searchWord((WordTree*)node->left(), buffer); } } } else { return NULL; } } 

 
 
 
WordTree* WordTree::findWord(const char *buffer) { return searchWord((WordTree*)root(), buffer); } 

 
 
 
void WordTree::addWord(char * buffer) { //need add a findword method and find first and then new WordTree *ptr; ptr = findWord(buffer); if (ptr==NULL) { ptr = new WordTree; 

 
 
 
ptr->setName(buffer); if (ptr->insert(ptr)) { setWordCounter(); } } else { ptr->setFreq(); } }

 
 
 
void WordTree::setName(const char *str) { Tree::setName(str); setKey((void*)name()); }

 
 
 
int Tree::treeCounter= 0;

 
 
 
WordTree::WordTree(const char* fileName) { WordTree::WordTree(); openFile(fileName); }

 
 
 
void WordTree::setKey(void * newKey) { pKey = newKey; }

 
 
 
bool WordTree::operator 

 
bool WordTree::operator ==(Tree& second) { if (strcmp((char*)key(), (char*)second.key())==0) { return true; } else { return false; } }

 
 
 
bool WordTree::operator >(Tree& second) { if (strcmp((char*)key(), (char*)second.key())>0) { return true; } else { return false; } }

 
 
 
void defaultVisit(Tree* node) { cout<getIndex()<name()<getFreq()<getRank()<parent()!=NULL) { cout<parent()->name()<parent()->left()) { cout< 

 
void Tree::preWalk(Tree* node, void (*visit)(Tree* node)) { if (node!=NULL) { visit(node); preWalk(node->left(), visit); preWalk(node->right(), visit); } } 

 
 
 
void Tree::postWalk(Tree* node, void (*visit)(Tree* node)) { if (node!=NULL) { postWalk(node->left(), visit); postWalk(node->right(), visit); visit(node); } }

 
 
 
void Tree::maxWalk(Tree* node, void (*visit)(Tree* node)) { if (node!=NULL) { maxWalk(node->right(), visit); visit(node); maxWalk(node->left(), visit); 

 
 
 
} }

 
 
 
void Tree::midWalk(Tree* node, void (*visit)(Tree* node)) { if (node!=NULL) { midWalk(node->left(), visit); visit(node); midWalk(node->right(), visit); } }

 
 
 
void Tree::preWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr) { if (node!=NULL) { visit(node, userPtr); preWalk(node->left(), visit, userPtr); preWalk(node->right(), visit, userPtr); } } 

 
 
 
void Tree::midWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr) { if (node!=NULL) { midWalk(node->left(), visit, userPtr); visit(node, userPtr); midWalk(node->right(), visit, userPtr); } }

 
 
 
void Tree::postWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr) { if (node!=NULL) { postWalk(node->left(), visit, userPtr); postWalk(node->right(), visit, userPtr); visit(node, userPtr); } }

 
 
 
void Tree::maxWalk(Tree* node, void (*visit)(Tree* node, void* userPtr), void* userPtr) { if (node!=NULL) { maxWalk(node->right(), visit, userPtr); visit(node, userPtr); maxWalk(node->left(), visit, userPtr); } } 

 
 
 
void Tree::traverse(void (*visit)(Tree* node, void* userPtr), void* userPtr, TraverseOrder defaultOrder, Tree* start) { Tree *domino; domino = start;

 
 
 
switch(defaultOrder) { case PREORDER: preWalk(domino, visit, userPtr); break; case MIDORDER: midWalk(domino, visit, userPtr); break; case POSTORDER: postWalk(domino, visit, userPtr); break; case MAXORDER: maxWalk(domino, visit, userPtr); break; } } 

 
 
 
void Tree::traverse(void (*visit)(Tree* node), TraverseOrder defaultOrder, Tree* start) { Tree *domino; domino = start;

 
 
 
switch(defaultOrder) { case PREORDER: preWalk(domino, visit); break; case MIDORDER: midWalk(domino, visit); break; case POSTORDER: postWalk(domino, visit); break; case MAXORDER: maxWalk(domino, visit); break; } }

 
 
 
Tree* Tree::pRoot = NULL;

 
 
 
void BinaryTree::remove(BinaryTree* node) { BinaryTree* ptr=NULL;

 
 
 
if (node->left()==NULL || node->right()==NULL) { if (node->left()!=NULL) { node->parent()->setLeft(node->left()); node->left()->setParent(node->parent()); } if (node->right()!=NULL) { node->parent()->setRight(node->right()); node->right()->setParent(node->parent()); } } else { ptr = node->next(); remove(ptr); ptr->setParent(node->parent()); if (node->parent()==NULL) { node->setRoot(ptr); } else { if (node==node->parent()->left()) { node->parent()->setLeft(ptr); } else { node->parent()->setRight(ptr); } ptr->setLeft(node->left()); ptr->setRight(node->right()); } } } 

 
 
 
bool Tree::operator==(Tree& second) { if (this->compare(second.key())==0) { return true; } else { return false; } }

 
 
 
bool Tree::operator compare(second.key())<0) { return true; } else { return false; } } 

 
 
 
bool Tree::operator >(Tree& second) { if (this->compare(second.key())>0) { return true; } else { return false; } }

 
 
 
int Tree::compare(const void * otherKey) { return *((int*)(key()))- *((int*)(otherKey)); }

 
 
 
void* Tree::key() { return pKey; }

 
 
 
void Tree::setKey(void *newKey) { pKey = malloc(sizeof(int)); *(int*)(pKey) = *(int*)(newKey); } 

 
 
 
void Tree::setRoot(Tree *node) { pRoot = node; }

 
 
 
bool BinaryTree::insert(BinaryTree* node, BinaryTree* start) { Tree* ptr, *dummy;

 
 
 
ptr = start; dummy = ptr; while (ptr!=NULL) { dummy = ptr; if (*ptr>*node) { ptr = ptr->left(); } else { if (*ptrright(); } else { if (*ptr==*node) { return false; } } } }

 
 
 
node->setParent(dummy);

 
 
 
if (dummy==NULL) { setRoot(node); } else { // node->setRoot(dummy->root()); if (*dummy>*node) { dummy->setLeft(node); } else { if (*dummysetRight(node); } } //if "== ", donot insert; } return true; } 

 
 
 
void Tree::setLeft(Tree* leftSon) { pLeft = leftSon; }

 
 
 
void Tree::setRight(Tree* rightSon) { pRight = rightSon; }

 
 
 
void Tree::setParent(Tree* father) { pParent = father; } 

 
 
 
void Tree::giveBirth() { Tree* leftTree = new Tree; Tree* rightTree = new Tree; char str[128];

 
 
 
leftTree->setIndex(this->getIndex() *2 ); rightTree->setIndex(this->getIndex() * 2 + 1);

 
 
 
this->setLeft(leftTree); this->setRight(rightTree);

 
 
 
leftTree->setParent(this); rightTree->setParent(this);

 
 
 
strcpy(str, "left son of "); strcat(str, this->name());

 
 
 
leftTree->setName(str);

 
 
 
strcpy(str, "right son of "); strcat(str, this->name());

 
 
 
rightTree->setName(str);

 
 
 
leftTree->setParent(this); rightTree->setParent(this);

 
 
 
if (root()==NULL) { setRoot(this); setParent(NULL); } /* else { leftTree->setRoot(root()); rightTree->setRoot(root()); } */ } 

 
 
 
void Tree::setIndex(const int number) { index = number; }

 
 
 
const int Tree::getIndex() { return index; }

 
 
 
const char* Tree::name() { return pName; }

 
 
 
void Tree::setName(const char *str) { if (str!=NULL) { pName = (char *)malloc(strlen(str)+1); strcpy(pName, str); } }

 
 
 
Tree::Tree() { setIndex(treeCounter); treeCounter++; pLeft = NULL; pRight = NULL; pParent = NULL; pName = NULL; pKey = NULL; freq = 0; rank =0; }

 
 
 
Tree::~Tree() { if (pName!=NULL) { free(pName); } if (pKey!=NULL) { free(pKey); } }

 
 
 
Tree* Tree::left() { return pLeft; }

 
 
 
Tree* Tree::right() { return pRight; }

 
 
 
Tree* Tree::parent() { return pParent; }

 
 
 
BinaryTree* BinaryTree::next() { Tree* result = NULL;

 
 
 
if (right()!=NULL) { result = right(); while (result->left!=NULL) { result = result->left(); } } else { if (parent()!= NULL) { result = this; while(result->parent()!=NULL&&result==result->parent()->right()) { result = result->parent(); } } //result = null } return (BinaryTree*)result; }

 
 
 
BinaryTree* BinaryTree::prev() { Tree* result = NULL; if (left()!=NULL) { result = left(); while (result->right()!=NULL) { result = result->right(); } } else { if (parent()!=NULL) { result = this; while (result->parent()!=NULL&&result==result->parent()->left()) { result = result->parent(); } } } return (BinaryTree*)result; } SuperDictionary.JPG

 
 
 

 
 
 
    back.gif (341 bytes)  up.gif (335 bytes)   next.gif (337 bytes)
 
 
http://www3.sympatico.ca/qingzhehuang/SuperDictionary.htm

 

 
 
 
 来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/10752043/viewspace-993038/，如需转载，请注明出处，否则将追究法律责任。 
 

 

转载于:http://blog.itpub.net/10752043/viewspace-993038/

                

        




    


  



    

      

        

            

              
                
                  csd3176
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
【C++】二叉搜索树

				
			

			

				

					春风不语。
				

				

					10-01
					
					1512
					
				

			

		

		

			
				
本篇到这里就结束了，主要讲了二叉搜索树的基本概念以及实现逻辑，希望对大家有所帮助，祝生活愉快，我们下篇再见！

			
		

	



                

            
              



	

		

			

				
					
C++：二叉搜索树模拟实现（KV模型）

					
最新发布

				
			

			

				

					Zhenyu_Coder的博客
				

				

					02-08
					
					4001
					
				

			

		

		

			
				
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。

			
		

	



              


  
              

                


	

		

			

				
					
搜索二叉树应用——简单字典实现

				
			

			

				

					weixin_34390996的博客
				

				

					02-27
					
					250
					
				

			

		

		

			
				
搜索二叉树基本概念请看上篇博客这两个问题都是典型的K（key）V（value）问题，我们用KV算法解决。

判断一个单词是否拼写正确：假设把所有单词都按照搜索树的性质插入到搜索二叉树中，我们判断一个单词拼写是否正确就是在树中查找该单词是否存在（查找key是否存在）。

结构声明下
typedef char* KeyType;

typedef struct BSTreeNode 
{
    st...

			
		

	





	

		

			

				
					
AVL树/B树/红黑树/二叉搜索树/并查集/哈夫曼树/字典树实现合集（C++）

				
			

			

				

					05-25
				

			

		

		

			
				
包含AVL树、B树、红黑树、二叉搜索树、并查集、哈夫曼树、字典树的实现

			
		

	



		

			
		



	

		

			

				
					
二叉搜索树

				
			

			

				

					weixin_30604651的博客
				

				

					02-08
					
					329
					
				

			

		

		

			
				
有一个二叉搜索树用来存储字符'A', 'B', 'C','D','E','F','G','H'下面哪个结果是后序树遍历结果）［美国著名软件公司M2009年11月笔试题］
A．ADBCEGFHB．BCAGEHFDC．BCAEFDHGD．BDACEFHG解析：二叉搜索树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树：对于树中的每个节点X，它的左子树中所有关键字的...

			
		

	





	

		

			

				
					
【实现一个二叉树管理功能，结点存储字符串】

				
			

			

				

					m0_64656010的博客
				

				

					04-25
					
					913
					
				

			

		

		

			
				
//简单二叉树
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#define max  32
typedef struct tagNode{
	char NName[max];
	struct tagNode *pL,*pR;
}TNode, *PNode;
typedef struct {
	PNode *elem;
	int front,rear;
	int queuesize;
}XhQueue;
void InitQueue(.

			
		

	





	

		

			

				
					
C语言实现的AVL树、二叉搜索树和堆栈数据结构

				
			

			

				

					
				

			

		

		

			
				
根据所提供的文件信息，该资源库聚焦于使用C语言实现多种经典的数据结构，包括AVL树、二叉搜索树以及堆栈结构，这些内容构成了数据结构学习的基础与进阶部分。  首先，从标题“Data-Structures-:hacktoberfest ...

			
		

	





	

		

			

				
					
基于数组的二叉搜索树算法实现

				
			

			

				

					
				

			

		

		

			
				
二叉搜索树（Binary Search Tree, BST）是一种重要的数据结构，广泛应用于计算机科学中的查找、插入和删除操作。然而，在本项目“Binary-Search-Tree-Over-Array-Algorithm”中，其核心思想并非传统意义上使用链式...

			
		

	





	

		

			

				
					
二叉搜索树，超强实用讲解

				
			

			

				

					冉筱
				

				

					08-13
					
					658
					
				

			

		

		

			
				
目录

      一，概述

      二，HDU1710(Binary Tree Traversals)

      三， HDU3791-二叉搜索树

      四，hd3999

      五，比较全的模板

一，概述

  时间急迫，希望能在半个月把各个算法入门了，在一个专题一个专题的搞，二叉树也搞几天了，...

			
		

	





	

		

			

				
					
二叉搜索树的基本操作和简单的应用

				
			

			

				

					Ksaila的博客
				

				

					10-06
					
					3703
					
				

			

		

		

			
				
二叉搜索树

什么是二叉搜索树：二叉搜索树又称之为二叉排序树，它不为空树时，它左子树上所有的元素都小于根节点的元素，而根节点右子树上所有的元素都大于根节点的元素。



二叉搜索树的基本操作：

二叉树的查找：

思路  ：

非递归查找：

         1.如果二叉树的根节点为空的话，直接返回0。

          2.如果二叉树的该根节点不为空的话，循环下面的操作：

       ...

			
		

	





	

		

			

				
					
数据结构之二叉搜索树的基本操作

				
			

			

				

					Chenxi13
				

				

					05-16
					
					360
					
				

			

		

		

			
				
二叉搜索树


  二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。


以上摘录自百度百科，简单来说，二叉搜索树就是任意一棵树，右子树最大，接下来是根节点...

			
		

	





	

		

			

				
					
二叉查找树（C++）

				
			

			

				

					wo_ai_luo_的博客
				

				

					02-21
					
					1198
					
				

			

		

		

			
				
二叉查找树是什么呢？（也叫二叉搜索树）就是字面意思，首先是一颗二叉树：一棵树，最多分两个叉。1.1 满二叉树上面那个图就是一颗二叉树，同时也是一颗满二叉树：每一个节点都有两个儿子，左儿子和右儿子。同时啊，还有完全二叉树：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。1.2 完全二叉树1.3 普通二叉树。

			
		

	





	

		

			

				
					
二叉搜索树实现简单字典

				
			

			

				

					f2016913的博客
				

				

					04-04
					
					3225
					
				

			

		

		

			
				
日常生活中我们经常使用字典来查找单词的中文意思，也会根据中文来查找所对应的汉语。前面我们知道二叉树实现可以迅速查找一个数据，而且可以插入和删除。 
这里我们可以用搜索二叉树实现简单的字典，查找英文单词对应的汉语意思。 
问题的描叙： 
1：如何判断英文单词是否拼写正确； 
2：如何统计单词出现的次数 
这里我们可以用二叉树的K V算法； 
v(value)是key的附属信息，这里我们可以理解为汉语

			
		

	





	

		

			

				
					
数据结构4-1：二叉搜索树

				
			

			

				

					hey，欢迎浏览我的博客，希望能给你提供帮助。
				

				

					12-13
					
					313
					
				

			

		

		

			
				
二叉搜索树什么是二叉搜索树？二叉搜索树操作的特别函数：二叉搜索树的查找操作：Find查找最大和最小元素：FindMin、FindMax二叉搜索树的插入：Insert二叉搜索树的删除：Delete
什么是二叉搜索树？

静态查找就是我们要找的元素是不动的。也就是说在一个集合上主要做的是find操作，而没有delete一个映射的这种操作发生。静态查找我们讲过的一个例子：二分查找就很nice
另外一种查找就是我们要找的这个对象的集合呢本身会动态的发生变化，也就是说经常要发生插入删除，除了查找之外还有插入删除操作发

			
		

	





	

		

			

				
					
数据结构之二叉搜索树详解

				
			

			

				

					小赵小赵福星高照的博客
				

				

					03-05
					
					895
					
				

			

		

		

			
				
二叉搜索树
文章目录二叉搜索树二叉搜索树概念二叉搜索树的操作二叉搜索树的节点结构二叉搜索树的结构二叉搜索树的查找二叉搜索树的插入二叉搜索树的遍历二叉搜索树的删除二叉搜索树插入的递归写法二叉搜索树查找的递归写法二叉搜索树删除的递归写法二叉搜索树增删查改操作代码二叉搜索树的应用Key搜索场景KV搜索场景(key-value)二叉搜索树概念二叉搜索树的操作二叉搜索树的节点结构二叉搜索树的结构二叉搜索树的查找二叉搜索树的插入二叉搜索树的遍历二叉搜索树的删除二叉搜索树插入的递归写法二叉搜索树查找的递归写法二叉搜索树删

			
		

	





	

		

			

				
					
浅析过滤敏感词过滤算法(C++)

				
			

			

				

					一个枪迷的博客
				

				

					06-16
					
					3956
					
				

			

		

		

			
				
C++ 的过滤敏感词算法

			
		

	





	

		

			

				
					
用二叉搜索树实现简单字典

				
			

			

				

					ChaseRaod的博客
				

				

					10-24
					
					1348
					
				

			

		

		

			
				
在上一篇博客中，我们介绍了二叉搜索树的基本概念和结构，那么二叉搜索树有哪些应用呢？我们可以用二叉搜索树的K V模型实现一个简单字典模型。 
http://blog.youkuaiyun.com/chaseraod/article/details/78323622#include<iostream>
#include<queue>
#include<string>
using namespace std;temp

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值