參考原文(原文作者：Timothy J. Rolfe )：http://penguin.ewu.edu/~trolfe/DSWpaper/

DSW演算法用於平衡BST（二叉查詢樹），而且平衡後的二叉樹是一顆完全二叉樹(complete binary tree-即葉子節點頂多位於最後兩層，而且從左到右排列)。該演算法的優點是：無須開闢額外的空間用於儲存節點，時間複雜度線性O(n)。該演算法分兩個階段進行：首先將任意一顆二叉樹通過一序列右旋轉(right rotations)轉換成一個單鏈結構（稱作vine，即每個非葉子節點只有右孩子，沒有左孩子）；然後在第二階段中對單鏈結構通過幾個批次左旋轉（left rotations）生成一顆完全二叉樹。為了生成完全二叉樹，在第二階段的左旋轉中，首先只將一部分節點左旋轉（這算是第一個批次左旋轉），然後依次對剩下的單鏈節點做多批次左旋轉（每個批次的左旋轉所針對的節點位於剩下的vine上依次相隔的一個節點），直到某個批次的左旋轉次數不大於1。

實現程式碼：

import java.util.ArrayList; import java.util.LinkedList; import java.util.List; /** * DSW(Day-Stout-Warren) algorithm to balance a binary search tree * * @author ljs * see also: http://penguin.ewu.edu/~trolfe/DSWpaper/ */ public class DSW_BST { static class Node{ int val; Node left; Node right; public Node(int val){ this.val = val; } public String toString(){ return String.valueOf(val); } } //the number of nodes in this tree private int n; //phase one: right rotate the input tree into a vine //return the root of the elongated tree; and compute the nodes count private Node createVine(Node root){ Node pseudoRoot = new Node(Integer.MIN_VALUE); Node grandpar = pseudoRoot; Node tmp = root; int nodeCnt = 0; while(tmp != null){ if(tmp.left != null){ //right rotation for node tmp.left Node child = tmp.left; //postpone grandpar.right update until tmp.left is null //grandpar.right = child; tmp.left = child.right; child.right = tmp; tmp = child; }else{ grandpar.right = tmp; //move down grandpar = tmp; tmp = tmp.right; nodeCnt++; } } root = pseudoRoot.right; n = nodeCnt; return root; } //phase two: balance the vine into a complete BST //return the new root private Node createCompleteBST(Node root,int n){ //caculate m = 2^log(n+1) - 1; int tmp = n + 1; int m = 1; tmp>>=1; while(tmp != 0){ m<<=1; tmp>>=1; } m--; int leftRotates = n - m; root = leftRotate(root,leftRotates); while(m>1){ m>>=1; //m = m/2 root = leftRotate(root,m); } return root; } //return the new root after a number of left rotations private Node leftRotate(Node root,int leftRotates){ Node pseudoRoot = new Node(Integer.MIN_VALUE); Node grandpar = pseudoRoot; Node tmp = root; int rotations = 1; while(tmp != null && tmp.right != null && rotations<=leftRotates){ //left rotate for node tmp.right Node child = tmp.right; grandpar.right = child; tmp.right = child.left; child.left = tmp; tmp = child.right; grandpar = child; rotations++; } return pseudoRoot.right; } //return the new root public Node dswBalance(Node root){ root = createVine(root); n = this.getNumberOfNodes(); root = createCompleteBST(root,n); return root; } public int getNumberOfNodes() { return n; } //utility method for test purpose public static void recursiveInOrderTraverse(Node root){ if(root == null)return; recursiveInOrderTraverse(root.left); System.out.format(" %d", root.val); recursiveInOrderTraverse(root.right); } //utility method for test purpose public static void levelTraverseCompleteBST(Node root,int n){ LinkedList<Node> queue = new LinkedList<Node>(); List<List<Node>> nodesList = new ArrayList<List<Node>>(); queue.add(root); int level=0; int levelNodes = 1; int nextLevelNodes = 0; //System.out.format("%nLevel %d:",level); List<Node> levelNodesList = new ArrayList<Node>(); while(!queue.isEmpty()) { Node node = queue.remove(); if(levelNodes==0){ //save the prev. level's nodes list nodesList.add(levelNodesList); levelNodesList = new ArrayList<Node>(); level++; //System.out.format("%nLevel %d:",level); levelNodes = nextLevelNodes; nextLevelNodes = 0; } levelNodesList.add(node); //System.out.format(" %d", node.val); if(node.left != null){ queue.add(node.left); nextLevelNodes++; } if(node.right != null) { queue.add(node.right); nextLevelNodes++; } levelNodes--; } //save the last level's nodes list nodesList.add(levelNodesList); int maxLevel = nodesList.size()-1; //==level //expected max level for a complete binary tree = ceiling(log(n+1) - 1) int expectedMaxLevel = (int)Math.ceil(Math.log1p(n) / Math.log(2)) - 1; System.out.format("%n[expected max level: %d; real max level: %d]%n", expectedMaxLevel,maxLevel); //Note: expected max columns: 2^(level+1) - 1 int cols = 1; for(int i=0;i<=maxLevel;i++){ cols <<= 1; } cols--; Node[][] tree = new Node[maxLevel+1][cols]; //load the tree into an array for later display for(int currLevel=0;currLevel<=maxLevel;currLevel++){ levelNodesList = nodesList.get(currLevel); //Note: the column for this level's j-th element: 2^(maxLevel-level)*(2*j+1) - 1 int tmp = maxLevel-currLevel; int coeff = 1; for(int i=0;i<tmp;i++){ coeff <<= 1; } for(int j=0;j<levelNodesList.size();j++){ int col = coeff*(2*j + 1) - 1; tree[currLevel][col] = levelNodesList.get(j); } } //display the binary search tree for(int i=0;i<=maxLevel;i++){ for(int j=0;j<cols;j++){ Node node = tree[i][j]; if(node == null) System.out.format(" "); else System.out.format("%2d",node.val); } System.out.format("%n"); } } public static void main(String[] args) { /* 13 10 25 2 12 20 35 29 30 31 32 33 */ System.out.format("Test case 1:%n"); Node n13 = new Node(13); Node n10 = new Node(10); Node n25 = new Node(25); Node n2 = new Node(2); Node n12 = new Node(12); Node n20 = new Node(20); Node n35 = new Node(35); Node n29 = new Node(29); Node n30 = new Node(30); Node n31 = new Node(31); Node n32 = new Node(32); Node n33 = new Node(33); n13.left = n10; n13.right = n25; n10.left = n2; n10.right = n12; n25.left = n20; n25.right = n35; n35.left = n29; n29.right = n30; n30.right = n31; n31.right = n32; n32.right = n33; Node root = n13; System.out.format("%nBefore being balanced, in-order BST:%n"); DSW_BST.recursiveInOrderTraverse(root); DSW_BST dsw = new DSW_BST(); root = dsw.dswBalance(root); System.out.format("%nAfter being balanced, in-order BST:%n"); DSW_BST.recursiveInOrderTraverse(root); System.out.format("%n%n%nAfter being balanced, it is now a complete BST:"); DSW_BST.levelTraverseCompleteBST(root,dsw.getNumberOfNodes()); System.out.format("************************************"); System.out.format("%nTest case 2:%n"); Node nn5 = new Node(5); Node nn10 = new Node(10); Node nn20 = new Node(20); Node nn15 = new Node(15); Node nn30 = new Node(30); Node nn25 = new Node(25); Node nn40 = new Node(40); Node nn23 = new Node(23); Node nn28 = new Node(28); nn5.right = nn10; nn10.right = nn20; nn20.left = nn15; nn20.right = nn30; nn30.left = nn25; nn30.right = nn40; nn25.left = nn23; nn25.right = nn28; root = nn5; System.out.format("%nBefore being balanced, in-order BST:%n"); DSW_BST.recursiveInOrderTraverse(root); dsw = new DSW_BST(); root = dsw.dswBalance(root); System.out.format("%nAfter being balanced, in-order BST:%n"); DSW_BST.recursiveInOrderTraverse(root); System.out.format("%n%n%nAfter being balanced, it is now a complete BST:"); DSW_BST.levelTraverseCompleteBST(root,dsw.getNumberOfNodes()); } }

測試

Test case 1:

Before being balanced, in-order BST:
 2 10 12 13 20 25 29 30 31 32 33 35
After being balanced, in-order BST:
 2 10 12 13 20 25 29 30 31 32 33 35


After being balanced, it is now a complete BST:
[expected max level: 3; real max level: 3]
                   30             
        13                 33     
  10        25       32      35 
 2  12  20  29  31           
************************************
Test case 2:

Before being balanced, in-order BST:
 5 10 15 20 23 25 28 30 40
After being balanced, in-order BST:
 5 10 15 20 23 25 28 30 40


After being balanced, it is now a complete BST:
[expected max level: 3; real max level: 3]
                  25             
        20              30     
   10      23      28      40 
 5  15