排序专题(二) / 稳定的内部排序 / 二叉排序树

二叉排序树基础实现与操作
最新推荐文章于 2022-03-06 17:35:00 发布
原创 最新推荐文章于 2022-03-06 17:35:00 发布 · 890 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉排序树 #二叉树的递归前序中序后序遍历 #二叉树的非递归前序中序后序遍历

本文介绍了一种常见的二叉树结构——二叉排序树的定义、基本操作及其实现方法，包括添加、删除、查找等常用操作，并详细阐述了如何通过递归和非递归方式实现树的遍历。
  • 二叉排序树还是很容易理解的，无需多讲解，定义：
    • 若左子树不空，则左子树上所有结点的值均小于它的根结点的值
    • 若右子树不空，则右子树上所有结点的值均大于它的根结点的值
    • 左、右子树也分别为二叉排序树
  • 代码较多，注释较少，不过还是比较易懂的，但逻辑不一定是最简洁的
  • Code除delete()方法外，其它都经过UT测试
  • 方法列表：
    • 获取树中元素总个数，重复元素也计数：public int size();
    • 获取树的高度，即层数：public int depth();
    • 通过给定数组构建二叉排序树：public void buildBinarySortTree(int[] array);
    • 添加一个元素：public boolean add(int data);
    • 删除一个元素，若所给值对应多个元素，会一并删除：public boolean delete(int value);
    • 获取指定元素的前驱：public Integer[] getPrecursor(int value);
    • 按给定值搜索元素：public boolean search(int value);

    • 递归的先序遍历：private void preorderTraversalRecursion(Node root);
    • 非递归的先序遍历A：public int[] preorderTraversal();
    • 非递归的先序遍历B：public int[] anotherPreorderTraversal();

    • 递归的中序遍历：private void inorderTraversalRecursion(Node root);
    • 非递归的中序遍历：public int[] inorderTraversal();

    • 递归的后序遍历：private void postorderTraversalRecursion(Node root);
    • 非递归的后序遍历A：public int[] postorderTraversalA();
    • 非递归的后序遍历B：public int[] postorderTraversalB();
    • 非递归的后序遍历C：public int[] postorderTraversalC();

    • 非递归层序遍历A：public int[] levelOrderTraversal();
    • 非递归的层序遍历B：public int[] anotherLevelOrderTraversal();
  • public class BinarySortTree {
    
    private transient int size = 0;
    private transient int depth = 0;
    
    private Node root = null;
    
    private List<Integer> builtinPreorderList = null;
    private List<Integer> builtinInorderList = null;
    private List<Integer> builtinPostorderList = null;
    
    /*
     * The structure of the tree Node
     */
    private static class Node {
        
        private Integer data;
        private Integer equivalent;
      
        private Node parentNode;
        private Node leftChild;
        private Node rightChild;
        
        public Node(Integer data, Integer equivalent,
                Node parentNode, Node leftChild, Node rightChild) {
            
            this.data = data;
            this.equivalent = equivalent;
            this.parentNode = parentNode;
            this.leftChild = leftChild;
            this.rightChild = rightChild;
        }

    }
    
    public BinarySortTree() {
        root = new Node(null, null, null, null, null);
        builtinPreorderList = new ArrayList<Integer>();
        builtinInorderList = new ArrayList<Integer>();
        builtinPostorderList = new ArrayList<Integer>();
    }
    
    public int size() {
        return size;
    }
    
    public int depth() {
        return depth;
    }
    
    public void buildBinarySortTree(int[] array) {
        
        for (int i = 0; i < array.length; i++) {
            add(array[i]);
        }
        
    }
    
    public boolean add(int data) {
        
        if (size == 0) {
            root.data = data;
            root.equivalent = 0;
            size ++;
            depth ++;
            return true;
        }
        
        Node tempNode = root;
        
        int tempDepth = 1;
        
        while (true) {
            
            if (data < tempNode.data) {
                if (tempNode.leftChild != null) {
                    tempNode = tempNode.leftChild;
                    tempDepth ++;
                } else {
                    tempNode.leftChild = new Node(data, 0, tempNode, null, null);
                    tempDepth ++;
                    break;
                }
            } else if (data == tempNode.data) {
                tempNode.equivalent ++;
                size ++;
                return true;
            } else {
                if (tempNode.rightChild != null) {
                    tempNode = tempNode.rightChild;
                    tempDepth ++;
                } else {
                    tempNode.rightChild = new Node(data, 0, tempNode, null, null);
                    tempDepth ++;
                    break;
                }
            }
            
        }
        
        size ++;
        
        if (tempDepth > depth) {
            depth = tempDepth;
        }
        
        return true;
    }
    
    public boolean delete(int value) {
        
        Node resultNode = searchNode(value);
        
        if (resultNode == null) {
            return false;
        } else {
            if (resultNode.leftChild == null) {
                if (resultNode.rightChild == null) {
                    /*
                     * Both leftChild and rightChild are null
                     */
                    if (resultNode.data < resultNode.parentNode.data) {
                        resultNode.parentNode.leftChild = null;
                    } else {
                        resultNode.parentNode.rightChild = null;
                    }
                } else {
                    /*
                     * leftChild is null but rightChile is not null
                     */
                    if (resultNode.data < resultNode.parentNode.data) {
                        resultNode.parentNode.leftChild = resultNode.leftChild;
                        resultNode.leftChild.parentNode = resultNode.parentNode;
                    }
                }
            } else {
                if (resultNode.rightChild == null) {
                    /*
                     * leftChild is not null but rightChild is null
                     */
                    if (resultNode.data < resultNode.parentNode.data) {
                        resultNode.parentNode.leftChild = resultNode.leftChild;
                        resultNode.leftChild.parentNode = resultNode.parentNode;
                    } else {
                        resultNode.parentNode.rightChild = resultNode.leftChild;
                        resultNode.leftChild.parentNode = resultNode.parentNode;
                    }
                } else {
                    /*
                     * Both leftChild and rightChild are not null
                     */
                    Node tempNode = resultNode.rightChild;
                    while (tempNode.leftChild != null) {
                        tempNode = tempNode.leftChild;
                    }
                    resultNode.data = tempNode.data;
                    resultNode.equivalent = tempNode.equivalent;
                    if (tempNode.equals(resultNode.rightChild)) {
                        /*
                         * The condition that the resultNode's rightChild
                         * has not leftChild
                         */
                        resultNode.rightChild = tempNode.rightChild;
                    } else {
                        /*
                         * The condition that the resultNode's rightChild
                         * has leftChild
                         */
                        tempNode.parentNode.leftChild = tempNode.rightChild;
                    }
                    if (tempNode.rightChild != null) {
                        /*
                         * Rebuild the relation from childNode to parentNode
                         */
                        tempNode.rightChild.parentNode = tempNode.parentNode;
                    }
                }
            }
            return true;
        }
        
    }
    
    private Node searchNode(int value) {
        
        Node resultNode = root;
        
        while (resultNode != null && value != resultNode.data) {
            if (value < resultNode.data) {
                resultNode = resultNode.leftChild;
            } else {
                resultNode = resultNode.rightChild;
            }
        }
        
        return resultNode;
    }
    
    /**
     * Get the informations of the anterior node of the corresponding node
     * which contains the given data, main are the data and its number.
     * 
     * @return An array, details as follows :
     * 
     *     [0] --> the data of the anterior node.
     *     [1] --> the quantity of this data.
     *     
     *     [null, null] --> this tree does not contain the given value.
     */
    public Integer[] getPrecursor(int value) {
        
        Node resultNode = searchNode(value);
        
        if (resultNode == null || resultNode.equals(root)) {
            return new Integer[] {null, null};
        } else {
            return new Integer[] {resultNode.parentNode.data,
                    resultNode.parentNode.equivalent};
        }
        
    }
    
    public boolean search(int value) {
        
        Node resultNode = searchNode(value);
        
        if (resultNode == null) {
            return false;
        } else {
            return true;
        }
    }
    
    /*
     * Recursively get the binary sort tree's sequence according to the given way.
     */
    public int[] getSpecifiedTraversalSequenceRecursion(String type) {
        int[] resultArray = new int[size];
        int index = 0;
        switch (type) {
            case Constant.TREE_TRAVERSAL_PREORDER :
                preorderTraversalRecursion(root);
                for (int element : builtinPreorderList) {
                    resultArray[index ++] = element;
                }
                break;
            case Constant.TREE_TRAVERSAL_INORDER :
                inorderTraversalRecursion(root);
                for (int element : builtinInorderList) {
                    resultArray[index ++] = element;
                }
                break;
            case Constant.TREE_TRAVERSAL_POSTORDER :
                postorderTraversalRecursion(root);
                for (int element : builtinPostorderList) {
                    resultArray[index ++] = element;
                }
                break;
        }
        return resultArray;
    }
    
    /*
     * The tree's recursive preorder traversal.
     */
    private void preorderTraversalRecursion(Node root) {
        if (root == null) {
            return;
        } else {
            for (int i = root.equivalent; i >= 0; i --) {
                builtinPreorderList.add(root.data);
            }
            preorderTraversalRecursion(root.leftChild);
            preorderTraversalRecursion(root.rightChild);
        }
    }
    
    /*
     * The tree's nonrecursive preorder traversal.
     */
    public int[] preorderTraversal() {
        
        int[] resultArray = new int[size];
        
        int index = 0;
        
        Stack<Node> assistanceStack = new Stack<Node>();
        
        Node tempNode = root;
        
        while (tempNode != null || !assistanceStack.empty()) {
            if (tempNode != null) {
                for (int i = tempNode.equivalent; i >= 0; i --) {
                    resultArray[index ++] = tempNode.data;
                }
                assistanceStack.push(tempNode);
                tempNode = tempNode.leftChild;
            } else {
                tempNode = assistanceStack.pop();
                tempNode = tempNode.rightChild;
            }
        }
        
        return resultArray;
    }
    
    /*
     * The tree's another nonrecursive preorder traversal.
     */
    public int[] anotherPreorderTraversal() {
        
        int[] resultArray = new int[size];
        
        if (size != 0) {
            
            int index = 0;
            
            Stack<Node> assistanceStack = new Stack<Node>();
            
            assistanceStack.push(root);
            
            while (!assistanceStack.empty()) {
                Node tempNode = assistanceStack.pop();
                for (int i = tempNode.equivalent; i >= 0; i --) {
                    resultArray[index ++] = tempNode.data;
                }
                if (tempNode.rightChild != null) {
                    assistanceStack.push(tempNode.rightChild);
                }
                if (tempNode.leftChild != null) {
                    assistanceStack.push(tempNode.leftChild);
                }
            }
        }
        
        return resultArray;
    }
    
    /*
     * The tree's recursive inorder traversal.
     */
    private void inorderTraversalRecursion(Node root) {
        if (root == null) {
            return;
        } else {
            inorderTraversalRecursion(root.leftChild);
            for (int i = root.equivalent; i >= 0; i --) {
                builtinInorderList.add(root.data);
            }
            inorderTraversalRecursion(root.rightChild);
        }
    }
    
    /*
     * The tree's nonrecursive inorder traversal.
     */
    public int[] inorderTraversal() {
        
        int[] resultArray = new int[size];
        
        int index = 0;
        
        Stack<Node> assistanceStack = new Stack<Node>();
        
        Node tempNode = root;
        
        while (tempNode != null || !assistanceStack.empty()) {
            if (tempNode != null) {
                assistanceStack.push(tempNode);
                tempNode = tempNode.leftChild;
            } else {
                tempNode = assistanceStack.pop();
                for (int i = tempNode.equivalent; i >= 0; i --) {
                    resultArray[index ++] = tempNode.data;
                }
                tempNode = tempNode.rightChild;
            }
        }
        
        return resultArray;
    }
    
    /*
     * The tree's recursive postorder traversal.
     */
    private void postorderTraversalRecursion(Node root) {
        if (root == null) {
            return;
        } else {
            postorderTraversalRecursion(root.leftChild);
            postorderTraversalRecursion(root.rightChild);
            for (int i = root.equivalent; i >= 0; i --) {
                builtinPostorderList.add(root.data);
            }
        }
    }
    
    public int[] postorderTraversalA() {
        int[] resultArray = new int[size];
        if (size != 0) {
            int index = 0;
            Node tempNode = root;
            Node lastVisitedNode = null;
            Stack<Node> assistanceStack = new Stack<Node>();
            while (tempNode != null) {
                while (tempNode.leftChild != null) {
                    assistanceStack.push(tempNode);
                    tempNode = tempNode.leftChild;
                }
                while (tempNode != null
                        && (tempNode.rightChild == null
                        || tempNode.rightChild == lastVisitedNode)) {
                    for (int i = tempNode.equivalent; i >= 0; i --) {
                        resultArray[index ++] = tempNode.data;
                    }
                    lastVisitedNode = tempNode;
                    if (assistanceStack.isEmpty()) {
                        return resultArray;
                    }
                    tempNode = assistanceStack.pop();
                }
                assistanceStack.push(tempNode);
                tempNode = tempNode.rightChild;
            }
        }
        
        return resultArray;
    }
    
    public int[] postorderTraversalB() {
        int[] resultArray = new int[size];
        if (size > 0) {
            int index = 0;
            Node tempNode = root;
            Node rightChild = null;
            Stack<Node> leftStack = new Stack<Node>();
            Stack<Node> rightStack = new Stack<Node>();
            do {
                while (tempNode != null) {
                    rightChild = tempNode.rightChild;
                    leftStack.push(tempNode);
                    rightStack.push(rightChild);
                    tempNode = tempNode.leftChild;
                }
                tempNode = leftStack.pop();
                rightChild = rightStack.pop();
                if (rightChild == null) {
                    for (int i = tempNode.equivalent; i >= 0; i --) {
                        resultArray[index ++] = tempNode.data;
                    }
                } else {
                    leftStack.push(tempNode);
                    rightStack.push(null);
                }
                tempNode = rightChild;
            } while (!leftStack.isEmpty() || !rightStack.isEmpty());
        }
        
        return resultArray;
    }
    
    public int[] postorderTraversalC() {
        int[] resultArray = new int[size];
        if (size > 0) {
            int index = 0;
            Node tempNode = root;
            Stack<Node> stackA = new Stack<Node>();
            Stack<Node> stackB = new Stack<Node>();
            while (tempNode != null || !stackA.isEmpty()) {
                while (tempNode != null) {
                    stackA.push(tempNode);
                    stackB.push(tempNode);
                    tempNode = tempNode.rightChild;
                }
                if (!stackA.isEmpty()) {
                    tempNode = stackA.pop();
                    tempNode = tempNode.leftChild;
                }
            }
            while (!stackB.isEmpty()) {
                tempNode = stackB.pop();
                for (int i = tempNode.equivalent; i >= 0; i --) {
                    resultArray[index ++] = tempNode.data;
                }
            }
        }
        
        return resultArray;
    }
    
    /*
     * The tree's level order traversal.
     */
    public int[] levelOrderTraversal() {
        
        int[] resultArray = new int[size];
        
        if (size > 0) {
            int index = 0;
            Node tempNode = root;
            Queue<Node> alternationQueueA = new LinkedList<Node>();
            Queue<Node> alternationQueueB = new LinkedList<Node>();
            while (tempNode != null || !alternationQueueA.isEmpty()
                    || !alternationQueueB.isEmpty()) {
                
                if (tempNode != null) {
                    for (int i = tempNode.equivalent; i >= 0; i --) {
                        resultArray[index ++] = tempNode.data;
                    }
                    if (tempNode.leftChild != null) {
                        alternationQueueA.offer(tempNode.leftChild);
                    }
                    if (tempNode.rightChild != null) {
                        alternationQueueA.offer(tempNode.rightChild);
                    }
                    tempNode = null;
                } else {
                    Node queueNode = null;
                    while (!alternationQueueA.isEmpty()) {
                        queueNode = alternationQueueA.poll();
                        if (queueNode.leftChild != null) {
                            alternationQueueB.offer(queueNode.leftChild);
                        }
                        if (queueNode.rightChild != null) {
                            alternationQueueB.offer(queueNode.rightChild);
                        }
                        for (int i = queueNode.equivalent; i >= 0; i --) {
                            resultArray[index ++] = queueNode.data;
                        }
                    }
                    while (!alternationQueueB.isEmpty()) {
                        queueNode = alternationQueueB.poll();
                        if (queueNode.leftChild != null) {
                            alternationQueueA.offer(queueNode.leftChild);
                        }
                        if (queueNode.rightChild != null) {
                            alternationQueueA.offer(queueNode.rightChild);
                        }
                        for (int i = queueNode.equivalent; i >= 0; i --) {
                            resultArray[index ++] = queueNode.data;
                        }
                    }
                }
            }
        }
        
        return resultArray;
    }
    
    public int[] anotherLevelOrderTraversal() {
        int[] resultArray = new int[size];
        if (size > 0) {
            int index = 0;
            Node tempNode = root;
            Queue<Node> assistanceQueue = new LinkedList<Node>();
            assistanceQueue.offer(tempNode);
            while (!assistanceQueue.isEmpty()) {
                tempNode = assistanceQueue.poll();
                for (int i = tempNode.equivalent; i >= 0; i --) {
                    resultArray[index ++] = tempNode.data;
                }
                if (tempNode.leftChild != null) {
                    assistanceQueue.offer(tempNode.leftChild);
                }
                if (tempNode.rightChild != null) {
                    assistanceQueue.offer(tempNode.rightChild);
                }
            }
        }
        
        return resultArray;
    }

}

  • PS:
    • Code还是去年工作半年闲暇时码的，目的是为了弥补自己本科期间没有动手写这些基础code的缺憾
    • 总是工作时抽闲写一点，注释较少，望君手下留情
各种排序算法总结和比较
11-30 3661
排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 代码都经过了CodeBlocks的调试，但是很可...
C语言程序设计之 //算法7.4　二叉排序树的递归查找 //算法7.5　二叉排序树的插入 //算法7.6　二叉排序树的创建 //算法 7.7　二叉排序树的删除
September_C的博客
05-11 2151
此代码可以正常运行，下附有运行区 //算法7.4　二叉排序树的递归查找 //算法7.5　二叉排序树的插入 //算法7.6　二叉排序树的创建 //算法 7.7　二叉排序树的删除 #include<stdio.h> #include<stdlib.h> #define ENDFLAG '#' //char a[10]={'5','6','7','2','1','9','8','10','3','4','#'};//全局变量 typedef struct ElemType{ cha.
算法 - 排序
weixin_30861459的博客
09-01 229
选择排序 思想 遍历无序列表，从中选出最小的元素，依次添加到新的列表中。 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 实操 实际操作的时候，并不是真的创建一个新的列表用来有序的存放数据，因为那样会造成额外的空间消耗，空间复杂度加大，所以其实一般都是...
如何由二叉树的先序和中序序列画出二叉树
weixin_33889245的博客
06-06 1630
今天数据结构的考试有这个题，做了好久，下来后，我好好地在网上查了一下，并结合我自己的理解，总结出来了一个比较好理解的方法。这个方法可以说做起这样的题又快又准。(概括为一个口诀：先序放中间，中序分两边)　基本思想就是递归：1.取出先序的第一个节点。(先序中的节点为根节点)2.用第一个节点可以将中序分成左右子树，然后又取出先序的第二个节点 再次将左右子树再次划分，3，当将中序全部划分为单个...
稳定排序与不稳定排序
我的博客
09-20 812
快速排序、希尔排序、选择排序、堆排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。 首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在Aj位置前，排序后Ai还是要在Aj位置前。 ...
二叉树和堆排序
谁家的喵
03-06 513
二叉树的性质总结，并利用二叉树的性质实现堆排序
精选资源
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
精选资源
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
排序算法的稳定性 （什么样的排序是不稳定的）
冷月无声的博客
06-09 6210
有两个6，a[0]和a[3]。排序结果就有两种可能： 如果排序结束后，a[0]可以保证一定在a[3]前头，也就是他们原有的顺序不变，那这种排序算法就是稳定的。（比如常见的冒泡排序、基数排序、插入排序、归并排序、桶排序、二叉树排序等都是稳定的排序算法） 反之，如果不能保证原有顺序，这种算法就是不稳定的。（比如常见的选择排序，希尔排序，堆排序，快速排序等都是不稳定的排序算法） 要证...
各种排序算法的稳定性及效率比较
Cottage驿站
05-15 2756
1.稳定性比较 1） 稳定的：如果存在多个具有相同排序码的记录，经过排序后，这些记录的相对次序仍然保持不变，则这种排序算法称为稳定的。     插入排序、冒泡排序、归并排序、分配排序（桶式、基数）都是稳定的排序算法。2）不稳定的：否则称为不稳定的。直接选择排序、堆排序、shell排序、快速排序都是不稳定的排序算法。 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的选择排序、希尔排
哈希表与二叉排序树的比较
qq_31984717的博客
12-07 1718
此段来自《极客时间》王争老师的数据结构与算法： 我们在散列表那节中讲过，散列表的插入、删除、查找操作的时间复杂度可以做到常量级的 O(1)，非常高效。而二叉查找树在比较平衡的情况下，插入、删除、查找操作时间复杂度才是 O(logn)，相对散列表，好像并没有什么优势，那我们为什么还要用二叉查找树呢？ 我认为有下面几个原因：第一，散列表中的数据是无序存储的，如果要输出有序的数据，需要先进行排序。...
冒泡，选择，快速，二叉树排序速度比较
qq_41438016的博客
07-23 1396
 冒泡排序，选择排序，快速排序，二叉树排序详细代码见博主其他文章。 public class Main { public static void main(String[] args) { int[] data1 = new int[40000]; int[] data2 = new int[40000]; int[] data3 = new...
常见排序算法的稳定与不稳定
杨氏计算机知识整理
08-28 8548
排序算法中稳定的定义：序列相同元素排序后先后次序不变即稳定 稳定的 　　冒泡排序（bubble sort） — O(n2) 　　鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2) 　　插入排序 （insertion sort）— O(n2) 　　桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体 　　计数排序 (counting sort) ...
排序方法及二叉树
qq_43080331的博客
10-22 889
各种排序算法总结和比较 排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 代码都经过了CodeBlocks的调试，但是很可能有没注意到的B...
八大排序算法 之 堆排序（二叉树排序）
yxb_yingu的博客
05-07 2万+
例如数组 a={19,3,60,7,1,15,33,24,45,32,79,85}; 排序思想： 1，堆排序也是选择排序的一种，根据堆得特性，每次把最大或最小值（本次以最大值为例）拿出来，按序排列； 2，堆排序是对普通选择排序的一种优化：如果是一个稳定堆，每次在选择最大值时，只用沿着二叉树其中一个分叉去交换即可，其他分叉符合堆得特性（因是排好的稳定堆），可以看作是稳定的，不用重排交换，省去了
二叉树排序算法
Hello_GY 的博客
07-06 1万+
二叉树排序的基本原理：先构建一颗空树，使用第一个元素作为根节点，如果之后的元素比第一个小，则放到左子树，否则放到右子树，之后按中序遍历。时间复杂度：nlog2(n)空间复杂度：中序遍历时，需要构建栈，为logn.#include "StdAfx.h" #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define STACK_INCREMENT ...
7. 二叉排序树的搜索、插入、删除，时间复杂度
热门推荐
谢语天
08-08 2万+
二叉排序树又称二叉查找树，它或是一棵空的er
C++实现二分查找与二叉排序树详解
【标题】:"二分查找和二叉排序树（C++实现）" 【知识点详细说明】 ### 二分查找 二分查找是一种在有序数组中查找特定元素的高效算法。其基本思想是将待查找区间分成两半，比较目标值与中间元素的大小，根据比较...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值