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

最新推荐文章于 2020-09-01 09:36:49 发布
最新推荐文章于 2020-09-01 09:36:49 发布
阅读量827 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉排序树 二叉树的递归前序中序后序遍历 二叉树的非递归前序中序后序遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SecondJanuary/article/details/8511479
版权
  • 二叉排序树还是很容易理解的，无需多讲解，定义：
    • 若左子树不空，则左子树上所有结点的值均小于它的根结点的值
    • 若右子树不空，则右子树上所有结点的值均大于它的根结点的值
    • 左、右子树也分别为二叉排序树
  • 代码较多，注释较少，不过还是比较易懂的，但逻辑不一定是最简洁的
  • 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的缺憾
    • 总是工作时抽闲写一点，注释较少，望君手下留情
SecondJanuary
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法的稳定性及效率比较
Cottage驿站
05-15 2368
1.稳定性比较 1） 稳定的：如果存在多个具有相同排序码的记录，经过排序后，这些记录的相对次序仍然保持不变，则这种排序算法称为稳定的。     插入排序、冒泡排序、归并排序、分配排序（桶式、基数）都是稳定的排序算法。2）不稳定的：否则称为不稳定的。直接选择排序、堆排序、shell排序、快速排序都是不稳定的排序算法。 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的选择排序、希尔排
【二叉排序树 （2）】
Brand__New的专栏
04-25 779
【进阶篇】 二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即是对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索、插入、删除的时间复杂度等于树高，期望O(logn)，最坏O
算法 - 排序
weixin_30861459的博客
09-01 164
选择排序 思想 遍历无序列表，从中选出最小的元素，依次添加到新的列表中。 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 实操 实际操作的时候，并不是真的创建一个新的列表用来有序的存放数据，因为那样会造成额外的空间消耗，空间复杂度加大，所以其实一般都是...
稳定排序与不稳定排序
我的博客
09-20 750
快速排序、希尔排序、选择排序、堆排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。 首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在Aj位置前，排序后Ai还是要在Aj位置前。 ...
排序算法的稳定性 （什么样的排序是不稳定的）
冷月无声的博客
06-09 6032
有两个6，a[0]和a[3]。排序结果就有两种可能： 如果排序结束后，a[0]可以保证一定在a[3]前头，也就是他们原有的顺序不变，那这种排序算法就是稳定的。（比如常见的冒泡排序、基数排序、插入排序、归并排序、桶排序、二叉树排序等都是稳定的排序算法） 反之，如果不能保证原有顺序，这种算法就是不稳定的。（比如常见的选择排序，希尔排序，堆排序，快速排序等都是不稳定的排序算法） 要证...
哈希表与二叉排序树的比较
qq_31984717的博客
12-07 1615
此段来自《极客时间》王争老师的数据结构与算法： 我们在散列表那节中讲过，散列表的插入、删除、查找操作的时间复杂度可以做到常量级的 O(1)，非常高效。而二叉查找树在比较平衡的情况下，插入、删除、查找操作时间复杂度才是 O(logn)，相对散列表，好像并没有什么优势，那我们为什么还要用二叉查找树呢？ 我认为有下面几个原因：第一，散列表中的数据是无序存储的，如果要输出有序的数据，需要先进行排序。...
二叉搜索树/二叉排序树/二叉查找树
further_的博客
09-01 2138
怕
C语言程序设计之 //算法7.4　二叉排序树的递归查找 //算法7.5　二叉排序树的插入 //算法7.6　二叉排序树的创建 //算法 7.7　二叉排序树的删除
September_C的博客
05-11 1986
此代码可以正常运行，下附有运行区 //算法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.
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
7. 二叉排序树的搜索、插入、删除，时间复杂度
谢语天
08-08 2万+
二叉排序树又称二叉查找树，它或是一棵空的er
二叉排序树、平衡二叉排序树、B-树、B+树、B*树
jcw的博客
08-06 1131
引言：为啥会引入这些树的数据结构呢？在学习数据结构的时候，这块内容放到“查找”的章节中，文中提到，很多的查找算法都是基于顺序存储而言的，且没有考虑 对查找数据进行维护的问题，也就是说只对一组静态数据进行查找。但是在实际的应用中，如果需要对不断更新的数据进行查找，也就是所谓的动态查找，在顺序表中维护数据的有序是比较耗时的。树作为一种动态数据结构，人们发现通过对数的一些结构的限制，能够很大程度上提升查找
二叉排序树与堆的区别
weixin_30244889的博客
07-31 604
　　在二叉排序树中，每个结点的值均大于其左子树上所有结点的值，小于其右子树上所有结点的值，对二叉排序树进行中序遍历得到一个有序序列。所以，二叉排序树是结点之间满足一定次序关系的二叉树； 　　堆是一个完全二叉树，并且每个结点的值都大于或等于其左右孩子结点的值（这里的讨论以大根堆为例），所以，堆是结点之间满足一定次序关系的完全二叉树。 　　具有n个结点的二叉排序树，其深度取决于给定集合的初始排列顺...
二叉排序树（二叉查找树、二叉搜索树）
热门推荐
rodman177的博客
05-03 10万+
什么是二叉查找树： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。 本文章重点来讨论一下关于二叉查找树删除节点的问题。 有一下二叉查找树，如图： 在删除节点的时候我们只需考虑一下三种情况： （1）要删除的节点是叶子结点，如图： （2）要删除的节点有左节点但是没有右节点，或者有右节点但是没有左节点，如图： （3）要删除的节点既有...
二叉树的概念及其排序方法
qq_43685242的博客
08-30 7020
1. 树 树是数据结构中的一种. 结点是数据结构中的基础，是构成复杂数据结构的基本组成单位 树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中： 1）有且仅有一个特定的称为根（Root）的结点； 2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、…、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。 此外，树的定义还需要强调以下两点： 1）n>0时根结点是唯一的，不可能存在多个根结点，数据结构中的树只能有一个根结点。 2）m&
排序专题(一) / 稳定的内部排序
SecondJanuary
01-16 1607
1.冒泡排序(Bubble Sort) 思想：众所皆知，无需多言 平均时间复杂度：O(n2)public class BubleSort { public static void bubleSort(int[] array) { if (array.length <= 1) { return; } els
排序专题(四) / 不稳定的内部排序 / 堆排序
SecondJanuary
01-30 1516
堆的定义 前置定义 完全二叉树 完全二叉树是这样一棵树：设此树的高度为h，除第h层外，其它各层(1~h-1)的结点数都达到最大个数(2i-1)，第h层所有的结点都连续集中在最左边。 满二叉树(满二叉树在国内国外的定义是不同的) 国内定义：设一个二叉树的高度为h，若其有2h-1个结点，则其为满二叉树。(显然，叶子结点只可能出现在第h层，且除叶子结点外的其它结点都有两个子节点
排序专题(八) / 不稳定的内部排序 / 希尔(shell)排序
SecondJanuary
01-30 1271
时间复杂度：shell排序时间复杂度取决于所选取的步长序列，介于O(nlogn)和O(ns)(1 也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。 希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插
二叉排序树算法实现与操作
"二叉排序树算法 - 兰州理工大学计算机与通信学院2010年春季学期课程设计报告" 二叉排序树（Binary Sort Tree，BST），也称为二叉查找树，是一种特殊的二叉树数据结构，它满足以下性质：对于任意节点，其左子树中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值