7.1 二叉搜索树

本章问题

1.中序遍历的一般形式是什么?
void InOrder(BiTree T){
	if(T){
		InOrder(T->lchild);//访问左子树
		cout<<T->data<<" ";//输出该节点的数据
		InOrder(T->rchild);//访问右子树
	}
}

先左儿子底部,然后父节点,然后右儿子的左子树底部,

img
先序遍历:GDAFEMHZ
中序遍历:ADEFGHMZ
后序遍历:AEFDHZMG

2.二叉搜索树的特点

特点: 任何一棵二叉树是二叉搜索树,当且仅当其中序遍历序列单调非降。

是一棵空树或具有以下几种性质的树:
1.若左子树不空,则左子树上所有结点的值均小于它的根结点的值
2.若右子树不空,则右子树上所有结点的值均大于它的根结点的值
3.左、右子树也分别为二叉排序树
4.没有权值相等的结点。

3.什么是等价二叉搜索树

条件:中序遍历相同
特点:“上下可变,左右不乱”,即等价二叉搜索树中各节点的垂直高度可能不同,但水平次序完全一致;

4.等价二叉搜索树的操作-旋转调整
操作功能
zig 旋转-顺时针旋转实现等价前提下的局部拓扑调整
zag旋转-逆时针旋转实现等价前提下的局部拓扑调整

在下列图片之中,圆圈表示的节点,矩形表示的子树

zig旋转 -顺时针

旋转过程描述:将x和v作为c的左子树和右孩子,y和z分别作为v的左右子树

image-20210102174606946

zag旋转-逆时针

旋转过程描述:将v和z作为c的左孩子,右子树,x和y分别为作为v的左,右子树

image-20210102174606946

5.中序遍历的直接前驱和直接后继怎么获得

找后继
  1、如有右子女,后继是右子女的最左下节点;
  2、若无右子女,且是父母的左子女,则后继就是父母;
  3、若无右子女,且是父母的右子女,则一直上溯到第一个“左祖先”(定义如前
面)则后继就是这个祖先。若无这样的祖先,说明已经遍历完毕。

找前驱
  1 、如有左子女,前驱是左子女的最右下节点;
  2、若无左子女,且是父母的右子女,则前驱就是父母;
  3、若无左子女,且是父母的左子女,则一直上溯到第一个“右祖先”(定义如前
面)则前驱就是这个祖先。若无这样的祖先,说明已经遍历完毕。

6.如何插入和删除二叉搜索树节点,才能仍然保持中序遍历单调非降

这里有一个简单的想法,删除节点后,该节点的之后的直接后继依次向前移动
最右下插入节点后,依次与其直接前驱比较,然后排序,但是这样是o(n)的复杂度,这样的复杂度即使是线性结构也可以做到
没有什么体现二叉搜索树的优势
那么有什么更优化的算法么?
是有的,那么具体的方法是什么呢
插入
1.查找插入的位置,并且判断是否唯一
2.在找到的位置插入节点
查找步骤具体的描述
从树根出发,逐步的缩小查找范围,直到发现目标(成功)或缩小至空树(失败)
删除
1.查找节点和后继
2.删除节点,将节点后继连接到被删除节点的父节点
查找步骤具体的描述
来自博客:https://blog.csdn.net/hansionz/article/details/81988752
首先要确定删除节点的种类

二叉搜索树的删除大致分为以下类:
1.左子树为空
2.右子树为空
3.左右子树都为空
4.左右子树都不为空

img

对于以上的四类要删除的结点,其实我们还可以在具体一些,将一二三类归在一起,第四类是一类。
下面是两类删除结点的方法

img

7.1.1 二叉搜索树(BST)

特点: 任何一棵二叉树是二叉搜索树,当且仅当其中序遍历序列单调非降。

7.1.1.1 接口列表
操作功能对象
search(const T& e)查找指定元素,返回命中节点,并返回其父亲节点二叉搜索树
insert(const T& e)按照二叉搜索树的结构要求插入指定元素二叉搜索树
remove(const T& e)按照二叉搜索树的结构要求删除元素二叉搜索树
7.1.1.2 二叉搜索树-类模板
#include"binTree.h"
 
//二叉搜索树模板类
template<typename T> class bst :public binTree<T>
{
public:
	binNode<T>* _hot;   //所命中的节点的parent
	binNode<T>* connect34(   //按照3+4结构,联接3个节点及4颗树
		binNode<T>*, binNode<T>*, binNode<T>*,
		binNode<T>*, binNode<T>*, binNode<T>*, binNode<T>*
	);
	binNode<T>* rotateAt(binNode<T>* v);  //对x及父亲、祖父做统一旋转调整
 
public:
	static binNode<T>* & searchIn(binNode<T>* &v, const T& e, binNode<T>* &hot);   //在以v为根的子树中查找关键码e,并将命中节点的parent返回给hot
	virtual binNode<T>* & search(const T& e);   //查找
	virtual binNode<T>* insert(const T& e);     //插入
	virtual bool remove(const T& e);            //删除
 
	static binNode<T>* removeAt(binNode<T>* &x, binNode<T>* &hot);   //删除位置x所指的节点(以判断存在),返回值指向实际被删除者的接替者,hot指向被实际删除者的父亲
};
7.1.1.3 searchIn算法和search接口
template<typename T> binNode<T>* & bst<T>::searchIn(binNode<T>* &v, const T& e, binNode<T>* &hot)
{
	if (!v || (v->data == e))    //若v本身不存在或则直接命中,则返回v
		return v;
	hot = v;
	return searchIn((e < (v->data)) ? v->lc : v->rc, e, hot);
}
 
template<typename T> binNode<T>* & bst<T>::search(const T& e)
{
	return searchIn(_root, e, _hot = nullptr);
}  //返回时,返回值指向命中节点或假想的哨兵节点,hot指向其parent,
7.1.1.4 insert接口
template<typename T> binNode<T>* bst<T>::insert(const T& e)
{
	//首先search查询是否存在或待插入的位置
	binNode<T>* &x = search(e);
	if (x)   //若已经存在则返回
		return x;
	//否则直接插在x上,设置好前后连接关系
	x = new binNode<T>(e, _hot);
	_size++;
	updateHeightAbove(x);
	return x;
}
7.1.1.5 remove和removeAt
template<typename T> bool bst<T>::remove(const T& e)
{
	binNode<T>* succ=nullptr;  //缓存替代者节点   
	//首先搜索是否存在
	binNode<T>* &x = search(e);  //缓存将要被删除的节点
	binNode<T>* temp = x;
	if (!x)   //不存在则直接返回
		return false;
	//case 1 :命中节点至多只有一个孩子,则直接删除,孩子顶上
	if (!(x->lc))  //左孩子为空,则右孩子顶上
	{
		succ = x = x->rc;
	}
	else if(!(x->rc))
	{
		succ = x = x->lc;
	}
	//case 2 :命中节点有两个孩子,则通过succ找直接后继节点
	else
	{
		temp = temp->succ();
		swap(x->data, temp->data);   //交换数据后temp成为实际要删除的点
		binNode<T>* u = temp->parent;
		((u == x) ? u->rc : u->lc) = succ = temp->rc;  //跨过节点succ(只有一种情况是左孩子)
	}	
	_hot = temp->parent;	
	if (succ)
		succ->parent = _hot;
	delete temp;
	_size--;
	updateHeightAbove(_hot);
	return true;
}
 
template<typename T> binNode<T>* bst<T>::removeAt(binNode<T>* &x, binNode<T>* &hot)
{
	binNode<T>* w = x;   //实际被摘除的节点
	binNode<T>* succ = nullptr;  //实际被删除的节点的接替者
	if (!(x->lc))  //左孩子为空,则右孩子顶上
	{
		succ = x = x->rc;
	}
	else if (!(x->rc))//右孩子为空,则左孩子
	{
		succ = x = x->lc;
	}
	//case 2 :命中节点有两个孩子,则通过succ找直接后继节点
	else
	{
		w = w->succ();  //中序遍历的直接后继
		swap(x->data, w->data);  //交换数据
		binNode<T>* u = w->parent;//直接后继的父节点
		((u == x) ? u->rc : u->lc) = succ = w->rc;   //隔离实际删除点
        //若直接后继的父节点为自身,则直接后继父节点的左孩子
	}
	hot = w->parent;
	if (succ) succ->parent = hot;
	delete w;
	return succ;
}
7.1.1.6 connect34 3+4连接
template<typename T> binNode<T>* bst<T>::connect34(              //按照3+4结构,联接3个节点及4颗树
	binNode<T>* a, binNode<T>* b, binNode<T>* c,
	binNode<T>* T0, binNode<T>* T1, binNode<T>* T2, binNode<T>* T3)
{
	a->lc = T0; if (T0) T0->parent = a;
	a->rc = T1; if (T1) T1->parent = a;
	updateHeight(a);   //更新a的高度
	
	c->lc = T2; if (T2) T2->parent = c;
	c->rc = T3; if (T3) T3->parent = c;
	updateHeight(c);
 
	b->lc = a; a- >parent = b;
	b->rc = c; c->parent = b;
	updateHeight(b);
	return b;
}
7.1.1.7 rotateAt 3+4重平衡
template<typename T> binNode<T>* bst<T>::rotateAt(binNode<T>* v)
{
	binNode<T>* p = v->parent; binNode<T>* g = p->parent;   //首先根据v找到p和g节点
	if (g->lc == p)  //失衡是由节点删除导致的(p是g的左孩子)
	{
		if (p->lc == v) //进一步,v是p的左孩子
		{
			p->parent = g->parent;
			return connect34(v, p, g, v->lc, v->rc, p->rc, g->rc);
		}
		else
		{
			v->parent = g->parent;
			return connect34(p, v, g, p->lc, v->lc, v->rc, g->rc);
		}
	}
	else   //失衡是由节点插入造成的
	{
		if (p->rc == v)
		{
			p->parent = g->parent;
			return connect34(g, p, v, g->lc, p->lc, v->lc, v->rc);
		}
		else
		{
			v->parent = g->parent;
			return connect34(g, v, p, g->lc, v->lc, v->rc, p->rc);
		}
	}
}

7.1.2 BST.h

#pragma once
#include "bintree.h"
#include "release.h"
#include <iostream>

template<typename T> class BST:public BinTree<T>{
    protected:
        BinNodePosi(T) _hot;//“命中”节点的父亲
        BinNodePosi(T) connect34(//3+4调整
            BinNodePosi(T),BinNodePosi(T),BinNodePosi(T),
            BinNodePosi(T),BinNodePosi(T),BinNodePosi(T),BinNodePosi(T));
        BinNodePosi(T) rotateAt(BinNodePosi(T) x);//对x及父亲、祖父做统一的旋转调整
    public:
        virtual BinNodePosi(T) &search(const T& e);//查找
        virtual BinNodePosi(T) insert(const T& e);//插入
        virtual bool remove( const T& e);//删除
};


//查找调用的函数
template <typename T>
static BinNodePosi(T) & searchIn( BinNodePosi(T) & v, const T &e, BinNodePosi(T) & hot){
    if( !v || (e == v->data)) return v;
    hot = v;
    return searchIn((( e < v->data ) ? v->lc : v->rc), e , hot );
}
//查找
template <typename T> BinNodePosi(T) & BST<T>::search (const T & e)
{ return searchIn( this->_root, e, _hot = nullptr);}

//插入
template <typename T> BinNodePosi(T) BST<T>::insert (const T & e){
    BinNodePosi(T) & x = search( e ); if(x) return x;
    x = new BinNode<T> ( e, _hot);
    this->_size ++;
    this->updateHeightAbove(x);
    return x;
}

//删除
template <typename T> bool BST<T>::remove( const T& e){
    BinNodePosi(T) & x = search(e); if( !x ) return false;
    removeAt( x, _hot ); this->_size --;
    this->updateHeightAbove( _hot );
    return true;
}
//删除调用的函数
template <typename T>
static BinNodePosi(T) removeAt( BinNodePosi(T)& x , BinNodePosi(T) & hot ){
    BinNodePosi(T) w = x;
    BinNodePosi(T) succ = nullptr;
    if( !HasLChild( *x ))
        succ = x = x->rc;
    else if ( !HasRChild( *x ))
        succ = x = x->lc;
    else{
        w = w->succ();
        T tmp = x->data;
        x->data = w->data;
        w->data = tmp;
        //swap ( x->data, w->data);
        BinNodePosi(T) u = w->parent;
        ((u == x) ? u->rc : u->lc) = succ = w->rc;
    }
    hot = w->parent;
    if( succ ) succ->parent = hot;
    dtl::release( w->data ); dtl::release( w ); return  succ;
}

//3+4连接
template <typename T> BinNodePosi(T) BST<T> :: connect34(
    BinNodePosi(T) a, BinNodePosi(T) b, BinNodePosi(T) c,
    BinNodePosi(T) T0, BinNodePosi(T) T1, BinNodePosi(T) T2, BinNodePosi(T) T3
){
    a->lc = T0; if( T0 ) T0->parent = a;
    a->rc = T1; if( T1 ) T1->parent = a; BinTree<T>::updateHeight(a);
    c->lc = T2; if( T2 ) T2->parent = c;
    c->rc = T3; if( T3 ) T3->parent = c; BinTree<T>::updateHeight(c);
    b->lc = a; a->parent = b;
    b->rc = c; c->parent = b; BinTree<T>::updateHeight(b);
    return b;
}
//3+4重平衡
template <typename T> BinNodePosi(T) BST<T>::rotateAt( BinNodePosi(T) v){
    BinNodePosi(T) p = v->parent; BinNodePosi(T) g = p->parent;
    if( p->data < g->data)/*zig*/
        if( v->data < p->data){/*zig-zig*/
            p->parent = g->parent;
            std::cout << v->data  << std::endl;
            return connect34( v, p, g, v->lc, v->rc, p->rc, g->rc);
        }else{/*zig-zag*/
            v->parent = g->parent;
            return connect34( p, v, g,  p->lc, v->lc, v->rc, g->rc);
        }
    else/*zag*/
        if( v->data >= p->data){/*zag-zag*/
            p->parent = g->parent;
            return connect34(g, p, v, g->lc, p->lc, v->lc, v->rc);
        }else{/*zag-zig*/
            v->parent = g->parent;
            return connect34( g, v, p, g->lc, v->lc, v->rc, p->rc);
        }

}

7.1.3 测试程序

#include "BST.h"
#include <iostream>
using namespace std;
template<typename T> void returnValue(T& a)
{
    cout << "return_value: " << a << endl;
}

int main(int argc,char* argv[])
{
	//构造树
	BST<int> bt_test;
	bt_test.insert(36);
	bt_test.insert(27);
	bt_test.insert(58);
	bt_test.insert(53);
	bt_test.insert(69);
	bt_test.insert(50);
	bt_test.insert(54);

	//测试
	cout << bt_test.search(53)->data << endl;//搜索
	bt_test.insert(59);//插入
	//bt_test.remove(50);//删除
	bt_test.insert(51);

	void (* visit)(int& ) = &returnValue;//中序遍历
	bt_test.traverse(bt_test.root(),visit);
}

/*
53
return_value: 27
return_value: 36
return_value: 50
return_value: 51
return_value: 53
return_value: 54
return_value: 58
return_value: 59
return_value: 69
*/

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Data Structures, Algorithms, and Applications in C++, Second Edition 出版者的话 译者序 前言 第一部分 预备知识 第1章 C++回顾 1.1 引言 1.2 函数与参数 1.2.1 传值参数 1.2.2 模板函数 1.2.3 引用参数 1.2.4 常量引用参数 1.2.5 返回值 1.2.6 重载函数 1.3 异常 1.3.1 抛出异常 1.3.2 处理异常 1.4 动态存储空间分配 1.4.1 操作符new 1.4.2 一维数组 1.4.3 异常处理 1.4.4 操作符delete 1.4.5 二维数组 1.5 自有数据类型 1.5.1 类currency 1.5.2 一种不同的描述方法 1.5.3 操作符重载 1.5.4 友元和保护性类成员 1.5.5 增加#ifndef、#define和#endif语句 1.6 异常类illegalParameterValue 1.7 递归函数 1.7.1 递归的数学函数 1.7.2 归纳 1.7.3 C++递归函数 1.8 标准模板库 1.9 测试与调试 1.9.1 什么是测试 1.9.2 测试数据的设计 1.9.3 调试 1.10 参考及推荐读物 第2章 程序性能分析 2.1 什么是程序性能 2.2 空间复杂度 2.2.1 空间复杂度的组成 2.2.2 举例 2.3 时间复杂度 2.3.1 时间复杂度的组成 2.3.2 操作计数 2.3.3 最好、最坏和平均操作计数 2.3.4 步数 第3章 渐近记法 3.1 引言 3.2 渐近记法 3.2.1 大Ο记法 3.2.2 渐近记法Ω和Θ 3.3 渐近数学(可选) 3.3.1 大O记法 3.3.2 Ω记法 3.3.3 Θ记法 3.3.4 小ο记法 3.3.5 特性 3.4 复杂度分析举例 3.5 实际复杂度 3.6 参考及推荐读物 第4章 性能测量 4.1 引言 4.2 选择实例的大小 4.3 设计测试数据 4.4 实验设计 4.5 高速缓存 4.5.1 简单计算机模型 4.5.2 缓存未命中对运行时间的影响 4.5.3 矩阵乘法 4.6 参考及推荐读物 第二部分 数据结构 第5章 线性表——数组描述 5.1 数据对象和数据结构 5.2 线性表数据结构 5.2.1 抽象数据类型linearList 5.2.2 抽象类linearList 5.3 数组描述 5.3.1 描述 5.3.2 变长一维数组 5.3.3 类arrayList 5.3.4 C++迭代器 5.3.5 arrayList的一个迭代器 5.4 vector的描述 5.5 在一个数组中实现的多重表 5.6 性能测量 5.7 参考及推荐读物 第6章 线性表——链式描述 6.1 单向链表 6.1.1 描述 6.1.2 结构chainNode 6.1.3 类chain 6.1.4 抽象数据类型linearList的扩充 6.1.5 类extendedChain 6.1.6 性能测量 6.2 循环链表和头节点 6.3 双向链表 6.4 链表用到的词汇表 6.5 应用 6.5.1 箱子排序 6.5.2 基数排序 6.5.3 凸包 6.5.4 并查集 第7章 数组和矩阵 7.1 数组 7.1.1 抽象数据类型 7.1.2 C++数组的索引 7.1.3 行主映射和列主映射 7.1.4 用数组的数组来描述 7.1.5 行主描述和列主描述 7.1.6 不规则二维数组 7.2 矩阵 7.2.1 定义和操作 7.2.2 类matrix 7.3 特殊矩阵 7.3.1 定义和应用 7.3.2 对角矩阵 7.3.3 三对角矩阵 7.3.4 三角矩阵 7.3.5 对称矩阵 7.4 稀疏矩阵 7.4.1 基本概念 7.4.2 用单个线性表描述 7.4.3 用多个线性表描述 7.4.4 性能测量 第8章 栈 8.1 定义和应用 8.2 抽象数据类型 8.3 数组描述 8.3.1 作为一个派生类实现 8.3.2 类arrayStack 8.3.3 性能测量 8.4 链表描述 8.4.1 类derivedLinkedStack 8.4.2 类linkedStack 8.4.3 性能测量 8.5 应用 8.5.1 括号匹配 8.5.2 汉诺塔 8.5.3 列车车厢重排 8.5.4 开关盒布线 8.5.5 离线等价类问题 8.5.6 迷宫老鼠 8.6 参考及推荐读物 第9章 队列 9.1 定义和应用 9.2 抽象数据类型 9.3 数组描述 9.3.1 描述 9.3.2 类arrayQueue 9.4 链表描述 9.5 应用 9.5.1 列车车厢重排 9.5.2 电路布线 9.5.3 图元识别 9.5.4 工厂仿真 9.6 参考及推荐读物 第10章
MATPOWER 7.1 是一个用于电力系统分析和仿真的开源软件包。它提供了一套功能强大的工具,用于解决各种电力系统问题,包括潮流计算、潮流追踪、稳定性分析等。 MATPOWER 7.1 在电力系统分析和仿真方面有以下主要特点和功能: 1. 潮流计算:MATPOWER 7.1 可以通过牛顿拉夫逊法或快速潮流算法来计算电力系统的潮流。它可以计算节点电压、有功功率、无功功率和线路潮流等重要参数。 2. 潮流追踪:MATPOWER 7.1 可以进行潮流追踪分析,帮助用户了解电力系统的稳定性和可行性。潮流追踪可以用于研究大规模电力系统的稳态行为,并帮助解决传输网约束和功率平衡问题。 3. 稳定性分析:MATPOWER 7.1 可以进行稳定性分析,包括小扰动稳定性和大扰动稳定性。它可以用于评估电力系统在故障或其他系统操作条件下的稳定性。 4. 扩展功能:MATPOWER 7.1 提供了一套灵活的扩展功能,用户可以基于其核心算法进行自定义开发。它支持用户自定义模型、扩展功能和算法。 MATPOWER 7.1 是一个功能强大、灵活且易于使用的电力系统分析和仿真软件包。它被广泛应用于电力系统规划、运行和市场分析等领域,为用户提供了一种高效、准确且可靠的方法来解决各种电力系统问题。无论是研究人员还是电力系统运营商,都可以从MATPOWER 7.1 提供的功能和特点中获益。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值