基于二分搜索树的集合Set

最新推荐文章于 2022-02-23 13:47:34 发布
最新推荐文章于 2022-02-23 13:47:34 发布
阅读量113 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45010894/article/details/108506665
版权

不能添加重复元素

package set;

import tree.BST;

public class BSTSet<E extends Comparable<E>>implements Set<E> {
    private BST<E>bst;

    public BSTSet(){
        bst = new BST<>();
    }
    @Override
    public void add(E e) {
        bst.add(e);
    }

    @Override
    public void remove(E e) {
        bst.remove(e);
    }

    @Override
    public boolean contains(E e) {
        return bst.contains(e);
    }

    @Override
    public int getSize() {
        return bst.size();
    }

    @Override
    public boolean isEmpty() {
        return bst.isEmpty();
    }
}


package set;

public interface Set<E> {
    void add(E e);
    void remove(E e);
    boolean contains(E e);

    int getSize();

    boolean isEmpty();

}


package tree;

import java.util.*;

//具有可比性的泛型
public class BST<E extends Comparable> {
    private class Node {
        public E e;
        private Node left;
        private Node right;

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST() {
        root = null;
        size = 0;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    //    向二分搜索树中添加新的元素
//    public void add(E e){
//        if (root == null){
//            root = new Node(e);
//            size++;
//        }else {
//            add(root, e);
//        }
//    }
    //向以node为根的二分搜索树中插入元素 递归算法
//    private void  add(Node node,E e){
//        if(e.equals(node.e))
//            return;
//        else if (e.compareTo(node.e)<0&&node.left==null){
//            node.left = new Node(e);
//            size++;
//            return;
//        }
//        else if (e.compareTo(node.e)>0&&node.right==null){
//            node.right = new Node(e);
//            size++;
//            return;
//        }
//        if (e.compareTo(node.e)<0){
//            add(node.left,e);
//        }else
//            add(node.right,e);
//    }
    public void add(E e) {
        root = add(root, e);
    }

    private Node add(Node node, E e) {
        if (node == null) {
            size++;
            return new Node(e);
        }
        if (e.compareTo(node.e) < 0) {
            node.left = add(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            node.right = add(node.right, e);
        }
        return node;
    }

    // 是否包含某个节点
    public boolean contains(E e) {
        return contains(root, e);
    }

    private boolean contains(Node node, E e) {
        if (node == null) {
            return false;
        }
        if (e.compareTo(node.e) == 0) {
            return true;
        } else if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }

    //遍历
    //先序遍历根左右
    public void proOrder() {
        preOrder(root);
    }

    private void preOrder(Node node) {
        if (node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    //遍历
    //先序遍历根左右 非递归算法
    public void proOrderNR() {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node cur = stack.pop();
            System.out.println(cur.e);

            if (cur.right != null) {
                stack.push(cur.right);
                if (cur.left != null)
                    stack.push(cur.left);
            }
        }
    }

    //中序遍历
    public void inOrder() {
        inOrder(root);
    }

    private void inOrder(Node node) {
        if (node == null)
            return;
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    //后续遍历
    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node node) {
        if (node == null) {
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);

    }

    //查找二分搜索树的最小值（向左走，最后一个左子树）
    public E minimum() {
        if (size == 0)
            throw new IllegalArgumentException("BST is empty");
        return minimum(root).e;
    }

    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }

        return minimum(node.left);
    }

    //查找二分搜索树的最大值（向右走，最后一个右子树）
    public E maxmum() {
        if (size == 0)
            throw new IllegalArgumentException("BST is empty");
        return maxmum(root).e;
    }

    private Node maxmum(Node node) {
        if (node.right == null)
            return node;
        return maxmum(node.right);
    }

    //删除二分搜索树的最小值，返回最小值
    public E removeMin() {
        E ret = minimum();
        removeMin(root);
        return ret;
    }

    //最小节点删除之后，将其右节点添加到删除的位置
    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    //删除最大值
    public E removeMax() {
        E ret = maxmum();
        removeMax(root);
        return ret;
    }

    private Node removeMax(Node node) {
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }

    //删除任意节点
    public void remove(E e) {
        root = remove(root, e);
    }

    //删除以node为根的二分搜索树中值为e的节点，递归算法
    private Node remove(Node node, E e) {
        if (node == null)
            return null;
        if (e.compareTo(node.e) < 0) {
            node.left = remove(node.left, e);
            return node;
        } else if (e.compareTo(node.e) > 0) {
            node.right = remove(node.right, e);
            return node;
        } else {
            //待删除节点左子树为空
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            //待删除节点右子树为空
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            //待删除节点左右子树都不为空，找到比待删除节点大的最小节点，即待删除节点的右子树的最小值，用该节点代替要删除的节点
            //待删除节点的后继节点
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            //删除节点
            node.left = node.right = null;
            return successor;
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        generateBSTString(root, 0, stringBuilder);
        return stringBuilder.toString();
    }

    //    以node为根节点，深度为depth描述二叉树的字符串
    private void generateBSTString(Node node, int depth, StringBuilder stringBuilder) {
        if (node == null) {
            stringBuilder.append(generateBSTString(depth) + "null\n");
            return;
        }
        stringBuilder.append(generateBSTString(depth) + node.e + "\n");
        generateBSTString(node.left, depth + 1, stringBuilder);
        generateBSTString(node.right, depth + 1, stringBuilder);
    }

    private String generateBSTString(int depth) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            stringBuilder.append("--");
        }
        return stringBuilder.toString();
    }

    //层序遍历（广度）
    public void levelOrder() {
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node cur = queue.remove();
            System.out.println(cur.e);

            if (cur.left != null) {
                queue.add(cur.left);
            }
            if (cur.right != null) {
                queue.add(cur.right);
            }
        }
    }

    public static void main(String[] args) {

        BST<Integer> bst = new BST<>();
        Random random = new Random();
        int n = 1000;
        for (int i = 0; i < n; i++) {
            bst.add(random.nextInt(10000));
        }
        ArrayList<Integer> nums = new ArrayList<>();
        while (!bst.isEmpty()) {
            nums.add(bst.removeMin());
        }
        System.out.println(nums);

        for (int i = 1; i < nums.size(); i++) {
            if (nums.get(i - 1) > nums.get(i))
                throw new IllegalArgumentException("Error");
        }
        System.out.println("removeMin test completed");


        ArrayList<Integer> nums1 = new ArrayList<>();
        while (!bst.isEmpty()) {
            nums1.add(bst.removeMax());
        }
        System.out.println(nums);

        for (int i = 1; i < nums1.size(); i++) {
            if (nums.get(i - 1) < nums1.get(i))
                throw new IllegalArgumentException("Error");
        }
        System.out.println("removeMin test completed");
    }
}
菜蜗牛很菜
关注
专栏目录
go的基础数据结构的实现，包括动态数组、链表、堆、栈、集合、索引、二分搜索树、avl数、红黑树等.zip
01-03
这个名为"go的基础数据结构的实现，包括动态数组、链表、堆、栈、集合、索引、二分搜索树、avl树、红黑树等.zip"的压缩包提供了一系列用Go实现的数据结构的源代码。下面将详细探讨这些数据结构的原理及其在Go中的...
Java 使用二分搜索树来实现有序集合Set
抛弃幻想，准备斗争
04-12 347
集合规定每个元素只能存在一次。 由于二分搜索树是不能存放重复元素，所以二分搜索树是实现集合最好的底层数据结构。 首先定义集合接口： public interface Set<E> { //向集合中添加元素 void add(E e); //判断集合中是否包含元素e boolean contains(E e); //删除元素 voi...
Map和Set/二分搜索树
weixin_51143430的博客
02-23 573
map和set概念 Map:存储Key-value键值对，存储的数据拾音社关系，需要根据不重复的key对应value. Set:存储不重复元素的线性表，只判定元素是否存在，或者过滤重复元素. Map和Set是一种专门用来进行搜索的数据结构，是一种适合动态查找的集合容器。用它来进行遍历操作效率极低。 Key-Value键值对 Key:搜索的数据(关键字） Value:和关键字相对应（值） Map中存储的是键值对，而Set中只存储Key. Map的使用 迭代器：用于遍历集合，有了for-each循环，在不
C++复习之STL（二）——谈一谈关联式容器set和有序vector的使用选择问题
weixin_30836759的博客
08-19 367
1.set的宣言 先看看C++标准中对set的介绍： A set is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval of the keys themselves. Set sup...
STL之set集合容器
热门推荐
LYHVOYAGE的专栏
04-05 2万+
set集合容器实现了hongheish
java8集合源码分析-Happy-With-Data-Structure:学习数据结构的一些代码，包括数组，链表，二分搜索树，集合，并查集，
06-04
学习数据结构的一些代码，包括数组，链表，二分搜索树，集合，映射，优先队列，并查集，线段树，字典树（前缀树），AVL树，红黑树，哈希表，如有错误，多多指教。 我们在调用set,map等标准库里的东西，大多使用平衡...
基于功率集树的粗糙集特征选择方法
02-24
本文提出的基于功率集树的粗糙集特征选择方法，首先定义了一种新的结构称为“PS-tree”（Power Set Tree，功率集树）。PS-tree是一种有序树，代表了所有可能的属性组合的集合。在PS-tree中，每一个可能的属性约简都...
在链表中添加元素
weixin_45010894的博客
08-30 2854
public class LinkedList<E> { //结点类 private class Node{ public E e; public Node next; public Node(E e,Node next){ this.e=e; this.next=next; } public Node(E e){ this(e,null); }
时间复杂度比较
weixin_45010894的博客
11-17 655
分享几张时间复杂度比较的图片，方便记忆 几种常见的数据结构的操作对应的时间复杂度 几种常见排序的时间复杂度
链表的虚拟头结点
weixin_45010894的博客
08-30 353
public class LinkedList<E> { //结点类 private class Node{ public E e; public Node next; public Node(E e,Node next){ this.e=e; this.next=next; } public Node(E e){ this(e,null); }
基于链表的集合Set
weixin_45010894的博客
09-10 339
链表集合 package set; import java.util.LinkedList; public class LinkedListSet<E> implements Set<E> { private LinkedList<E>list; public LinkedListSet(){ list = new LinkedList<>(); } @Override public void ad
递归数组求和
weixin_45010894的博客
09-01 333
package prac; public class Sum { public static int sum(int [] arr){ return sum(arr, 0); } public static int sum(int[]arr,int index){ if (index==arr.length) return 0; return arr[index]+sum(arr,index+1);
链表的遍历，查询和修改,删除
weixin_45010894的博客
08-31 226
import javax.swing.plaf.metal.MetalIconFactory; public class LinkedList<E> { //结点类 private class Node { public E e; public Node next; public Node(E e, Node next) { this.e = e; this.next = next
二分搜索树-先序遍历
weixin_45010894的博客
09-09 226
package tree; //具有可比性的泛型 public class BST<E extends Comparable> { private class Node { public E e; private Node left; private Node right; public Node(E e) { this.e = e; left = null;
二分搜索树删除最大元素最小元素
weixin_45010894的博客
09-09 209
package tree; import java.util.*; //具有可比性的泛型 public class BST<E extends Comparable> { private class Node { public E e; private Node left; private Node right; public Node(E e) { this.e = e;
循环队列与数组队列的速度测试
weixin_45010894的博客
08-30 207
import java.util.Random; public class QueueTest { private static double testQueue(Queue<Integer> queue, int opCount) { long startTime = System.nanoTime(); Random random = new Random(); for (int i = 0; i < opCount; i++)
链表映射
weixin_45010894的博客
09-11 200
package map; public class LinkedListMap<K, V> implements Map<K, V> { private class Node { public K key; public V value; public Node next; public Node(K key, V value, Node next) { this.key = key;
Java二分搜索树与链表Set实现复杂度深度解析
Java基于二分搜索树和链表实现的集合Set复杂度分析实例详解深入探讨了在Java编程中如何利用这两种数据结构来构建集合类Set。Set是一种不允许有重复元素的容器，它的核心特性是保证元素唯一性。在这个例子中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值