二叉查找树

于 2014-08-29 21:27:30 发布
阅读量405 收藏
点赞数
/*******************************************
二叉查找树，支持的操作包括：SERACH、MINIMUM、
MAXIMUM、PREDECESSOR、SUCCESSOR、INSERT、DELETE。
定理：对于一个高度为h的二叉查找树，操作SERACH、MINIMUM、
MAXIMUM、PREDECESSOR、SUCCESSOR的运行时间均为O(h)
*******************************************/ 
   
/*================JJ日记=====================
作者: JJDiaries(阿呆) 
邮箱：JJDiaries@gmail.com
日期: 2013-11-13
============================================*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#define WORDLEN 16 
//定义一个节点，除了存放key值外，还包含了一个data字符数组用于存放一个单词 
struct node{ 
     int key; 
     char data[WORDLEN]; 
     struct node *parent; 
     struct node *left; 
     struct node *right; 
}; 
typedef struct node * tree; 
   
/*============================================
树的中序遍历
INORDER_TREE_WALK(x)
     if x!=NIL
         then INORDER_TREE_WALK(left[x])
              print key[x]
              INORDER_TREE_WALK(left[x])
============================================*/   
void inorder_tree_walk(tree T) 
{ 
     if (T!=NULL){ 
         inorder_tree_walk(T->left); 
         printf ( "key:%d   words:%s\n" ,T->key,T->data); 
         inorder_tree_walk(T->right); 
     } 
} 
   
   
/*============================================
树的搜索，返回含有关键字k的结点
TREE_SEARCH(x,k) //递归版本
     if x=NIL or k =key[x]
         then return x
     if k<key[x]
         then return TREE_SEARCH(left[x],k)
         else return TREE_SEARCH(right[x],k)
 
TREE_SEARCH(x,k) //非递归版本
     while x!=NIL and k!= key[x]
         do if k<key[x]
             then x <—— left[x]
             else x <—— right[x]
     return x
============================================*/ 
//递归版本 
struct node* tree_search(tree T, int k) 
{ 
     if (T==NULL || k == T->key) 
         return T; 
     if (k < T->key) 
         return tree_search(T->left,k); 
     else  
         return tree_search(T->right,k); 
} 
//非递归版本 
struct node* tree_search1(tree T, int k) 
{ 
     while (T!=NULL && T->key!=k) 
         if (k < T->key) 
             T=T->left; 
         else  
             T=T->right; 
     return T; 
} 
   
/*============================================
返回key值最小的结点
TREE_MINIMUM(x)
     while left[x]!=NIL
         do x <—— left[x]
     return x
============================================*/   
struct node* tree_minimum(tree T) 
{ 
     while (T->left != NULL) 
         T=T->left; 
     return T; 
} 
   
/*============================================
返回key值最大的结点
TREE_MAXMUM(x)
     while right[x]!=NIL
         do x <—— right[x]
     return x
============================================*/ 
struct node* tree_maxmum(tree T) 
{ 
     while (T->right != NULL) 
         T=T->right; 
     return T; 
} 
/*============================================  
中序遍历下，返回某一结点的后继结点
1）如果结点x有右子结点，则其后继结点为右子树中最小结点。
2）如果结点x没有右子树，且x有一个后继y，则y是x的最低祖先结点
且y的左儿子也是x的祖先。
TREE_SUCCESSOR(x)
     if right[x] != NIL
         return TREE_MINIMUM(right[x])
     y=p[x]
     while y!=NIL and x=right[y] //如果x=left[y]，那么x的后继就是y，跳出while循环，直接返回y即可
         do x <—— y
            y <—— p[y]
     return y
============================================*/   
struct node * tree_successor( struct node *T) 
{ 
     if (T->right!=NULL) 
         return tree_minimum(T->right); 
     struct node *y=T->parent; 
     while (y!=NULL && T == y->right){ 
         T=y; 
         y=y->parent; 
     } 
     return y; 
} 
   
   
/*===========================================
插入操作
思路：从根节点一路往下寻找插入位置，用指针x跟踪这条寻找路径，并用指针y指向x的父结点
TREE_INSERT(T,z)
     y=NIL
     x=root[T]
     while x!= NIL //直到x为空，这个空位置即为需要插入的位置
         do y<—— x
             if key[z]<key[x]
                 then x <—— left[x]
                 else x <—— right[x]
     p[z]=y
     if y=NIL
         then root[T]=z //树T为空时的情况
         else if key[z] < key[y]
             then left[y]=z //小于y的插在左边，大于的插在右边
             else right[y]=z
============================================*/   
void tree_insert(tree *PT, struct node *z) 
{ 
     if (*PT==NULL){ //树为空，则将z作为根结点返回 
         *PT=z; 
         return ; 
     } 
     struct node *y=NULL; 
     struct node *x=*PT; 
     while (x!=NULL){ 
         y=x; 
         if (z->key < x->key) 
             x=x->left; 
         else 
             x=x->right; 
     } 
     z->parent=y; 
     if (z->key < y->key) 
         y->left=z; 
     else 
         y->right=z; 
} 
   
/*===============================================
删除操作
删除操作分为三类情况：
1）若要删除的节点z没有子女，则只需修改z的父节点的该子女为NIL即可
2）若要删除的节点z只有一个子女，则只需将z的这个子女与z的父节点连接起来即可
3）若要删除的节点z有两个子女，则需要先删除z的后继y，再用y的内容替换z的内容。
TREE_DELETE(T,z)
     if left[z]=NIL || right[z]=NIL  //把要删除的节点先保存在y中
         then y <—— z  
         else y <—— TREE_SUCCESSOR(z)
     if left[y]!=NIL                 //将y的非空子女存放在x中
         then X <—— left[y]
         else x <—— right[y]
     if x!=NIL 
         then p[x]=p[y]    //将要删除节点的子女连接到要删除节点的父节点上
     if p[y]=NIL     //如果要删除的节点为根节点
         then root[T] <—— x
         else if y=left[p[y]]//
             then left[p[y]] <—— x
             else right[p[y]] <—— x
     if y!=z  //第三种情况，需要用y的内容替换z的内容
         then key[z] <—— key[y]
             copy y's other data to z
     return y
==============================================*/ 
struct node * tree_delete(tree *PT, struct node *z) 
{ 
     struct node *delnode,*sonnode; 
     if (z->left==NULL || z->right == NULL) //有一个子女或无子女，则要删除的结点结尾z本身 
         delnode=z; 
     else                                 //有两个子女，则要删除的结点为z的后继结点 
         delnode=tree_successor(z); 
   
     if (delnode->left!=NULL) 
         sonnode=delnode->left; 
     else 
         sonnode=delnode->right; 
       
     if (sonnode!=NULL) 
         sonnode->parent=delnode->parent; 
     if (delnode->parent==NULL) 
         *PT=sonnode; 
     else if (delnode->parent->left==delnode) 
         delnode->parent->left=sonnode; 
     else 
         delnode->parent->right=sonnode; 
     if (delnode!=z){ 
         z->key=delnode->key; 
         strcpy (z->data,delnode->data); 
     } 
     return delnode; 
} 
//初始化一棵树 
tree init_tree( int key) 
{    
     struct node * t; 
     t=(tree) malloc ( sizeof ( struct node)); 
     if (t==NULL) 
         return NULL; 
     t->key=key; 
     t->parent=t->left=t->right=NULL; 
     return t; 
} 
//释放资源 
void fini_tree(tree T) 
{ 
     if (T!=NULL){ 
         fini_tree(T->left); 
         fini_tree(T->right); 
         printf ( "free node(%d,%s) now\n" ,T->key,T->data); 
         free (T); 
           
     } 
} 
//测试程序 
int main() 
{ 
     tree myTree=init_tree(256); 
     if (myTree==NULL) 
         return 1; 
     strcpy (myTree->data, "JJDiaries" ); 
     struct record{ 
     int key; 
     char word[WORDLEN]; 
     }; 
     struct record records[]={ {2, "Viidiot" }, 
                      {4, "linux-code" }, 
                      {123, "google" }, 
                      {345, "baidu" }, 
                      {543, "nsfocus" } 
                     }; 
     int i; 
     struct node *tmp; 
     for (i=0;i<5;++i){ 
         tmp=(tree) malloc ( sizeof ( struct node)); 
         if (tmp==NULL) 
             continue ; 
         tmp->key=records[i].key; 
         strcpy (tmp->data,records[i].word); 
         tmp->left=tmp->right=tmp->parent=NULL; 
         tree_insert(&myTree,tmp); 
     } 
     inorder_tree_walk(myTree); 
     struct node *del; 
     del=tree_delete(&myTree,tree_search(myTree,345)); 
     printf ( "Delete node(%d,%s)\n" ,del->key,del->data); 
     free (del); 
     inorder_tree_walk(myTree); 
     fini_tree(myTree); 
} 
================================================== 
//程序运行结果： 
jjdiaries@ubuntu>./search_tree 
key:2   words:Viidiot 
key:4   words:linux-code 
key:123   words:google 
key:256   words:JJDiaries 
key:345   words:baidu 
key:543   words:nsfocus 
Delete node(345,baidu) 
key:2   words:Viidiot 
key:4   words:linux-code 
key:123   words:google 
key:256   words:JJDiaries 
key:543   words:nsfocus 
free node(123,google) now 
free node(4,linux-code) now 
free node(2,Viidiot) now 
free node(543,nsfocus) now 
free node(256,JJDiaries) now 
=================================================== 
只会吃吃睡
关注
专栏目录
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
二叉查找树详细介绍.docx
最新发布
06-27
二叉查找树（BST，Binary Search Tree）是一种特殊类型的二叉树，它的每个节点都遵循以下规则： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点的值都大于该节点的值。 3. 左右子树也...
等价二叉查找树
01-07
练习：等价二叉查找树 实现 Walk 函数。 测试 Walk 函数。 函数 tree.New(k) 用于构造一个随机结构的已排序二叉查找树，它保存了值 k, 2k, 3k, …, 10k。 创建一个新的信道 ch 并且对其进行步进： go Walk(tree.New...
c++实现二叉查找树示例
09-04
二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树，它具有以下特性：对于树中的每个节点，其左子树上的所有节点的值都小于该节点的值，而右子树上的所有节点的值都大于该节点的值。在C++中实现二叉查找树...
二叉查找树，AVL树
01-07
二叉查找树 若它的左子树不为空，则左子树上所有的节点值都小于它的根节点值。 若它的右子树不为空，则右子树上所有的节点值都大于它的根节点值。 它的左右子树也分别可以充当为二叉查找树。 查找的平均复杂度是O...
二叉查找树C++实现
12-23
二叉查找树（Binary Search Tree, BST）是一种基础但非常重要的数据结构，它在计算机科学中扮演着核心角色，尤其是在算法和数据结构的学习中。二叉查找树的主要特性是每个节点的左子树只包含小于该节点的元素，右子...
java二叉查找树的实现代码
08-29
"java二叉查找树的实现代码" 本文主要介绍了java二叉查找树的实现代码，具有一定的参考价值。下面是对标题、描述、标签和部分内容的详细解释和知识点总结。 一、标题和描述 标题中提到了java二叉查找树的实现代码...
c语言实现二叉查找树实例方法
09-04
二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树数据结构，它具有以下特性： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。 2. 节点的键大于其左...
ABR.zip_abr_二叉查找树
09-21
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树上的所有节点的值都小于该节点的值，而右子树上所有节点的值都大于该节点的值。这个特性使得二叉...
bst.zip_bst_二叉查找树
09-23
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值、一个指向左子树的指针和一个指向右子树的指针。在二叉查找树中，对于任意节点，其左子树中的...
Java基于二叉查找树实现排序功能示例
08-29
Java基于二叉查找树实现排序功能示例 本文主要介绍了Java基于二叉查找树实现排序功能的示例，通过实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧。下面将对这些知识点进行详细的解释和分析。 一、...
二叉树和二叉查找树-基本方法.pdf
03-14
二叉树和二叉查找树是数据结构领域中的重要概念，它们在计算机科学中有着广泛的应用，尤其是在数据存储、检索和排序等方面。二叉树是一种每个节点最多有两个子节点的树形结构，分为左子节点和右子节点。二叉查找树...
C++二叉查找树实现过程详解
12-22
什么是二叉查找树 　在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要，这是树。而在树中，二叉树又是当中的贵族。二叉树的一个重要应用是它们在查找中的应用，于是有了二叉查找树。 使二叉树成为一颗...
二叉查找树java
09-02
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树上的所有节点的值都小于该节点的值，而右子树上的所有节点的值都大于该节点的值。这个特性使得...
最优二叉查找树 动态规划法.cpp.rar
10-14
最优二叉查找树（Optimal Binary Search Tree, OBST）是一种高效的检索数据结构，它根据键值分布的不同，自适应地调整树的形态以达到最小化查找时间的目的。在计算机科学中，动态规划（Dynamic Programming, DP）是...
二叉查找树简介
01-03
二叉查找树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，键的值满足以下规则：左子树中的所有键都...
二分搜索树-二叉查找树 .docx
03-13
二分搜索树，又称二叉查找树或有序二叉树，是一种特殊类型的二叉树，其每个节点都遵循以下规则： 1. 节点的左子树仅包含键值小于该节点的节点。 2. 节点的右子树仅包含键值大于该节点的节点。 3. 左右子树同样也是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值