《恋上数据结构第1季》二叉搜索树 BST

已于 2022-05-25 19:49:56 修改
阅读量2.1k 收藏 2
点赞数
分类专栏： # 《恋上数据结构》 文章标签： 二叉树 数据结构 java 算法
于 2020-03-06 22:03:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43734095/article/details/104687980
版权

二叉搜索树（BinarySearchTree）

数据结构与算法笔记目录：《恋上数据结构》 笔记目录

想加深 Java 基础推荐看这个： Java 强化笔记目录

我的《恋上数据结构》源码（第1季 + 第2季）：https://github.com/szluyu99/Data_Structure_Note

思考：在 n 个动态的整数中搜索某个整数？（查看其是否存在）

  • 假设使用动态数组存放元素，从第 0 个位置开始遍历搜索；
    平均时间复杂度: o ( n ) o(n) o(n)
    在这里插入图片描述

  • 如果维护一个有序的动态数组，使用二分搜索；
    最坏时间复杂度: o ( l o g n ) o(logn) o(logn)、但是添加、删除的平均时间复杂度是 o ( n ) o(n) o(n)
    在这里插入图片描述

  • 使用二叉搜索树；
    添加、删除、搜索的最坏时间复杂度均可优化至: o ( l o g n ) o(logn) o(logn)

二叉搜索树是二叉树的一种，是应用非常广泛的一种二叉树，英文简称为 BST

  • 又被称为：二叉查找树、二叉排序树
  • 任意一个节点的值都大于其左子树所有节点的值
  • 任意一个节点的值都小于其右子树所有节点的值
  • 它的左右子树也是一棵二又搜索树
    在这里插入图片描述
    二叉搜索树可以大大提高搜索数据的效率；

二叉搜索树存储的元素必须具备可比较性：

  • 比如 int、double 等
  • 如果是自定义类型，需要指定比较方式
  • 不允许为 null

注意：对于我们现在使用的二叉树来说，它的元素没有索引的概念

BST 接口设计

我们实现的 二叉搜索树 需要继承前面实现的 通用二叉树；
具体可以查看：《恋上数据结构第1季》二叉树代码实现
在这里插入图片描述
由于 BST 继承 BinaryTree，有的方法已经在 BinaryTree 中实现了，无需再次实现。

int size() // 元素的数量
boolean isEmpty() // 是否为空
void clear() // 清空所有元素
void add (E element) // 添加元素
void remove (E element) // 删除元素
boolean contains (E element) // 是否包含某元素

BST 基础

由于二叉搜索树的节点必须具有可比较性，元素的比较方案设计：

  • 允许外界传入一个 Comparator 自定义比较方案
  • 如果没有传入 Comparator，强制认定元素实现了 Comparable 接口
import java.util.Comparator;
/**
 * 二叉搜索树
 */
@SuppressWarnings("unchecked")
public class BST<E> extends BinaryTree<E> {
	
	// 比较器，根据传入的比较器实现 compareTo() 方法
	private Comparator<E> comparator;
	
	public BST(Comparator<E> comparator){ // 可以传一个比较器
		this.comparator = comparator;
	}
	public BST(){ // 不传比较器，相当于传入一个 null
		this(null); //
	}
	
	// 根据元素值获取节点元素
	private Node<E> node(E element){
		elementNotNullCheck(element);
		
		Node<E> node = root;
		while(node != null){
			int cmp = compareTo(element, node.element);
			if(cmp < 0){
				node = node.left;
			}else if (cmp > 0){
				node = node.right;
			}else{ // cmp == 0
				return node;
			}
		}
		return null;
	}
	
	/**
	 * 是否包含某元素
	 */
	public boolean contains(E element) {
		return node(element) != null;
	}	

	// 节点元素比较
	private int compareTo(E e1, E e2) {
		if (comparator != null) { // 传入比较器则通过比较器比较
			return comparator.compare(e1, e2);
		}
		// 没传比较器，元素内部必须自行实现了 Comparable 接口
		return ((Comparable<E>)e1).compareTo(e2);
	}
	
	// 检测传入的节点是否为空
	private void elementNotNullCheck(E element) {
		if (element == null) { // 不能传入空节点
			throw new IllegalArgumentException("element must not null");
		}
	}
	
}

添加元素: add()

在这里插入图片描述

/**
 * 添加元素
 */
public void add(E element) {
    elementNotNullCheck(element); // 不能传入空节点

    // 传入第一个节点, 若根节点为null, 则该节点为根节点
    if (root == null) {
        root = new Node<>(element, null);
        size++;
        return;
    }

    // 添加的不是第一个节点, 找到父节点
    Node<E> node = root;
    Node<E> parent = root;
    int cmp = 0;
    while (node != null) {
        parent = node; // 父节点
        // 比较【传入节点的元素值】与【父节点的元素值】
        cmp = compareTo(element, node.element);
        if (cmp > 0) { // 传入节点比父节点要大, 往右
            node = node.right;
        } else if (cmp < 0) { // 传入节点比父节点要小, 往左
            node = node.left;
        } else { // 相等, 最好是覆盖掉, 也可以采取其他操作, 看业务需求
            node.element = element;
            return;
        }
    }

    // 上面只是找到了要添加位置的父节点, 下面要将元素添加进去
    Node<E> newNode = new Node<>(element, parent);
    if (cmp > 0) {
        parent.right = newNode;
    } else {
        parent.left = newNode;
    }
    size++;
}

删除元素: remove()

删除节点 – 叶子节点

叶子节点直接删除即可；
在这里插入图片描述

删除节点 – 度为1的节点

删除度为1的节点：用子节点替代原节点的位置；

  • 如果要删除的节点不是根节点：
    在这里插入图片描述
  • 如果要删除的节点是根节点：
    在这里插入图片描述

删除节点 – 度为2的节点

在这里插入图片描述

/**
 * 根据传入的值删除元素
 */
public void remove(E element) {
	remove(node(element));
}
// 根据节点删除元素
private void remove(Node<E> node) {
	if (node == null) return;
	
	size--;
	
	if (node.hasTwoChildren()) { // 度为2的节点
		// 找到后继节点
		Node<E> s = successor(node);
		// 用后继节点的值覆盖度为2的节点的值
		node.element = s.element;
		// 删除后继节点
		node = s;
	}
	
	// 删除node节点（node的度必然是1或者0）
	Node<E> replacement = node.left != null ? node.left : node.right;
	
	if (replacement != null) { // node是度为1的节点
		// 更改parent
		replacement.parent = node.parent;
		// 更改parent的left、right的指向
		if (node.parent == null) { // node是度为1的节点并且是根节点
			root = replacement;
		} else if (node == node.parent.left) {
			node.parent.left = replacement;
		} else { // node == node.parent.right
			node.parent.right = replacement;
		}
	} else if (node.parent == null) { // node是叶子节点并且是根节点
		root = null;
	} else { // node是叶子节点，但不是根节点
		if (node == node.parent.left) {
			node.parent.left = null;
		} else { // node == node.parent.right
			node.parent.right = null;
		}
	}
}

// 根据元素值获取节点元素
private Node<E> node(E element){
	elementNotNullCheck(element);
	
	Node<E> node = root;
	while(node != null){
		int cmp = compareTo(element, node.element);
		if(cmp < 0){
			node = node.left;
		}else if (cmp > 0){
			node = node.right;
		}else{ // cmp == 0
			return node;
		}
	}
	return null;
}

BST 完整源码

package com.mj.tree;

import java.util.Comparator;

/**
 * 二叉搜索树
 */
@SuppressWarnings("unchecked")
public class BST<E> extends BinaryTree<E> { // 继承通用二叉树类

    // 比较器，根据传入的比较器实现 compareTo() 方法
    private Comparator<E> comparator;

    public BST(Comparator<E> comparator) { // 可以传一个比较器
        this.comparator = comparator;
    }

    public BST() { // 不传比较器，相当于传入一个 null
        this(null); //
    }

    /**
     * 是否包含某元素
     */
    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * 添加元素
     */
    public void add(E element) {
        elementNotNullCheck(element); // 不能传入空节点

        // 传入第一个节点, 若根节点为null, 则该节点为根节点
        if (root == null) {
            root = new Node<>(element, null);
            size++;
            return;
        }

        // 添加的不是第一个节点, 找到父节点
        Node<E> node = root;
        Node<E> parent = root;
        int cmp = 0;
        while (node != null) {
            parent = node; // 父节点
            // 比较【传入节点的元素值】与【父节点的元素值】
            cmp = compareTo(element, node.element);
            if (cmp > 0) { // 传入节点比父节点要大, 往右
                node = node.right;
            } else if (cmp < 0) { // 传入节点比父节点要小, 往左
                node = node.left;
            } else { // 相等, 最好是覆盖掉, 也可以采取其他操作, 看业务需求
                node.element = element;
                return;
            }
        }

        // 上面只是找到了要添加位置的父节点, 下面要将元素添加进去
        Node<E> newNode = new Node<>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;
    }

    /**
     * 根据传入的值删除元素
     */
    public void remove(E element) {
        remove(node(element));
    }
    // 根据节点删除元素
    private void remove(Node<E> node) {
        if (node == null) return;

        size--;

        if (node.hasTwoChildren()) { // 度为2的节点
            // 找到后继节点
            Node<E> s = successor(node);
            // 用后继节点的值覆盖度为2的节点的值
            node.element = s.element;
            // 删除后继节点
            node = s;
        }

        // 删除node节点（node的度必然是1或者0）
        Node<E> replacement = node.left != null ? node.left : node.right;

        if (replacement != null) { // node是度为1的节点
            // 更改parent
            replacement.parent = node.parent;
            // 更改parent的left、right的指向
            if (node.parent == null) { // node是度为1的节点并且是根节点
                root = replacement;
            } else if (node == node.parent.left) {
                node.parent.left = replacement;
            } else { // node == node.parent.right
                node.parent.right = replacement;
            }
        } else if (node.parent == null) { // node是叶子节点并且是根节点
            root = null;
        } else { // node是叶子节点，但不是根节点
            if (node == node.parent.left) {
                node.parent.left = null;
            } else { // node == node.parent.right
                node.parent.right = null;
            }
        }
    }

    // 根据元素值获取节点元素
    private Node<E> node(E element) {
        elementNotNullCheck(element);

        Node<E> node = root;
        while (node != null) {
            int cmp = compareTo(element, node.element);
            if (cmp < 0) {
                node = node.left;
            } else if (cmp > 0) {
                node = node.right;
            } else { // cmp == 0
                return node;
            }
        }
        return null;
    }

    // 节点元素比较
    private int compareTo(E e1, E e2) {
        if (comparator != null) { // 传入比较器则通过比较器比较
            return comparator.compare(e1, e2);
        }
        // 没传比较器，元素内部必须自行实现了 Comparable 接口
        return ((Comparable<E>) e1).compareTo(e2);
    }

    // 检测传入的节点是否为空
    private void elementNotNullCheck(E element) {
        if (element == null) { // 不能传入空节点
            throw new IllegalArgumentException("element must not null");
        }
    }

}

运行测试

import java.util.Comparator;

import com.mj.BinarySearchTree.Visitor;
import com.mj.file.Files;
import com.mj.printer.BinaryTrees;

public class Main {
	public static class PersonComparator implements Comparator<Person> { // 比较器
		@Override
		public int compare(Person e1, Person e2) {
			return e1.getAge() - e2.getAge();
		}
	}

	public static class PersonComparator2 implements Comparator<Person> {
		@Override
		public int compare(Person e1, Person e2) {
			return e2.getAge() - e1.getAge();
		}
	}
	
	// Integer类型的数据
	public static void test1(){
		Integer date[] = new Integer[] { 7, 4, 9, 2, 5, 8, 11, 3, 12, 1};
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.println(bst);
	}

	// Person类型的数据
	public static void test2(){
		// Java，匿名类
		BinarySearchTree<Person> bst = new BinarySearchTree<>(new Comparator<Person>() {
			@Override
			public int compare(Person e1, Person e2) {
				return e1.getAge() - e2.getAge();
			}
		});
		Integer date[] = new Integer[] { 7, 4, 9, 2, 5, 8, 11, 3, 12, 1};
		for (int i = 0; i < date.length; i++) {
			bst.add(new Person(date[i]));
		}
		BinaryTrees.println(bst);
	}
	
	// 保存打印结果
	public static void test3(){
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		for(int i = 0; i < 40; i++){
			bst.add((int)(Math.random()*100));
		}
		String string = BinaryTrees.printString(bst);
		string += "\n";
		Files.writeToFile("F:/1.txt", string);
	}
	
	// add() 时值相等的处理
	public static void test4(){
		BinarySearchTree<Person> bst = new BinarySearchTree<>(new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				return o1.getAge() - o2.getAge();
			}
		});
		bst.add(new Person(15, "jack"));
		bst.add(new Person(16, "rose"));
		bst.add(new Person(10, "jerry"));
		bst.add(new Person(10, "kali")); // add()时值相等最好覆盖，否则则不会替换
		BinaryTrees.println(bst);
	}
	
	// 遍历
	public static void test5(){
		Integer date[] = new Integer[] { 7, 4, 9, 2, 5, 8, 11, 3, 12, 1};
		Person persons[] = new Person[10];
		BinarySearchTree<Person> bst = new BinarySearchTree<>(new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				return o2.getAge() - o1.getAge();
			}
		});
		
		for(int i = 0; i < persons.length; i++){
			persons[i] = new Person(date[i]);
			bst.add(persons[i]);
		}
		BinaryTrees.println(bst);
		System.out.print("层次遍历:");
		bst.levelOrder(new Visitor<Person>() {
			@Override
			public boolean visit(Person element) {
				System.out.print(element + " ");
				return false;
			}
			
		});
		
	}
	
	// 访问器遍历
	public static void test6(){
		Integer date[] = new Integer[] { 7, 4, 9, 2, 5, 8, 11, 3, 12, 1};
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.print(bst);
		
		System.out.print("层次遍历：");
		bst.levelOrder(new Visitor<Integer>() {
			@Override
			public boolean visit(Integer element) {
				System.out.print(element + " ");
				return false;
			}
		});
		System.out.println();
		
		System.out.print("前序遍历：");
		bst.preorder(new Visitor<Integer>() {
			public boolean visit(Integer element) {
				System.out.print(element + " ");
//				return element == 2 ? true : false;
				return false;
			}
		});
		System.out.println();
		
		System.out.print("中序遍历：");
		bst.inorder(new Visitor<Integer>() {
			@Override
			public boolean visit(Integer element) {
				System.out.print(element + " ");
				return false;
			}
		});
		System.out.println();
		
		System.out.print("后序遍历：");
		bst.postorder(null);
		bst.postorder(new Visitor<Integer>() {
			@Override
			public boolean visit(Integer element) {
				System.out.print(element + " ");
				return false;
			}
		});
		
	}
	
	// 高度
	public static void test7(){
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		for(int i = 0; i < 20; i++){
			bst.add((int)(Math.random()*100));
		}
		BinaryTrees.print(bst);
		System.out.println();
//		System.out.println(bst.height()1);//递归求高度
		System.out.println(bst.height());
	}
	
	// 是否是完全二叉树
	public static void test8(){
		/* 
		 *    7
		 *  4   8
		 *1   5 
		 * 
		 */
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		Integer date[] = new Integer[] { 7, 4, 8, 1, 5};
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.println(bst);
		System.out.println(bst.isComplete());
	}

	// 是否包含某个结点
	public static void test9(){
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		Integer date[] = new Integer[] { 7, 4, 8, 1, 5};
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.println(bst);
		System.out.println(bst.contains(6));
	}
	
	// 删除节点
	public static void test10(){
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		Integer date[] = new Integer[] { 7, 4, 8, 1, 5};
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.println(bst);
		bst.remove(8);
		BinaryTrees.println(bst);
	}
	public static void main(String[] args) {
		// test1();
		// test2();
		// test3();
		// test4();
		// test5();
		// test6();
		// test7();
		// test8();
		// test9();
		// test10();
	}
}
萌宅鹿同学
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
二叉搜索树（BST）及其实现
weixin_44396684的博客
11-26 501
二叉搜索树： 二叉搜索树（binary serach tree,BST）：对于树中的每一个结点，它的左子树中任意结点都小于该结点的值，而它的右子树中结点的值都大于该结点的值。（没有重复元素） 二叉搜索树的表示：可以使用链接结点的集合来表示二叉树，每个结点都包含一个数值和两个称为left和right的链接，分别引用左子结点和右子结点。 定义一个类实现结点 public class TreeNode<E> { protected E element; protected T
Java实现树，二叉搜索树，AVL平衡搜索树
每一个不曾起舞的日子，都是对人生的辜负。
03-21 263
MyList.LinearList参见链接 Tree package MyTree; public interface Tree { abstract public Comparable root(); abstract public int size(); abstract public int height(); abstract public b...
使用外部比较器Comparator进行排序
wxy654921028的博客
08-17 417
使用外部比较器Comparator进行排序使用 Comparator.comparing 进行排序comparing 方法一comparing 方法二使用 Comparator.reversed 进行排序使用 Comparator.nullsFirst进行排序使用 Comparator.thenComparing 排序 当我们需要对集合的元素进行排序的时候，可以使用java.util.Comparator 创建一个比较器来进行排序。Comparator接口同样也是一个函数式接口，我们可以把使用lambda表
【数据结构和算法】二叉排序树、二叉搜索树、二叉查找树（Java实现）
zzf_forgot的博客
10-02 296
一、概念 任何节点的键值一定大于其左子树中的每一个节点的键值，并小于其右子树中的每一个节点的键值。 二、二叉排序树的创建 &&小技巧。二叉树有一个重要的算法就是递归，当要处理子树时一般都会用到，而能够方便的使用递归的一定又是节点。所以通常是在树里调用节点的方法，在节点里完成一些递归操作。 下面是构造二叉排序树的核心方法： public void add(Node...
二叉搜索树（BST）
qq_41078889的博客
08-19 1918
BST树称作二叉搜索树(Binary Search Tree)或者二叉排序树(Binary Sort Tree) ,它或者是一颗空树;或者是具有下列性质的二叉树: 若左子树不为空，则左子树上所有节点的值均小于它的根节点的值 若右子树不为空，则右子树上所有节点的值均大于它的根节点的值 左右子树也分别满足二叉搜索树性质 特点:每一个节点都满足左孩子的值 (不为空) < 父节点的值<右孩子的值(不为空)。 二分查找就是利用了bst树的性质。 ......
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
陈越、何钦铭-数据结构作业8：二叉搜索树的操作集
03-28
函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针； 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针； 函数Find在二叉搜索树...
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
二叉搜索树（BST，Binary Search Tree），是数据结构中一种非常重要的树形数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于任何有效的节点...
数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx
最新发布
07-17
二叉搜索树(Binary Search Tree, BST)是一种非常重要的数据结构，其核心特性在于能够快速地进行查找、插入以及删除操作。在二叉搜索树中，每个节点包含一个键值（通常是一个整数或者浮点数），并且满足以下条件： 1...
二叉树学习之一ArrayList类
一名正在成长的程序员
11-03 456
由于牛客网中有四道题是需要用到二叉树的，所以开始学习二叉树。 但在学习二叉树之前我首先需要学习泛型， 在学习泛型之前我又学习了java的ArrayList类。都会的可以略过 首先给出定义： 现在， 我们介绍一个很有用的用于存储对象的类了。 可以创建一个数组存储对象， 但是这个数组一旦创建， 它的大小就固定了。 Java 提供 ArrayList 类来存储不限定个数的对象。下图给出了 Arr...
复习下BST( Binary search tree)
csf的专栏
12-26 701
Binary search tree的遍历分为preorder traversal、inorder traversal、postorder traversal三种。 树节点的结构如下： struct node { int sum; string name; struct node *left,*right; };   preorder traversal递归遍历： v
Java实现二叉树（一）：二叉查找树的实现
that_is_cool的博客
07-07 6909
Java实现二叉树（一）：二叉查找树的实现    数据结构+算法=程序，这是共识，是真理，还是学生时代卷子中的考点。但大多数程序员往往缺乏数据结构和算法的知识，或是根本没有学过，或是学过，但在工作时频繁地与业务逻辑打交道，也就逐渐忘记了有这么一回事。    话不多说，直接开始吧，本文将介绍二叉树的基本概念，以及平衡二叉树增删改查节点的实现，由于网上关于数据结构的资料，C++相对居多，而本身作为一个...
Java实现二叉搜索树
皮蛋瘦肉的博客
06-16 6671
定义 结构 特点 遍历 前序遍历 中序遍历 后序遍历 定义 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 结构 二叉搜索树的建立过程． 特点 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； （2）若右子...
java实现二叉查找树
zhang434的专栏
06-17 621
package ustc.zyy.ArrayList; /** * @author zhang yin ye * @date 2014 6 17 * */ import java.util.DuplicateFormatFlagsException; public class BinarySearchTree> { // 树根 private Bina
二叉搜索树（Binary Sort Tree）
不积跬步，无以致千里；不积小流，无以成江海
06-09 1034
在操作数据库的时候，经常进行大量的插入删除操作，我们希望达到的效果是能够对其中的某些元素操作，而不影响其他元素的位置，使表中的元素的移动达到最小，这里面一般使用的数据结构就是动态查找表。什么结构能够实现这样的效果呢？这里首先想到的是链表，对数据的组织形式选用最简单的树形结构。下面我们对二叉排序树进行讨论。二叉排序树一般具备以下几个特点： 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （
手写二叉搜索树（Java实现）
God Liao On The Way
10-09 1936
二叉搜索树的概念二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树的代码实现定义二叉搜索树的数据结构及基本方法 //定义树节点 public clas
恋上数据结构完整笔记（第1季 + 第2季）
热门推荐
萌宅鹿的技术小屋
03-13 2万+
Java 数据结构目录 整理一下。。。 【动态扩容数组】动态扩容数组 ArrayList实现源码（Java、C++） 【链表List】单向链表 SingleLinkedList、双向链表 LinkedList 实现源码 【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环...
《恋上数据结构第1季》动态扩容数组原理及实现
萌宅鹿的技术小屋
03-01 5577
动态扩容数组接口设计Java实现int型动态数组Java实现泛型动态数组Java实现泛型动态数组优化C++实现动态数组 接口设计 int size(); // 元素的数量 boolean isEmpty(); // 是否为空 boolean contains (E element); // 是否包含某个元素 void add (E element); // 添加元素到最后面 E get (int...
《恋上数据结构第1季》单向链表、双向链表
萌宅鹿的技术小屋
03-02 3831
单向链表java实现泛型单向链表List.java 接口AbstractList.javaLinkedList.java java实现泛型单向链表 List.java 接口 public interface List<E> { static final int ELEMENT_NOT_FOUND = -1; /** * 清除所有元素 */ void clear(); ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萌宅鹿同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值