超详细最全数据结构个人笔记【平衡二叉树】

最新推荐文章于 2024-07-25 15:31:50 发布
最新推荐文章于 2024-07-25 15:31:50 发布
阅读量304 收藏 3
点赞数 4
分类专栏： 超详细最全数据结构个人笔记 文章标签： 数据结构 笔记 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rain_wuming/article/details/139308142
版权

1.平衡二叉树概述

​ 平衡二叉树又称AVL树，它或者是一棵空树，或者是具有以下特性的二叉排序树（BST）

(1) 它的左子树或者右子树都是平衡二叉树

(2) 左子树和右子树的深度之差的绝对值不超过1(1,-0,-1)

若将二叉树上的节点的平衡因子定义为该节点的左子树的深度减去它右子树的深度，所以平衡二叉树所有节点的平衡因子只可能是-1，0，1

只有二叉树上有一个节点的平衡因子的绝对值大于1，则该二叉树不平衡。

2.建立平衡二叉树

​ 建立平衡二叉树过程中，把不平衡的树转为平衡树的四种方式：

​ (1)单向右旋平衡处理 SingleRotateWithRight

​ 在这里插入图片描述

(2)单向左旋平衡处理，SingleRotateWithLeft

在这里插入图片描述

(3)双向旋转(先左后右)平衡处理 DoubleRotateLeftRight

在这里插入图片描述

(4)双向旋转(先右后左)平衡处理DoubleRotateRightLeft

在这里插入图片描述

实现代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_NODE(a,b) ((a) > (b) ? (a) : (b))

typedef char dataType;

typedef struct AVLNode
{
    dataType data;
    struct AVLNode *lchild, *rchild;
    int height; // 树的高度，高度大于1需要旋转
}AVLNode;

#define NODE AVLNode
#include "drawtree.h"

// 返回每个节点的高度
int Height(AVLNode *root)
{
    if(root == NULL)
        return 0;

    return root->height;
}

// 单向右旋
AVLNode *SingleRotateWithRight(AVLNode *k2)
{
    AVLNode *k1 = k2->lchild;
    k2->lchild = k1->rchild;
    k1->rchild = k2;
    // 更新K1，k2高度
    k2->height = MAX_NODE(Height(k2->lchild),Height(k2->rchild))+1;
    k1->height = MAX_NODE(Height(k1->lchild),Height(k1->rchild))+1;
    return k1;
}

// 单向左旋
AVLNode *SingleRotateWithLeft(AVLNode *k2)
{
    AVLNode *k1 = k2->rchild;
    k2->rchild = k1->lchild;
    k1->lchild = k2;
    // 更新K1，k2高度
    k2->height = MAX_NODE(Height(k2->lchild),Height(k2->rchild))+1;
    k1->height = MAX_NODE(Height(k1->lchild),Height(k1->rchild))+1;
    return k1;
}

// 双向旋转，先左旋后右旋
AVLNode *DoubleRotateLeftRight(AVLNode *k3)
{
    k3->lchild = SingleRotateWithLeft(k3->lchild);
    return SingleRotateWithRight(k3);
}

// 双向旋转，先右旋后左旋
AVLNode *DoubleRotateRightLeft(AVLNode *k3)
{
    k3->rchild = SingleRotateWithRight(k3->rchild);
    return SingleRotateWithLeft(k3);
}

// 插入节点
AVLNode *insert_node(AVLNode *root, dataType data)
{
    if(root == NULL)// 从无到有
    {
        root = malloc(sizeof(AVLNode));
        if(root == NULL)
            return NULL;

        root->height = 1;
        root->data = data;
        root->lchild = NULL;
        root->rchild = NULL;
        return root;
    }

    if(data > root->data) // 节点插入到右子树
    {
        // 递归找位置
        root->rchild = insert_node(root->rchild,data);
        // 右子树高度加1
        root->height = MAX_NODE(Height(root->lchild),Height(root->rchild))+1;

        // 需要旋转
        if(Height(root->rchild) - Height(root->lchild) > 1)
        {
            if(data > root->rchild->data) // 右插
            {
                // 单向左旋
                root = SingleRotateWithLeft(root);
            }
            else // 左插
            {
                // 先右后左
                root = DoubleRotateRightLeft(root);
            }
        }
    }
    else if(data < root->data)
    {
        // 找位置
        root->lchild = insert_node(root->lchild, data);

        // 更新树的高度+1
        root->height = MAX_NODE(Height(root->lchild),Height(root->rchild))+1;

        if(Height(root->lchild) - Height(root->rchild) > 1)// 左深
        {
            if(data > root->lchild->data) // 右插
            {
                // 先左旋后右旋
                root = DoubleRotateLeftRight(root);
            }
            else if(data < root->lchild->data) // 左插
            {
                // 单向右旋
                root = SingleRotateWithRight(root);
            }
        }

    }

    return root;
}

int main(int argc, char const *argv[])
{
    AVLNode *root = NULL;
    while(1)
    {
        dataType data = getchar();
        if(data == '#')
            break;
        root = insert_node(root,data);
    }

    // 显示
    draw(root);

    return 0;
}

drawtree.h

///
//
//  Copyright(C), 2013-2017, GEC Tech. Co., Ltd.
//
//  文件: lab/tree/headers/drawtree.h
//  日期: 2017-9
//  描述: 使用C语言写一页webpage展示二叉树
//
///

#ifndef _DRAWTREE_H_
#define _DRAWTREE_H_

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 公共头文件 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//#include <unistd.h>
#include <string.h>
//#include <strings.h>
#include <time.h>
#include <errno.h>

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

// #include <sys/ipc.h>
// #include <sys/sem.h>
// #include <sys/shm.h>
// #include <sys/msg.h>
// #include <semaphore.h>
#include <fcntl.h>

//#include <pthread.h>
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 公共头文件 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */

#define MAX(a, b) ({ \
		typeof(a) _a = a; \
		typeof(b) _b = b; \
		(void)(&_a == &_b);\
		_a > _b? _a : _b; \
		})


/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 默认二叉树节点 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
typedef struct _tree_node
{
	int data;
	struct _tree_node *lchild;
	struct _tree_node *rchild;

#ifdef AVL
	int height;
#endif

#ifdef RB
	struct _tree_node *parent;
	int color;
#endif
}_treenode, *_linktree;
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 默认二叉树节点 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */


/* ↓↓↓↓↓ 用户指定二叉树节点 ↓↓↓↓↓ */
#ifndef NODE
#define NODE _treenode
#endif
/* ↑↑↑↑↑ 用户指定二叉树节点 ↑↑↑↑↑ */



/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */

#ifndef QUEUE_NODE_DATATYPE
#define QUEUE_NODE_DATATYPE NODE *
#endif

typedef QUEUE_NODE_DATATYPE qn_datatype;

struct _queue_node
{
	qn_datatype data;
	struct _queue_node *next;

};

typedef struct
{
	struct _queue_node *front;
	struct _queue_node *rear;
#ifdef QUEUE_SIZE
	int size;
#endif
}_queuenode, *_linkqueue;


static _linkqueue init_queue(void)
{
    _linkqueue q = (_linkqueue)malloc(sizeof(_queuenode));
	q->front = q->rear =
		(struct _queue_node *)malloc(sizeof(struct _queue_node));
	q->rear->next = NULL;

	return q;
}

static bool is_empty_q(_linkqueue q)
{
	return (q->front == q->rear);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static bool out_queue(_linkqueue q, qn_datatype *pdata)
{
	if(is_empty_q(q))
		return false;

	struct _queue_node *p = q->front;

	q->front = q->front->next;
	free(p);
	*pdata = q->front->data;

	return true;
}

static bool en_queue(_linkqueue q, qn_datatype data)
{
	struct _queue_node *pnew;
	pnew = (struct _queue_node *)malloc(sizeof(struct _queue_node));
	if(pnew == NULL)
		return false;

	pnew->data = data;
	pnew->next = NULL;

	q->rear->next = pnew;
	q->rear = pnew;

	return true;
}

#ifdef QUEUE_SIZE
int queue_size(_linkqueue *q)
{
	return q->size;
}
#endif
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */


static void pre_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	handler(root);
	pre_travel(root->lchild, handler);
	pre_travel(root->rchild, handler);
}

static void mid_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	mid_travel(root->lchild, handler);
	handler(root);
	mid_travel(root->rchild, handler);
}

static void post_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

	post_travel(root->lchild, handler);
	post_travel(root->rchild, handler);
	handler(root);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void level_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

    _linkqueue q;
	q = init_queue();

	en_queue(q, root);

    NODE *tmp;
	while(1)
	{
		if(!out_queue(q, &tmp))
			break;

		handler(tmp);

		if(tmp->lchild != NULL)
			en_queue(q, tmp->lchild);
		if(tmp->rchild != NULL)
			en_queue(q, tmp->rchild);
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static char page_begin[] = "<html><head><title>tree map"
                           "</title></head><body>"
			   "<table border=0 cellspacing"
                           "=0 cellpadding=0>";
static char line_begin[] = "<tr>";
static char line_end  [] = "</tr>";
static char space     [] = "<td>&nbsp;</td>";
static char underline [] = "<td style=\"border-bottom:"
	 		   "1px solid #58CB64\">&nbsp;"
                           "</td>";

#ifdef RB
static char data_begin_red[] = "<td bgcolor=\"#FF0000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\">";
static char data_begin_blk[] = "<td bgcolor=\"#000000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\"><font color"
				"=\"#FFFFFF\">";
static char data_end_red[] = "</td>";
static char data_end_blk[] = "</font></td>";
#else
static char data_begin[] = "<td style=\"border:1px sol"
                           "id #58CB64;background-colo"
                           "r:#DDF1D8;PADDING:2px;\" t"
                           "itle=\"level: 1\">";
static char data_end  [] = "</td>";
#endif

static char page_end  [] = "</table></body></html>";

#define MAX_NODES_NUMBER 100
#define FILENAME 32

static int central_order[MAX_NODES_NUMBER];

static void putunderline(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, underline, strlen(underline));
	}
}


static void putspace(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, space, strlen(space));
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#ifdef RB
static void putdata(int fd, NODE * p)
{
	char s[50];
	bzero(s, 50);

	snprintf(s, 50, "%d", p->data);

	switch(p->color)
	{
	case RED:
		write(fd, data_begin_red, strlen(data_begin_red));
		write(fd, s, strlen(s));
		write(fd, data_end_red, strlen(data_end_red));
		break;
	case BLACK:
		write(fd, data_begin_blk, strlen(data_begin_blk));
		write(fd, s, strlen(s));
		write(fd, data_end_blk, strlen(data_end_blk));
	}
}
#else
static void putdata(int fd, int data)
{
	char s[50] = {0};
	//bzero(s, 50);

	snprintf(s, 50, "%c", data);
	write(fd, data_begin, strlen(data_begin));
	write(fd, s, strlen(s));
	write(fd, data_end, strlen(data_end));
}
#endif

static int Index = 0;
static void create_index(NODE * root)
{
	if(Index >= MAX_NODES_NUMBER-1)
		return;

	central_order[Index++] = root->data;
}


static int get_index(int data)
{
	int i;
	for(i=0; i<100; i++)
	{
		if(central_order[i] == data)
			return i;
	}
	return -1;
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void data_leftside(int fd, NODE * root, int spaces)
{
	if(root == NULL)
		return;

	int s_line=0;

	if(root->lchild != NULL)
	{
		s_line = get_index(root->data)-
			 get_index(root->lchild->data)-1;
	}
	putspace(fd, spaces-s_line);
	putunderline(fd, s_line);
}


static int data_rightside(int fd, NODE * root)
{
	if(root == NULL)
		return 0;

	int s_line=0;

	if(root->rchild != NULL)
	{
		s_line = get_index(root->rchild->data)-
			 get_index(root->data)-1;
	}

	putunderline(fd, s_line);
	return s_line;
}


static void start_page(int fd)
{
	write(fd, page_begin, strlen(page_begin));
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void end_page(int fd)
{
	write(fd, page_end, strlen(page_end));
}

// 显示
static void draw(NODE * root)
{
	if(root == NULL)
		return;

	time_t t;
	time(&t);
	static char filename[FILENAME] = {0};
	//bzero(filename, FILENAME);
	snprintf(filename, FILENAME, "%u.html", (unsigned)t);
	int fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, 0644);
	if(fd == -1)
	{
		perror("open() failed");
		exit(1);
	}

	Index = 0;
	mid_travel(root, create_index);

    _linkqueue q = init_queue();

	NODE * tmp = root;
	int ndata = 1;

	start_page(fd);
	while(1)
	{
		write(fd, line_begin, strlen(line_begin));

		int i, n = 0;
		int nextline = 0;
		for(i=0; i<ndata; i++)
		{
			int index = get_index(tmp->data);

			data_leftside(fd, tmp, index-n);

			#ifdef RB
			putdata(fd, tmp);
			#else
			// 如果想要在网页上显示字符，将putdata函数里面的sprintf()的%d换成%c
			putdata(fd, tmp->data);
			#endif
			int rightline = data_rightside(fd, tmp);

			if(tmp->lchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->lchild);
			}
			if(tmp->rchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->rchild);
			}
			if(!out_queue(q, &tmp))
				return;

			n = index + rightline;
			n++;
		}
		write(fd, line_end, strlen(line_end));
		ndata = nextline;
	}
	end_page(fd);
	close(fd);
}
#endif
从此不叫無名
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
超详细的数据结构知识点-个人笔记
05-07
这篇超详细的“数据结构知识点-个人笔记”涵盖了数据结构的基础理论和实际应用，是初学者入门的理想资源。 笔记首先介绍了数据结构的基本概念，包括数组、链表、栈和队列等基本类型。数组是最基础的数据结构，它是...
数据结构详细笔记——二叉树
weixin_44732078的博客
11-01 443
二叉树的基本概念二叉树是n（n>=0）个结点的有限集合①或者为空的二叉树，即n=0②或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成，左子树和右子树又分别是一颗二叉树特点：1、每一个结点至多只有两棵子树2、左右子树不能颠倒（二叉树是有序树）注意区别：度为2的有序树与二叉树的区别度为2的树：肯定是非空树，所有结点的度
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
王道数据结构笔记02-平衡二叉树/平衡树/AVL树
testleaf.cn
08-31 2225
平衡二叉树（BalancedBinaryTree），简称平衡树（AVL树），树上任一结点的左子树和右子树的高度之差不超过1。简称AVL命名来源于其发明者G.M.Adelson-Velsky和E.M.Landis，不要和平均查找长度ASL混淆了。结点的平衡因子=左子树高-右子树高。平衡二叉树结点的平衡因子的值只可能是-1、0或1。只要有任一结点的平衡因子绝对值大于1，就不是平衡二叉树。intkey;//数据域intbalance;.......................................
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构（王道笔记）——二叉树
lranqi的博客
05-24 1226
王道二叉树相关概念，二叉树、满二叉树、完全二叉树、二叉排序树、平衡二叉树、扩充二叉树。二叉树的层序遍历、前序遍历、中序遍历、后序遍历。从前序与中序遍历序列构造二叉树，从中序与后序遍历序列构造二叉树。线索二叉树，加快查找结点前驱和后继的速度。
Java数据结构和算法详细笔记
07-09
在计算机科学中，数据结构和算法是核心概念，它们对于编写高效、优化的代码至关重要。Java作为面向对象的编程语言，支持多种数据结构和算法的实现。 线性结构是数据结构的一种，它的特点是数据元素之间存在一对一的...
数据结构高分笔记part1
10-30
树包括二叉树、平衡树（如AVL树和红黑树）、堆（最大堆和最小堆）等。图则可能包括图的表示（邻接矩阵和邻接表），以及图的遍历算法（深度优先搜索和广度优先搜索）。 4. **排序与查找**：排序算法如冒泡排序、插入...
数据结构学习笔记.zip
06-17
数组是最基础的数据结构，它提供了随机访问元素的能力，但插入和删除操作通常较慢。链表则通过指针连接元素，使得插入和删除操作更为灵活，但访问速度相对较慢。栈是后进先出（LIFO）的数据结构，常用于表达式求值和...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 901
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1287
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1361
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 425
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
【数据结构】单链表&带头双向循环链表的实现
t5y22的博客
07-24 445
链表
数据结构-C语言-排序（4）
h_number_1的博客
07-23 1197
归并排序、计数排序
2024.7.24 作业
qq_64434282的博客
07-24 1981
【代码】2024.7.24 作业。
数据结构和算法入门
最新发布
weixin_67852890的博客
07-25 1493
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
dsp c6657 SYS/BIOS学习笔记
小pp的博客
07-25 221
SYS/BIOS是一种用于TI的DSP平台的嵌入式操作系统（RTOS）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值