2. 程式人生 > >AVL樹詳解與總結

AVL樹詳解與總結

阿新 • • 發佈：2018-12-25

前言：

什麼叫做AVL樹？

    AVL樹的定義：

1、AVL的左右子樹高度之差的絕對值不超過1；

2、樹中的左右子樹都為AVL樹

3、平衡因子只能是（-1、0、1）

    AVL樹的效率

AVL樹的總共節點為N個，他的高度能搞保持在logN,插入、刪除、查詢等操作的時間複雜度也是logN。

    AVL樹的實現：

1、AVL樹的插入：

思路分析：1> 既然是插入就需要先找到插入的位置，使用while迴圈遍歷找到插入位置

                   2> 找到插入位置以後直接插入，然後向上遍歷修改父節點的平衡因子，當修改完以後的平衡因子有等於2或者-2的挑出來，進行樹的旋轉，並且調整平衡因子，使滿足AVL樹的定義。

                   3> 旋轉過程中需要考慮是左旋轉、右旋轉、左右旋轉、還是右左旋轉。左右旋轉簡單，直接呼叫自己編寫的左右旋轉函式即可，只要傳過來的節點記得加上引用就行了，這樣能夠直接連線到旋轉後的子樹。重點在於左右和右左旋轉，我們是否能直接呼叫左旋轉函式和右旋轉函式各一次？答案是否定的，因為在旋轉的過程中，不是在插入的那個位置進行旋轉，而是在中間進行旋轉，這是後父親節點和祖父節點的平衡因子BF就需要自己手動來定義了。以右左旋轉來分析：

如果當前節點的平衡因子為-1，那麼他的parent應該為1，pparent應該為0；

如果當前節點的平衡因子為1，那麼他的parent應該為0，pparent應該為-1；

如果當前節點的平衡因子為0，那麼他的parent應該為0，pparent應該為0；

具體自己下去畫個圖，在插入節點的位置（cur）下面加一個左節點或者右節點，然後分析。

#ifndef __BALANCETREE_H__
#define __BALANCETREE_H__

template<class K,class V>
struct BLNode
{
	K _key;
	V _value;
	BLNode<K, V>* _left;
	BLNode<K, V>* _right;
	BLNode<K, V>* _parent;
	int _bf;

	BLNode(const K& key, const V& value)
		:_key(key)
		, _value(value)
		, _parent(NULL)
		, _left(NULL)
		, _right(NULL)
		, _bf(0)
	{}

};

template<class K,class V>
class BalanceTree
{
	typedef BLNode<K, V> Node;

public:
	BalanceTree()
		:_root(NULL)
	{}

	bool Insert(const K& key, const V& value)
	{
		//先查詢需要插入的位置
		if (_root == NULL)
		{
			_root = new Node(key, value);
			return true;
		}

		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		//找到插入位置以後,確定平衡因子
		Node* ppNode = parent->_parent;
		

		if (parent->_key > key)//找到插入位置以後判斷是在父節點的左邊還是右邊，插入以後先調整平衡因子，向上遍歷，如果本來是-1或者1插入以後為0就不用調整了，因為上一層看到的還是這一層的高度沒有變
		{
			cur = new Node(key, value);
			parent->_left = cur;
			cur->_parent = parent;
			parent->_bf--;
			while (parent)
			{
				if ((parent->_bf == -1 ||parent->_bf ==1)&& parent->_parent != NULL)
				{
					if (parent->_parent->_key >parent->_key)
						parent->_parent->_bf--;
					else if (parent->_parent->_key < parent->_key)
						parent->_parent->_bf++;
					if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
						break;
					cur = parent;
					parent = parent->_parent;
				}
				else
					break;
			}
			
		}

		else if (parent->_key < key)
		{
			cur = new Node(key, value);
			parent->_right = cur;
			cur->_parent = parent;
			parent->_bf++;
			while (parent)
			{
				if ((parent->_bf == 1 ||parent->_bf == -1)&& parent->_parent != NULL)
				{
					if (parent->_parent->_key >parent->_key)
						parent->_parent->_bf--;
					else if (parent->_parent->_key < parent->_key)
						parent->_parent->_bf++;
					if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
						break;
					cur = parent;
					parent = parent->_parent;
				}
				else
					break;
			}
		}

		//根據平衡因子的變動，開始調整當前的樹，因為剛剛是平衡因子不符合的時候跳出來的
		ppNode = parent->_parent;
		Node* pppNode = NULL;
		if (ppNode!=NULL)
			pppNode = ppNode->_parent;
		if (ppNode && (ppNode->_bf == 2 || ppNode->_bf == -2))
		{
			//左旋
			if (parent == ppNode->_right && parent->_right == cur)
			{
				RotateL(ppNode);
			}

			//右旋
			else if (ppNode->_left == parent && parent->_left == cur)
			{
				RotateR(ppNode);
			}

			//左右雙旋
			else if (ppNode->_left == parent &&parent->_right == cur)
			{
				int bf = cur->_bf;
				Node* pNode = ppNode;
				Node* pLeftNode = parent;
				RotateL(parent);//先左旋，再連結
				ppNode->_left = parent;
				RotateR(ppNode);

				if (bf == 0)
				{
					pNode->_bf = 0;
					pLeftNode->_bf = 0;
				}
				else if (bf == -1)
				{
					pNode->_bf = 1;
					pLeftNode->_bf = 0;
				}
				else if (bf == 1)
				{
					pNode->_bf = 0;
					pLeftNode->_bf = -1;
				}
			}

			//右左雙旋
			else if (ppNode->_right == parent &&parent->_left == cur)
			{
				int bf = cur->_bf;
				Node* pNode = ppNode;
				Node* pRightNode = parent;
				RotateR(parent);
				ppNode->_right = parent;
				RotateL(ppNode);

				if (bf == 0)
				{
					pNode->_bf = 0;
					pRightNode->_bf = 0;
				}
				else if (bf == -1)
				{
					pNode->_bf = 0;
					pRightNode->_bf = 1;
				}
				else if (bf == 1)
				{
					pNode->_bf = -1;
					pRightNode->_bf = 0;
				}
			}

			if (pppNode == NULL)
			{
				_root = ppNode;
			}
			else
			{
				if (pppNode->_key > ppNode->_key)
					pppNode->_left = ppNode;
				else if (pppNode->_key < ppNode->_key)
					pppNode->_right = ppNode;
			}

		}
	}


	size_t Height()
	{
		return _Height(_root);
	}
	
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

protected:
	size_t _Height(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Height(root->_left) > _Height(root->_right) ? _Height(root->_left) + 1 : _Height(root->_right) + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == NULL)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	void rotateL(Node*& parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_parent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		parent->_right = subRL;
		if (subRL != NULL)
			subRL->_parent = parent;

		parent->_bf = 0;
		subR->_bf = 0;

		parent = subR;
	}

	void RotateL(Node*& parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL != NULL)
			subRL->_parent = parent;

		subR->_parent = parent->_parent;
		parent->_parent = subR;
		subR->_left = parent;

		parent->_bf = 0;
		subR->_bf = 0;

		parent = subR;
	}

	void RotateR(Node*& parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR != NULL)
			subLR->_parent = parent;

		subL->_parent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		parent->_bf = 0;
		subL->_bf = 0;

		parent = subL;
	}



protected:
	Node* _root;
};




void test()
{
	BalanceTree<int, int> bt;
	int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		bt.Insert(arr[i], i);
	}

	bt.InOrder();
	cout << bt.Height() << endl;

	BalanceTree<int, int> bt1;
	int arr1[] = { 4,2,6,1,3,5,15,7,16,14 };
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		bt1.Insert(arr1[i], i);
	}

	bt1.InOrder();
	cout << bt1.Height() << endl;
}


#endif //__BALANCETREE_H__

2、AVL樹的刪除：

    刪除相對而言跟插入差不多，都是需要理解過程的，對於刪除，我們只需要先找到要刪除的位置，然後分為三種情況：

1.左為空-------->直接連線到父節點上，只是需要判斷連線到父節點的左還是右上

2.右為空-------->同上

3.左右都不為空：找到右邊子樹的最左節點，（這裡還分為兩種情況：沒有左子節點和有）這裡只分析有左子節點的了，一直往左遍歷找到左子節點，交換左子節點和要刪除的節點，然後將parent->left連到左子節點的右就行了，最後一步就是調節平衡因子了，從當前節點開始向上修改平衡因子，以及判斷平衡因子有沒有為2或者-2的情況，然後跟上面一樣做處理。

相關推薦

AVL樹詳解與總結

前言： 什麼叫做AVL樹？     AVL樹的定義： 1、AVL的左右子樹高度之差的絕對值不超過1； 2、樹中的左右子樹都為AVL樹 3、平衡因子只能是（-1、0、1）     AVL樹的效率 AVL樹的總共節點為N個，他的高度能搞保持在logN,插入、刪除、查詢等操作的時

AVL樹(二叉平衡樹)詳解與實現

AVL樹概念 前面學習二叉查詢樹和二叉樹的各種遍歷，但是其查詢效率不穩定(斜樹)，而二叉平衡樹的用途更多。查詢相比穩定很多。(歡迎關注資料結構專欄) AVL樹是帶有平衡條件的二叉查詢樹。這個平衡條件必須要容易保持。而且要保證它的深度是O(logN). AVL的條件是左右樹的高度差（平衡因子）不大於1；並且它

二叉樹之一BST樹，AVL樹詳解及B樹和紅黑樹原理分析

BST樹，AVL樹詳解及B樹和紅黑樹原理分析 網際網路面試中樹尤其是BST，AVL是提問的重點也是難點，甚至B樹乃至高階資料結構紅黑樹都是提問的重點，像阿里雲面試就曾經問過map實現機制（紅黑樹）及其原理，這裡我們要做到對BST/AVL完全熟悉能給出全部程式碼實現，紅黑樹、

資料結構之：AVL樹詳解及C++模板實現

AVL樹簡介AVL樹的名字來源於它的發明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL樹是最先發明的自平衡二叉查詢樹（Self-Balancing Binary Search Tree,簡稱平衡二叉樹）。一棵AVL樹有如下必要條件：條件一：它必

【資料結構】AVL樹詳解

1.什麼是AVL樹 AVL樹又稱平衡二叉搜尋樹，它能保證二叉樹高度相對平衡，儘量降低二叉樹的高度，提高搜尋效率。單純的二叉搜尋樹在最壞的情況下插入查詢刪除等操作時間複雜度會是O(N), 例如： 所以，AVL樹就能避免這種情況，使得增刪查改的時間複雜度為O(lgN). （p

AVL樹詳解（附c++程式碼）

1.AVL樹簡介 AVL樹是一種自平衡的二叉搜尋樹，一顆典型的二叉搜尋樹（Binary Search Tree，以下簡稱BST）應該滿足Key(left) < Key(root) < Key(right)。即左子樹上所有的鍵值都小於根節點的鍵值，根節點的鍵值小於

AVL樹演算法介紹與總結

在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。在AVL樹中任何節點的兩個子樹的高度最大差別為一，所以它也被稱為高度平衡樹。查詢、插入和刪除在平均和最壞情況下都是O（log n）。增加和刪除可能需要通過一次或多次樹旋轉來重新平衡這個樹。AVL樹得名於它的發明者 G.M. Adelson-Velsky 和

dhcpcd引數詳解與總結

SYNOPSIS      dhcpcd [-bdeknpqABDEGKLTV] [-c, --script script] [-f, --config file]             [-h, --hostname hostname] [-i, --vendorcla

ActiveMQ基本詳解與總結& 訊息佇列-推/拉模式學習 & ActiveMQ及JMS學習

ActiveMQ基本詳解與總結 MQ簡介： 　　MQ全稱為Message Queue, 訊息佇列（MQ）是一種應用程式對應用程式的通訊方法。應用程式通過寫和檢索出入列隊的針對應用程式的資料（訊息）來通訊，而無需專用連線來連結它們。訊息傳遞指

數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java）

啟示 dpa con 技術分享 節點數 src 通知 一點 this 　　最終還是決定把紅黑樹的篇章一分為二，插入操作一篇，刪除操作一篇，因為合在一起寫篇幅實在太長了，寫起來都覺得累，何況是閱讀並理解的讀者。 　　　　　　紅黑樹刪除操作請參考 數據結構 - 紅黑樹（Red

數據結構 - 紅黑樹（Red Black Tree）刪除詳解與實現（Java）

replace ati 轉載 之前 9.png one com 四種 簡單 　　本篇要講的就是紅黑樹的刪除操作 　　　　　　紅黑樹插入操作請參考 數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java） 　　紅黑樹的刪除是紅黑樹操作中比較麻煩且比較有意

線段樹詳解（單點更新與成段更新\區間更新操作）

      本文純屬原創，轉載請註明出處，謝謝。         距離第一次接觸線段樹已經一年多了，再次參加ACM暑假集訓，這一次輪到我們這些老傢伙們給學弟學妹們講解線段樹了，所以就自己重新把自己做過的題目看

紅黑樹（Red Black Tree）刪除詳解與實現（Java）

　　本篇要講的就是紅黑樹的刪除操作 　　紅黑樹的刪除是紅黑樹操作中比較麻煩且比較有意思的一部分。 　　在此之前，重申一遍紅黑樹的五個定義： 1. 紅黑樹的節點要不是黑色的要不是紅色的 　　　　2. 紅黑樹的根節點一定是黑色的 　　　　3. 紅黑樹的所有葉子節點都是黑色的（注意：紅黑樹的葉子節點指Nil節點

【資料結構】B樹、B+樹與B*樹詳解

B樹 1.B樹的定義 B樹（B-tree）是對2-3樹資料結構的擴充套件，又稱為多路平衡查詢樹，它的一個節點可以擁有多於2個子節點的二叉查詢樹。與自平衡二叉查詢樹不同， B樹是一種自平衡樹資料結構，可以保持資料排序，它能夠儲存資料、對其進行排序並允許以

B樹（B-Tree）與Ｂ+樹詳解

注意：首先需要說明的一點是：B-樹就是B樹，沒有所謂的B減樹 引言 　　我們都知道二叉查詢樹的查詢的時間複雜度是Ｏ(log N)，其查詢效率已經足夠高了，那為什麼還有Ｂ樹和Ｂ＋樹的出現呢？難道它兩的時間複雜度比二叉查詢樹還小嗎？  　　答案當然不是，Ｂ樹和Ｂ＋樹的出現是因

B樹詳解 資料與結構

然後我們發現有一個節點只是包含一個元素，不符合5階B樹的性質，又因為{6}的左右兄弟節點都是剛剛脫貧，又不能向父親節點借，那麼怎麼辦嘞.....只好進行合併操作了，那麼我們就將含有{1,2}元素的節點和含有{6}的節點合併成一個節點，那麼我們就會得到這樣的B樹：這樣又出現了一個節點7，他的相鄰節點也不是十分富

樹堆（Treap）圖文詳解與實現

1.Treap的定義 樹堆（Treap）是二叉排序樹（Binary Sort Tree）與堆（Heap）結合產生的一種擁有堆性質的二叉排序樹。 但是這裡要注意兩點，第一點是Treap和二叉堆有一點不同，就是二叉堆必須是完全二叉樹，而Treap並不一定是；第二

stl map底層之紅黑樹插入步驟詳解與程式碼實現

本篇文章並沒有詳細的講解紅黑樹各方面的知識，只是以圖形的方式對紅黑樹插入節點需要進行調整的過程進行的解釋。 最近在看stl原始碼剖析，看到map底層紅黑樹的實現。為了加深對於紅黑樹的理解就自己動手寫了紅黑樹插入的實現。關於紅黑樹插入節點後破壞紅黑樹性質的幾種情況，可以在網

線段樹詳解 （原理，實現與應用）

比如，以左側的的藍色為例，若該節點是其父節點的右子節點，就證明它右側的那個紫色節點不會留下，會被其父替代，所以沒必要在這一步計算，若該節點是其父節點的左子節點，就證明它右側的那個紫色節點會留在這一層，所以必須在此刻計算，否則以後都不會再計算這個節點了。這樣逐層上去，容易發現，對於左側的藍色節點來說，只要它是左

線段樹 資料結構詳解與模板

線段樹是一個查詢和修改複雜度都為log(n)的資料結構。主要用於陣列的單點修改&&單點查詢&&區間求和&&區間修改. 另外一個擁有類似功能的是樹狀陣列，但是樹狀陣列最常用的是單點修改&&區間求和. 線