树集锦

最新推荐文章于 2020-04-16 16:53:04 发布
最新推荐文章于 2020-04-16 16:53:04 发布
阅读量405 收藏
点赞数
分类专栏： 算法策略 文章标签： null bt insert function recursion delete 
/* 
1、二叉树的遍历：前序，中序，后序，层序－－包括递归和非递归实现
2、AVL树
3、二叉查找树


 */
//////////////////////////////////////////////////////////////////////////////////////////
//二叉树的遍历：前序，中序，后序，层序－－包括递归和非递归实现
//tree.h
/********************************************************************
    created:    2005/12/30
    created:    30:12:2005   10:39
    filename:     bintree.h
    author:        Liu Qi
    
    purpose:    二叉树的3种遍历方式(包括非递归实现),前序，后序和中序，先访问根节点就是
    前序(部分书籍称为先根遍历,个人觉得该说法更好^_^)，类似的，最后访问根节点就是后序
*********************************************************************/


#ifndef TREE_H
#define TREE_H

#include <stdio.h>
#include <malloc.h>
#include <stack>
#include <queue>
#include <assert.h>

using namespace std;

typedef int ElemType;

typedef struct treeT
{
    ElemType key;
    struct treeT* left;
    struct treeT* right;
}treeT, *pTreeT;


/*===========================================================================
* Function name:    visit
* Parameter:        root:树根节点指针
* Precondition:        
* Description:        
* Return value:        
* Author:            Liu Qi, //-
===========================================================================*/
static void visit(pTreeT root)
{
    if (NULL != root)
    {
        printf(" %d\n", root->key);
    }
}



/*===========================================================================
* Function name:  BT_MakeNode    
* Parameter:      target:元素值    
* Precondition:      None    
* Postcondition:  NULL != pTreeT 
* Description:      构造一个tree节点，置左右指针为空，并且返回指向新节点的指针    
* Return value:      指向新节点的指针    
* Author:            Liu Qi,  [12/30/2005]
===========================================================================*/
static pTreeT BT_MakeNode(ElemType target)
{
    pTreeT pNode = (pTreeT) malloc(sizeof(treeT));

    assert( NULL != pNode ); 

    pNode->key   = target;
    pNode->left  = NULL;
    pNode->right = NULL;
    
    return pNode;
}


/*===========================================================================
* Function name:    BT_Insert
* Parameter:        target:要插入的元素值, pNode:指向某一个节点的指针
* Precondition:         NULL != ppTree 
* Description:        插入target到pNode的后面
* Return value:        指向新节点的指针
* Author:            Liu Qi,  [12/29/2005]
===========================================================================*/
pTreeT BT_Insert(ElemType target, pTreeT* ppTree)
{
    pTreeT Node;

    assert( NULL != ppTree ); 

    Node = *ppTree;
    if (NULL == Node)
    {
        return *ppTree = BT_MakeNode(target);
    }

    if (Node->key == target)    //不允许出现相同的元素
    {
        return NULL;
    }
    else if (Node->key > target)    //向左
    {
        return BT_Insert(target, &Node->left);
    }
    else
    {
        return BT_Insert(target, &Node->right);
    }
}




/*===========================================================================
* Function name:    BT_PreOrder
* Parameter:        root:树根节点指针
* Precondition:        None
* Description:        前序遍历
* Return value:        void
* Author:            Liu Qi,  [12/29/2005]
===========================================================================*/
void BT_PreOrder(pTreeT root)
{
    if (NULL != root)
    {
        visit(root);
        BT_PreOrder(root->left);
        BT_PreOrder(root->right);
    }    
}


/*===========================================================================
* Function name:    BT_PreOrderNoRec
* Parameter:        root:树根节点指针
* Precondition:        Node
* Description:        前序(先根)遍历非递归算法
* Return value:        void
* Author:            Liu Qi,  [1/1/2006]
===========================================================================*/
void BT_PreOrderNoRec(pTreeT root)
{
    stack<treeT *> s;

    while ((NULL != root) || !s.empty())
    {
        if (NULL != root)
        {
            visit(root);
            s.push(root);
            root = root->left;
        }
        else
        {
            root = s.top();
            s.pop();
            root = root->right;
        }
    }
}



/*===========================================================================
* Function name:    BT_InOrder
* Parameter:        root:树根节点指针
* Precondition:        None
* Description:        中序遍历
* Return value:        void
* Author:            Liu Qi,  [12/30/2005]
===========================================================================*/
void BT_InOrder(pTreeT root)
{
    if (NULL != root)
    {
        BT_InOrder(root->left);
        visit(root);
        BT_InOrder(root->right);
    }
}


/*===========================================================================
* Function name:    BT_InOrderNoRec
* Parameter:        root:树根节点指针
* Precondition:        None
* Description:        中序遍历,非递归算法
* Return value:        void
* Author:            Liu Qi,  [1/1/2006]
===========================================================================*/
void BT_InOrderNoRec(pTreeT root)
{
    stack<treeT *> s;
    while ((NULL != root) || !s.empty())
    {
        if (NULL != root)
        {
            s.push(root);
            root = root->left;
        }
        else
        {
            root = s.top();
            visit(root);
            s.pop();
            root = root->right;
        }
    }
}



/*===========================================================================
* Function name:    BT_PostOrder
* Parameter:        root:树根节点指针
* Precondition:        None
* Description:        后序遍历
* Return value:        void
* Author:            Liu Qi,  [12/30/2005]
===========================================================================*/
void BT_PostOrder(pTreeT root)
{
    if (NULL != root)
    {
        BT_PostOrder(root->left);
        BT_PostOrder(root->right);
        visit(root);    
    }
}


/*===========================================================================
* Function name:    BT_PostOrderNoRec
* Parameter:        root:树根节点指针
* Precondition:        None
* Description:        后序遍历,非递归算法
* Return value:        void
* Author:            Liu Qi, //  [1/1/2006]
===========================================================================*/
void BT_PostOrderNoRec(pTreeT root)
{
//学习中，尚未明白
}


/*===========================================================================
* Function name:    BT_LevelOrder
* Parameter:        root:树根节点指针
* Precondition:        NULL != root
* Description:        层序遍历
* Return value:        void
* Author:            Liu Qi,  [1/1/2006]
===========================================================================*/
void BT_LevelOrder(pTreeT root)
{
    queue<treeT *> q;
    treeT *treePtr;

    assert( NULL != root ); 

    q.push(root);

    while (!q.empty())
    {
        treePtr = q.front();
        q.pop();
        visit(treePtr);

        if (NULL != treePtr->left)
        {
            q.push(treePtr->left);    
        }
        if (NULL != treePtr->right)
        {
            q.push(treePtr->right);
        }    
            
    }
}

#endif

//////////////////////////////
//main.cpp
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "tree.h"

#define MAX_CNT 5
#define BASE  100

int main(int argc, char *argv[])
{
    int i;
    pTreeT root = NULL;
    
    srand( (unsigned)time( NULL ) ); 
    
    for (i=0; i<MAX_CNT; i++)
    {
        BT_Insert(rand() % BASE, &root);
    }

    //前序
    printf("PreOrder:\n");
    BT_PreOrder(root);
    printf("\n");

    printf("PreOrder no recursion:\n");
    BT_PreOrderNoRec(root);
    printf("\n");
    
    //中序
    printf("InOrder:\n");
    BT_InOrder(root);
    printf("\n");

    printf("InOrder no recursion:\n");
    BT_InOrderNoRec(root);
    printf("\n");

    //后序
    printf("PostOrder:\n");
    BT_PostOrder(root);
    printf("\n");

    //层序
    printf("LevelOrder:\n");
    BT_LevelOrder(root);
    printf("\n");
    
    return 0;
}

///////////////////////////////////////////////////////////////////////////////////////////

//AVL树
//AvlTree.h
#ifndef AVLTREE_H
#define AVLTREE_H
typedef int Element;
typedef struct Node{
	Element data;
	struct Node *left,*right;
	int Height;		//节点的高度
}AvlNode,*AvlTree,*Position;
void MakeEmpty(AvlTree &T); //清空平衡二叉搜索树
bool IsEmpty(AvlTree T); //判断树是否为空
bool Find(Element x,AvlTree T); //查找元素
Position FindMin(AvlTree T); //查找最小元素
Position FindMax(AvlTree T); //查找最大元素
AvlTree Insert(Element x,AvlTree &T); //插入元素
Position SingleRotateWithLeft(AvlTree k2); //向左单旋转
Position SingleRotateWithRight(AvlTree k2); //向右单旋转
Position DoubleRotateWithLeft(AvlTree k3); //双旋转
Position DoubleRotateWithRight(AvlTree k3); //双旋转
int MAX(int a,int b); 
int Height(Position p); //返回节点的高度
void InOrderTraverse(AvlTree T); //前序遍历树
#endif //AVLTREE_H

/////////////////////////
//method.cpp
#include "stdafx.h"
#include "AvlTree.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void MakeEmpty(AvlTree &T) //清空树
{
	if(T == NULL)
		return;
	MakeEmpty(T->left);
	MakeEmpty(T->right);
	free(T);
	T = NULL;
}
bool IsEmpty(AvlTree T) 
{
	return T == NULL ? true : false;
}
bool Find(Element x,AvlTree T)
{
	if(T == NULL)
		return false;
	else if(x < T->data)  //如果元素小于当前节点往左继续查找
		return Find(x,T->left);
	else if(x > T->data) //如果元素大于当前节点往右继续查找
		return Find(x,T->right);
	return true;
}
Position FindMin(AvlTree T) //查找最小值
{
	if(T == NULL)
		return NULL;
	else if(T->left == NULL) //节点的左子树为NULL,此节点就是最小元素的节点
		return T;
	else
		FindMin(T->left);
}
Position FindMax(AvlTree T)
{
	if(T == NULL)
		return NULL;
	else if(T->right == NULL) //节点的右子树为NULL,此节点就是最大元素的节点
		return T;
	else
		FindMax(T->right);
}
AvlTree Insert(Element x,AvlTree &T)
{
	if(T == NULL) //创建节点
	{
		T = (AvlTree)malloc(sizeof(AvlNode));
		if(T == NULL)
		{
			printf("内存分配失败,程序即将退出\n");
			exit(1);
		}
		T->data = x;
		T->Height = 0;
		T->left = T->right = NULL;
	}
	else if(x < T->data) //元素小于当前节点的元素,往左继续
	{
		T->left = Insert(x,T->left);
		if(Height(T->left) - Height(T->right) == 2) //如果左边节点的高度比右边节点的高度大2
			if(x < T->left->data)					//且元素x小于左边的元素,也就是x插入的方向是左边
				T = SingleRotateWithLeft(T);        //执行单旋转
			else
				T = DoubleRotateWithLeft(T);        //执行双旋转
	}
	else if(x > T->data)
	{
		T->right = Insert(x,T->right);
		if(Height(T->right) - Height(T->left) == 2)
			if(x > T->right->data)
				T = SingleRotateWithRight(T);
			else
				T = DoubleRotateWithRight(T);
	}
	T->Height = MAX(Height(T->left),Height(T->right)) + 1; //计算在节点插入后的各节点的高度
	return T;
}
Position SingleRotateWithLeft(AvlTree k2) //单旋转
{
	Position k1 = k2->left;
	k2->left = k1->right;
	k1->right = k2;
	k2->Height = MAX(Height(k2->left),Height(k2->right)) + 1;
	k1->Height = MAX(Height(k1->left),k2->Height) + 1;
	return k1;
}
Position SingleRotateWithRight(AvlTree k2)
{
	Position k1 = k2->right;
	k2->right = k1->left;
	k1->left = k2;
	k2->Height = MAX(Height(k2->left),Height(k2->right)) + 1;
	k1->Height = MAX(Height(k1->right),k2->Height);
	return k1;
}
Position DoubleRotateWithLeft(AvlTree k3) //双旋转
{
	k3->left = SingleRotateWithRight(k3->left);
	return SingleRotateWithLeft(k3);
}
Position DoubleRotateWithRight(AvlTree k3)
{
	k3->right = SingleRotateWithLeft(k3->right);
	return SingleRotateWithRight(k3);
}
int Height(Position p)
{
	return p == NULL ? -1 : p->Height;
}
int MAX(int a,int b)
{
	return a > b ? a : b;
}
void InOrderTraverse(AvlTree T) //前序遍历
{
	if(T)
	{
		printf("%d ",T->data);
		InOrderTraverse(T->left);
		InOrderTraverse(T->right);
	}
}

///////////////////////

//main.cpp
#include "stdafx.h"
#include "LinkList.h"
#include <stdio.h>
int main()
{
	AvlTree T = NULL;
	int it;
	printf("请输入平衡二叉搜索树的数据\n");
	while(scanf("%d",&it) != EOF)
		Insert(it,T);
	printf("平衡二叉搜索树的数据为:\n");
	InOrderTraverse(T);
	printf("\n");
	printf("平衡二叉搜索树的最小元素为:%d\n",FindMin(T)->data);
	printf("平衡二叉搜索树的最大元素为:%d\n",FindMax(T)->data);
	printf("请输入要查找的内容\n");
	scanf("%d",&it);
	if(Find(it,T))
		printf("在平衡二叉搜索树中找到元素%d\n",it);
	else
		printf("在平衡二叉搜索树中未找到元素%d\n",it);
	MakeEmpty(T);
	if(IsEmpty(T))
		printf("平衡二叉搜索树为空\n");
	return 0;
}

////////////////////////////////////////////////////////////////////////////////////////

// 二叉查找树
/* 二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，
则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值 */
//SearchTree.h
#ifndef SEARCHTREE_H
#define SEARCHTREE_H
typedef int Element;
typedef struct Node{
	Element data;
	struct Node* Left;
	struct Node* Right;
}SearchNode,*SearchTree,*Position;
void MakeEmpty(SearchTree T);
bool IsEmpty(SearchTree T);
bool Find(Element x,SearchTree T);
Position FindMin(SearchTree T);
Position FindMax(SearchTree T);
Position Insert(Element x,SearchTree &T);
Position Delete(Element x,SearchTree T);
void InOrderTraverse(SearchTree T);
#endif //SEARCHTREE_H

///////////////////////
//method.cpp
#include "stdafx.h"
#include "SearchTree.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void MakeEmpty(SearchTree T) //清空二叉树
{
	if(T)
	{
		MakeEmpty(T->Left);
		MakeEmpty(T->Right);
		free(T);
	}
}
bool IsEmpty(SearchTree T) //判断二叉树是否为空
{
	if(T == NULL)
		return true;
	else
		return false;
}
bool Find(Element x,SearchTree T)  //查找x是否在树中存在
{
	if(T == NULL)
		return false;
	else if(x < T->data)
		return Find(x,T->Left);
	else if(x > T->data)
		return Find(x,T->Right);
	return true;
}
Position FindMin(SearchTree T) //查找最小数
{
	if(T == NULL)
		return NULL;
	else if(T->Left == NULL)
		return T;
	else 
		return FindMin(T->Left);
}
Position FindMax(SearchTree T) //查找最大数
{
	if(T == NULL)
		return NULL;
	while(T->Right != NULL)
		T = T->Right;
	return T;
}
Position Insert(Element x,SearchTree &T) //向二叉树中插入数据
{
	if(T == NULL)
	{
		T = (SearchTree)malloc(sizeof(SearchNode));
		if(!T)
		{
			printf("内存分配失败\n");
			exit(1);
		}
		T->data = x;
		T->Left = T->Right = NULL;
	}
	else
	{
		if(x < T->data)
			T->Left = Insert(x,T->Left);
		else if( x > T->data)
			T->Right = Insert(x,T->Right);
	}
	return T;
}
Position Delete(Element x,SearchTree T) //删除元素为x的节点
{
	SearchTree temp = NULL;
	SearchTree tp = NULL;
	if(T == NULL)
		return NULL;
	else if(x < T->data)
		T->Left = Delete(x,T->Left);
	else if(x > T->data)
		T->Right = Delete(x,T->Right);
	else if(T->Left && T->Right)
	{
		temp = FindMin(T->Right);
		T->data = temp->data;
		T->Right = Delete(temp->data,T->Right);
	}
	else
	{
		tp = T;
		if(T->Left == NULL)
			T = T->Right;
		if(T->Right == NULL)
			T = T->Left;
		free(tp);
	}
	return T;
}
void InOrderTraverse(SearchTree T) //前序遍历
{
	if(T)
	{
		printf("%d ",T->data);
		InOrderTraverse(T->Left);
		InOrderTraverse(T->Right);
	}
}

//////////////////////
//main.cpp
#include "stdafx.h"
#include "SearchTree.h"
#include <stdio.h>
int main()
{
	SearchTree T = NULL;
	printf("please enter the element\n");
	int ch;
	while(scanf_s("%d",&ch) != EOF)
		Insert(ch,T);
	printf("集合中的内容为:\n");
	InOrderTraverse(T);
	printf("\n");
	printf("请输入要查找的数据\n");
	scanf_s("%d",&ch);
	if(Find(ch,T))
		printf("在集合中找到元素:%d\n",ch);
	else
		printf("在集合中没有找到元素:%d\n",ch);
	printf("集合中的最小元素为:%d\n",FindMin(T)->data);
	printf("集合中的最大元素为:%d\n",FindMax(T)->data);
	printf("请输入要删除的元素\n");
	int word;
	scanf_s("%d",&word);
	Delete(word,T);
	printf("删除后集合的元素为:\n");
	InOrderTraverse(T);
	return 0;
}

///////////////////////////////////////////////////////////////////////////////////////////////

虚树练习集锦
_Horizon
02-15 2117
虚树
理解决策树
SIGAI_优快云的博客
06-12 6197
原创声明：本文为 SIGAI 原创文章，仅供个人学习使用，未经允许，不得转载，不能用于商业目的。 其它机器学习、深度学习算法的全面系统讲解可以阅读《机器学习-原理、算法与应用》，清华大学出版社，雷明著，由SIGAI公众号作者倾力打造。 书的购买链接 书的勘误，优化，源代码资源 决策树是什么？ 决策树是最简单的机器学习算法，它易于实现，可解释性强，完全符合人类的直观思维，有着广泛的应用。决...
世界怪树集锦
bbllqjl的专栏
11-16 332
­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­ ­­­
字典树（Trie树）
qq_42024195的博客
03-09 663
引言 常关注本blog的读者朋友想必看过此篇文章：从B树、B+树、B*树谈到R 树，这次，咱们来讲另外两种树：Tire树与后缀树。不过，在此之前，先来看两个问题。 第一个问题： 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。之前在此文：海量数据处理面试题集锦与Bit-map详解中给出的参考答案：用trie树统计每个词出现的次数，时...
字典树
05-29 497
参考博文：http://blog.youkuaiyun.com/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串
Tire树（字典树）
SeaSky_Steven的博客
04-16 469
参考博文：http://blog.youkuaiyun.com/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查...
Trie树
帅性而为1号的博客
08-03 820
参考链接：http://blog.youkuaiyun.com/v_july_v/article/details/6897097                 百度百科                     http://blog.youkuaiyun.com/hackbuteer1/article/details/7964147 一、知识简介          最近在看字符串算法了，其中字典树
前缀树和后缀树
Hansry的博客
10-31 1500
转自：从Trie树（字典树）谈到后缀树 引言 谈及Tire树与后缀树之前，先看俩个问题： **第一个问题：**一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。 其中，海量数据处理面试题集锦与Bit-map详解中给出的参考答案：用trie树统计每个词出现的次数，时间复杂度是O(nle)(le表示单词的平均长度)，然后是找出出现最频繁的前1...
Trie树（字典树）
riba2534的博客
10-17 553
1. Trie树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质
TreeMap实现原理 红黑树
热门推荐
a616413086的专栏
09-19 1万+
TreeMap的实现是红黑树算法的实现，所以要了解TreeMap就必须对红黑树有一定的了解,其实这篇博文的名字叫做：根据红黑树的算法来分析TreeMap的实现，但是为了与Java提高篇系列博文保持一致还是叫做TreeMap比较好。通过这篇博文你可以获得如下知识点：        1、红黑树的基本概念。        2、红黑树增加节点、删除节点的实现过程。        3、红黑
MATLAB源码集锦-最小生成树Kruskal算法代码
02-14
通过这个MATLAB源码集锦，你可以深入理解Kruskal算法的实现细节，并进一步扩展到其他图论问题，如Prim算法、Dijkstra算法等，增强你的图处理和优化能力。同时，学习并实践这样的算法有助于提升编程技巧和解决实际...
MATLAB源码集锦-最小生成树kruskal算法离散型优化问题代码
02-14
MATLAB源码集锦中的"最小生成树kruskal算法离散型优化问题代码"很可能是对上述步骤的具体实现，包括读取输入、处理数据、执行Kruskal算法并显示结果。通过学习和理解这段代码，你可以更深入地了解Kruskal算法及其在...
MATLAB源码集锦-二叉决策树分类代码
02-16
总的来说，这个MATLAB源码集锦将帮助你深入理解二叉决策树分类的工作机制，并提供实践经验，让你能够在自己的项目中有效地利用决策树算法。通过阅读和运行这些代码，你可以掌握决策树的构建、训练、剪枝以及性能评估...
二叉搜索树操作集锦.md
11-17
二叉搜索树操作集锦.md
组织架构和岗位职责.doc
08-07
组织架构和岗位职责.doc
建业集团工程实测实量标准.doc
08-07
建业集团工程实测实量标准.doc
Blu-ray.vbs工具 可以补全蓝光ISO缺失目录
最新发布
08-07
Blu-ray.vbs可以检测蓝光目录的完整性，并自动补全
某公司员工持股方案设计.doc
08-07
某公司员工持股方案设计.doc
安徽省职业技能鉴定考评人员培训讲义.doc
08-07
安徽省职业技能鉴定考评人员培训讲义.doc
精选透明Flash素材：美丽花朵与树木集锦
### 知识点概述 #### 1. Flash技术介绍 Flash是由Adobe公司开发的一种多媒体创作软件，主要用于设计和开发动画、游戏、演示文稿和应用程序等。它支持矢量图形、动画和视频，能够创作出丰富的交互式内容。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值