You can think of a hash function two ways.

1. It takes a piece of data generates an index into a table. That is why we use them. For example, the hash function might take someone’s name and generate an index from 1 to 100.
2. Since all data in a computer is represented by numbers, a hash function can just be any function that accepts a number and generates another number. Generally, the range of input values is larger than the range of output values. For example, it takes a string of 20 characters and generates a number from 1 to 1000. What makes a particular function a good hash function depends on the data it has to deal with. It is inevitable that more than one input would generate the same output, because there are more possible input values than output values; these are called collisions. For the values it is most likely to encounter, a good hash function will minimize collisions. It is also often helpful if input values which are close to each other generate outputs that are very different.

A tree is a non-linear hierarchical data structure consisting of interconnected nodes through edges.

In contrast to linear data structures like arrays, linked lists, stacks, and queues, which store data sequentially, trees offer a more efficient way of accessing data, especially in the context of today's computational demands.

Key Tree Terminology:

• Node: A node holds a value or key and has pointers to its child nodes. Terminal nodes, called leaf nodes or external nodes, lack child pointers. Nodes with at least one child are internal nodes.
• Edge: The connection between nodes.
• Root: The top node of a tree.
• Node Height: The count of edges from a node to the farthest leaf along its longest path.
• Node Depth: The number of edges from the root to a node.
• Tree Height: The height of the root node or the depth of the deepest node.
• Node Degree: The total branches emerging from a node.
• Forest: A set of separate trees is termed a forest.

Types of Trees:

1. Binary Tree
2. Binary Search Tree
3. AVL Tree
4. B-Tree

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

public TreeNode(int val) {

this.val = val;

this.left = null;

this.right = null;

}

}

public class BinaryTree {

private TreeNode root;

public BinaryTree() {

this.root = null;

}

public void insert(int val) {

this.root = insertHelper(this.root, val);

}

private TreeNode insertHelper(TreeNode node, int val) {

if (node == null) {

return new TreeNode(val);

}

if (val < node.val) {

node.left = insertHelper(node.left, val);

} else {

node.right = insertHelper(node.right, val);

}

return node;

}

public void inorderTraversal() {

inorderHelper(this.root);

}

private void inorderHelper(TreeNode node) {

if (node != null) {

inorderHelper(node.left);

System.out.print(node.val + " ");

inorderHelper(node.right);

}

}

}

public class Main {

public static void main(String[] args) {

BinaryTree tree = new BinaryTree();

tree.insert(4);

tree.insert(2);

tree.insert(6);

tree.insert(1);

tree.insert(3);

tree.insert(5);

tree.insert(7);

tree.inorderTraversal();

}

}

When you think of a tree, what comes to mind? What are the roots, branches, and leaves? You might imagine a large oak tree with roots, branches, and leaves. Similarly, the tree data structure in computer science contains roots, branches, and leaves, but it is represented upside-down. A tree is a type of hierarchical data structure that can be used to express relationships between nodes. In this essay, I'll go through eight different forms of tree data structures.

In this essay, I'll go through the following tree data structures and how to use them.

1. General tree
2. Binary tree
3. Binary search tree
4. AVL tree
5. Red-black tree

1. General Tree

A generic tree is a tree data structure in which the hierarchical structure is unconstrained.

Properties

Follow a tree's attributes.

A node can have as many children as it wants.

2. Binary Tree

A binary tree is a data structure that has the qualities listed below.

Properties

Follow a tree's attributes.

A node can only have two children (children).

These two child nodes are referred to as the left and right child, respectively.

Usage

Compilers use syntax trees to construct them.

Expression parsers and solvers are implemented using this class.

Router-tables are stored in this file.

3. Binary Search Tree

A binary search tree is a narrower version of a binary tree.

Properties

1.Investigate the attributes of a binary tree.

2.The binary-search-tree property is a one-of-a-kind property. This attribute indicates that the left child's value (or key) must be less than or equal to the parent value, while the right child's value must be higher than or equal to the parent value.

Usage

Simple sorting algorithms are implemented with this library.

They can be used to create priority queues.

Many search apps use this when data is continually entering and exiting.

4. AVL tree

A self-balancing binary search tree is an AVL tree. This is the first tree to have its height automatically balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node keeps track of a value called a balance factor, which is the height difference between its left and right subtrees.

A balancing factor of -1, 0 or 1 must be present in all nodes.

If there is at least one node that does not have a balance factor of -1, 0 or 1, rotations should be conducted to balance the tree after insertions or deletions (self-balancing).

Usage

When there are a lot of insertions, this is the way to go.

To explore memory areas of processes during preemption, it is used in the Linux kernel's Memory management subsystem.

5. Red-black tree

A red-black tree is a self-balancing binary search tree in which each node has either a red or a black color. During insertions and deletions, the node colors are utilized to ensure that the tree remains roughly balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node has a red or black color.

The root is dark in color (sometimes omitted).

All of the leaves (labeled NIL) are black.

Both of a node's children are black if it is red.

Every path between a node and any of its child nodes must pass through the same amount of black nodes.

Usage

As a foundation for computational geometry data structures.

In modern Linux kernels, it's used in the Completely Fair Scheduler.

Used in the Linux kernel's epoll system call implementation.

A tree is a hierarchical data structure defined as a collection of nodes. Nodes represent value and nodes are connected by edges. A tree has the following properties:

1. The tree has one node called root. The tree originates from this, and hence it does not have any parent.
2. Each node has one parent only but can have multiple children.
3. Each node is connected to its children via edge.

1. General Tree

A generic tree is a tree data structure in which the hierarchical structure is unconstrained.

Properties

Follow a tree's attributes.

A node can have as many children as it wants.

2. Binary Tree

A binary tree is a data structure that has the qualities listed below.

Properties

Follow a tree's attributes.

A node can only have two children (children).

These two child nodes are referred to as the left and right child, respectively.

Usage

Compilers use syntax trees to construct them.

Expression parsers and solvers are implemented using this class.

Router-tables are stored in this file.

3. Binary Search Tree

A binary search tree is a narrower version of a binary tree.

Properties

1.Investigate the attributes of a binary tree.

2.The binary-search-tree property is a one-of-a-kind property. This attribute indicates that the left child's value (or key) must be less than or equal to the parent value, while the right child's value must be higher than or equal to the parent value.

Usage

Simple sorting algorithms are implemented with this library.

They can be used to create priority queues.

Many search apps use this when data is continually entering and exiting.

4. AVL tree

A self-balancing binary search tree is an AVL tree. This is the first tree to have its height automatically balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node keeps track of a value called a balance factor, which is the height difference between its left and right subtrees.

A balancing factor of -1, 0 or 1 must be present in all nodes.

If there is at least one node that does not have a balance factor of -1, 0 or 1, rotations should be conducted to balance the tree after insertions or deletions (self-balancing).

Usage

When there are a lot of insertions, this is the way to go.

To explore memory areas of processes during preemption, it is used in the Linux kernel's Memory management subsystem.

5. Red-black tree

A red-black tree is a self-balancing binary search tree in which each node has either a red or a black color. During insertions and deletions, the node colors are utilized to ensure that the tree remains roughly balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node has a red or black color.

The root is dark in color (sometimes omitted).

All of the leaves (labeled NIL) are black.

Both of a node's children are black if it is red.

Every path between a node and any of its child nodes must pass through the same amount of black nodes.

Usage

As a foundation for computational geometry data structures.

In modern Linux kernels, it's used in the Completely Fair Scheduler.

Used in the Linux kernel's epoll system call implementation.

A general tree, also known as a non-binary tree, is a tree data structure in which each node can have an arbitrary number of children. Unlike a binary tree, which has a maximum of two children per node, a general tree can have any number of children. This allows for more flexibility in modeling hierarchical relationships between data.

A general tree is typically represented using pointers, with each node containing a value and a list of pointers to its children. The root node is the topmost node in the tree and has no parent. The leaf nodes are the bottommost nodes in the tree and have no children.

A general tree can be used to implement various data structures such as Trie, Huffman tree, and N-ary tree.

A General Tree can be traversed in different ways such as:

• Breadth First Traversal (BFT) also known as Level Order Traversal
• Depth First Traversal (DFT) in three ways: Inorder, Preorder and Postorder.

The use of general tree depends on the problem we are trying to solve, for example, for a file system, a tree structure is used to represent the hierarchy of files and folders.

Making use of trees

Binary search trees (BSTs) are used to swiftly identify whether an element is present in a set or not.

A particular kind of tree known as a heap is used in heap sort.

A modified version of a tree known as a Tries is how modern routers store routing information.

The bulk of well-known databases use B-Trees and T-Trees, two distinct varieties of the tree structure we previously described, to store their data.

Compilers utilise a syntax tree to examine each programme you write for syntax errors.

Tree data structures: types

Typical tree

The generic tree is one of the various types of tree data structures. A node in the general tree might have either n nodes at most or none at all. The degree of the node is not restricted in any way (the number of nodes that a node can contain). The highest node in a general tree is called a root node. The descendants of the parent node are subtrees.

binomial tree

In this usage, the term "binary" refers to the two numbers 0 and 1. A binary tree allows for a maximum of two child nodes per node. In this case, the node can have a maximum of zero, one, or two nodes.

Binarized Search tree:

A non-linear data structure called a binary search tree connects one node to n other nodes.

It is a data structure based on nodes. In a binary search tree, a node can be represented by its data component, left-child, and right-child fields. In a binary search tree, a node can have connections to its top two child nodes, resulting in the node having two pointers (left child and right child pointer). Each node in the right subtree must have a value greater than the root node, and each node in the left subtree must have a value lower than the root node.

Here’s one called a “Counting Sort”:

And here is another one, called a “Bucket Sort”:

Et voila!

An array is like a shelf of books: if you know where any particular book is, you can go directly to that book on the shelf without having to consider any of the other books.

A stack is like a paper spike. The most recently added document is at the top of the pile on the spike. To reach an older document, you first have to remove all the more recently added documents.

A queue is like a narrow escalator in a building: people can only exit the escalator in the order in which they stepped on to it.

A dictionary is… just like a dictionary! However the keys can be anything that uniquely define the entry (e.g., a key might be a car number plate, the corresponding entry the details of the car owner).

An hash table (or hash map) is like an old fashioned rolodex where people were grouped by the initial letter of their surnames. You could go directly to the right “group” in the rolodex, but you would then need to search through the cards in that group to find the exact one you were looking for.

A tree is a way of locating what you want by answering a sequence of questions. Imagine finding your way through a government building. At the entrance there is a board saying: “Planning applications: Floor1; Commercial licences: Floor 2; Welfare: Floor3; …”. We go to Floor 1 (planning applications) where we find another sign board: “Domestic: East Wing; Commercial: West Wing; Infrastructure: South Wing”. We go to the West wing (commercial) where we find another board: “Legal: Joe Bloggs; Financial: Mary Dobson; …”. Finally we have located Mary, the person we were looking for!

A binary tree is just a tree where each question has a yes/no answer. These are typically used for sorting and ordering things.

A graph is just a map. Each location on the map is called a vertex; each road connecting locations is called an edge. If all the roads are one-way streets then this is a directed graph. If there are no loops in the roads, this is a directed acyclic graph.

A heap is a bit like a company organisation chart. The CEO is at the top, then the various executives, then under each executive the department managers, and under each manager is his staff. Note that at each “level” of the org. chart there is no particular ordering.

Each data structure has its own qualities and constraints; in practice, we choose data structures to suit the problem in hand: how do we want to organise our data and how do we want to process it?

A hash table's quick average time complexity for lookups, insertions, and deletions—typically O(1)—is its main benefit over alternative data structures. Because of their effectiveness, hash tables are perfect for uses like caching, database indexing, and dictionaries where instant access to data is crucial.

Here are a few main benefits:

Direct Access: Hash tables typically enable constant-time access by mapping keys to indexes using a hash function. Because of this, they operate far more quickly than structures like lists or trees, which often take O(log n) or O(n) time.

Effective for Big Datasets: Because hash tables have a low temporal complexity, they can manage big datasets effectively. Hash tables scale well when collisions are handled appropriately (e.g., chaining or open addressing) and resized.

Which combination or which data structure enables a node in a list to grow records of its own?

Let’s say our user owns a paint store and wants to keep kids from messing up his color palette display by computerizing it:

The data structure we’ll need begins with a linked list of color palette nodes…

…where each node has some color swatch nodes growing out of it, like so:

This is how we implement that data structure using the Plain English programming language. We start with our data types:

A palette is a thing with a name and some swatches.
A swatch is a thing with a color.

The keyword “thing” tells the compiler to put next and previous pointers on each record so we can link them together in lists. And so we can anchor lists of those types with phrases like “some palettes” and “some swatches”.

Then we define a global variable to serve as the anchor for our data structure:

The palettes are some palettes.

After that, we write a little routine to create a palette given a base color:

To create a palette with a name and a color:
Allocate memory for the palette. Append the palette to the palettes.
Put the name into the palette's name.
Put 250 into the color's lightness.
Loop.
Allocate memory for a swatch. Append the swatch to the palette's swatches.
Put the color into the swatch's color.
Add 125 to the color's lightness.
If the color's lightness is less than 876, repeat.

And we call that routine, seven times, from this routine…

To create some palettes:
Create a palette with "REDS" and the red color.
Create another palette with "ORANGES" and the orange color.
Create a third palette with "YELLOWS" and the yellow color.
Create a fourth palette with "GREENS" and the green color.
Create a fifth palette with "BLUES" and the blue color.
Create a sixth palette with "PURPLES" and the purple color.
Create a seventh palette with "VIOLETS" and the violet color.

…which is called from our “main” routine:

To run:
Start up.
Create the palettes.
Draw the palettes.
Destroy the palettes.
Wait for the escape key.
Shut down.

To make it work we’ll need some drawing routines, of course:

To draw the palettes:
Clear the screen.
Make a box 1 inches by 6-1/2 inches.
Move the box right 1-3/4 inch and down 1 inch.
Loop.
Get a palette from the palettes.
If the palette is nil, break.
Draw the palette's swatches in the box.
Outline the box with the white pen.
Draw the palette's name at the top of the box with the white pen.
Move the box right 1-1/2 inch.
Repeat.
Refresh the screen.

To draw some swatches in a box:
Make a little box 1 inch by 1/2 inch.
Move the little box to the box's left-top.
Move the little box down 1 inch.
Loop.
Get a swatch from the swatches.
If the swatch is nil, break.
Draw and fill the little box with the swatch's color.
Move the little box down 1 inch.
Repeat.

And when we run the program, we get this on the screen (click to enlarge):

Et voila!

It’s not always better, obviously: hash tables need to be reallocated now and then while binary trees scale smoothly; getting the hash function just right is more difficult than defining an ordering relation for a type and getting it wrong can totally screw up performance, and binary trees are ordering-aware and can be used to efficiently query or change an item by index while hash tables cannot.

But it’s true that hash tables are often a bit faster, and can be more memory efficient too. It’s sometimes more memory efficient because you don’t need to store as many references to other items, and it’s usually faster because the underlying hardware supports extremely fast array lookups, which is at the core of hash table operations.

Another reason why hash tables may be faster is if keys are information rich, and take a long time to either compare, check for equality, or compute the hash code of. In this case, for a hash table you can store each key’s hash code together with the key. Then, for every new hash operation, you have to compute the hash code once, then check for equality only for keys in the hash with the exact same hash code. So normally you will have to carry out only two of the expensive operations, while in a binary tree you need up to [math]\log_2(n)[/math], which is generally a bit more than two.

Using only paths in the data structure would not allow sufficiently fast access to the elements. This is why branching factor at least two is used.

Of course pointers could be implemented using indexes to an array and regular trees could use implicit adresses.

For example binary search on a sorted array could be interpreted as searching in an implicitly addressed binary tree. The heapsort heap is another implicit tree maintained in an array, but in the latter case almost everybody talks about it as about a tree.

When you need heaps better suited for other algorithms, you typically need trees with pointers as maintaining the “implicit linking adresses” would be too inefficient.

Maintaining a dynamic ordered set in a sorted array would be inefficient too, therefore the approximation of binary search of such an array is maintained instead. One just have to take some care the tree (pointers required) does not become highly unballanced during the dynamic updates. But there is a huge number of approaches ensuring logarithmic worst case depth.

Sometimes the problem to solve could be decribed using a graph (with vertices and edges). Often it is much easier to represent it by a “spanning tree” with additional information representing nontree edges.

Yes, called a “bidimap”, aka “bi directional map”.

Java doesn’t have one built into the standard API but there are several libraries out there that can provide one (or you can “roll your own” like I did many years ago).

Here is one:

BidiMap (Apache Commons Collections 4.4 API)

Here is another:

Google Core Libraries for Java 19.0 API)

Update:

Just as a clarification, I’m referring to cases where one is using a one to one mapping and may, for whatever reason, need to use a key to look up a value and use a value to look up a key. The set of keys are unique and the set of values are unique.

Also see Bidirectional map - Wikipedia

Nowadays, the world is flooded with data. Almost everything we do involves data, including how our emails are kept, how we use social media platforms to post, and how we interact with others. Data may be organized in a variety of ways. It could be kept in stacks, linked lists, hash tables, arrays, etc. Both linear and non-linear data structures might be used to sort data. The tree data structure is one of the most widely used ones today.

Real-life application of tree data structures:

1. A computer's file system, for instance, is represented as a binary tree.
2. Programming language compilers use syntax trees.
3. K-dimensional space is organized using a space partitioning tree. NASA uses it in its astronomy research.
4. Prefix lookup dictionaries are developed using Trie.
5. Many profitable stock traders employ decision trees in their regular trading.

Why is tree data structure being used?

The widespread adoption of tree data structures may be due to several factors. Data can be stored in a more natural hierarchical style, which is one of the key benefits.

Let's use the file system on our computer as an illustrative example. Each folder has a unique name, and we often put other directories or related files inside of it. You can start your search from a parent folder closest to the file or folder you're looking for and work your way down from there.

The world of data structures is fascinating. If you are interested in learning more about data structures and algorithms, try studying the subject. You can learn a lot more and practice such amazing examples in real life. If you think you have an interest in the field give it a try and find out for yourself.

How can one learn data structures and algorithms?

There are various methods by which you can study. Taking a university course, studying from a book by yourself, or through youtube videos. But in my opinion, an online course is a far better option than these methods. Online courses are cheap while still delivering the same content and are even taught by professionals which is a great way to learn DSA. Students have improved a lot from online courses.

Benefits of online courses:

• You can study from anywhere online and on your own time.
• You can participate in projects which will enhance your technical skills.
• You will attend classes where you can interact with the mentors just like in a traditional classroom.

Elite domains are also one feature that should be present in DSA courses. Why?

It could be helpful for people to decide which features of a topic they find interesting and which they don't. Elite Domain Specialization is the process of developing one's knowledge to an elite level in a single industry. Students will benefit from premium domain opportunities as they build their abilities and advance in their jobs. With domain specialization, individuals have the possibility of earning more income.

These features are offered in DSA courses on many different online platforms. Top examples include:

They offer the following courses on DSA.

1. DSA & System Design (Weekday Batches: 5 Months & Weekend Batches: 6 Months): 200+ hours of learning
2. Full Stack Software Development Program includes training for DSA. (Weekday Batches: 8 Months & Weekend Batches: 9 Months): 300+ hours of learning

Features:

• The Full Stack Software Development Program offers elite domains. You have a variety of choices, such as Project Management, Web 3.0, Web Development, and DevOps & Clouds.
• The 12+ industrial projects will give students real-world exposure. These tasks include learning how to integrate the payment gateway, developing a stock investment application, and developing an online code editor. They have many industrial projects and include Authentication, CRUD, Payment gateway integration, API Integration, etc.
• To help you choose the right course of action, experts are always accessible for free consultations. To assist people in selecting a career path that is a suitable match for their talents, these seminars provide in-depth career guidance on a range of topics.
• They offer IBM course completion certificates to their students.

A nice resource to practice data structures applications is Udemy. Both novices and experts will find this online course to be highly useful. It offers you user cases that use Python, jQuery, HTML, and CSS to replicate real-world problems.

The single drawback of this platform is the lack of real-time projects and elite domains in the curriculum.

Conclusion:

At last, I would suggest you understand the applications of tree data structures. It will help you understand how important data structures are to programming in real life. Some online courses such as Learnbay will be very helpful in promoting the usage of data structures and algorithms and their importance.

Have a nice day!

When you think of a tree, what comes to mind? What are the roots, branches, and leaves? You might imagine a large oak tree with roots, branches, and leaves. Similarly, the tree data structure in computer science contains roots, branches, and leaves, but it is represented upside-down. A tree is a type of hierarchical data structure that can be used to express relationships between nodes. In this essay, I'll go through eight different forms of tree data structures.

In this essay, I'll go through the following tree data structures and how to use them.

1. General tree
2. Binary tree
3. Binary search tree
4. AVL tree
5. Red-black tree

1. General Tree

A generic tree is a tree data structure in which the hierarchical structure is unconstrained.

Properties

Follow a tree's attributes.

A node can have as many children as it wants.

2. Binary Tree

A binary tree is a data structure that has the qualities listed below.

Properties

Follow a tree's attributes.

A node can only have two children (children).

These two child nodes are referred to as the left and right child, respectively.

Usage

Compilers use syntax trees to construct them.

Expression parsers and solvers are implemented using this class.

Router-tables are stored in this file.

3. Binary Search Tree

A binary search tree is a narrower version of a binary tree.

Properties

1.Investigate the attributes of a binary tree.

2.The binary-search-tree property is a one-of-a-kind property. This attribute indicates that the left child's value (or key) must be less than or equal to the parent value, while the right child's value must be higher than or equal to the parent value.

Usage

Simple sorting algorithms are implemented with this library.

They can be used to create priority queues.

Many search apps use this when data is continually entering and exiting.

4. AVL tree

A self-balancing binary search tree is an AVL tree. This is the first tree to have its height automatically balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node keeps track of a value called a balance factor, which is the height difference between its left and right subtrees.

A balancing factor of -1, 0 or 1 must be present in all nodes.

If there is at least one node that does not have a balance factor of -1, 0 or 1, rotations should be conducted to balance the tree after insertions or deletions (self-balancing).

Usage

When there are a lot of insertions, this is the way to go.

To explore memory areas of processes during preemption, it is used in the Linux kernel's Memory management subsystem.

5. Red-black tree

A red-black tree is a self-balancing binary search tree in which each node has either a red or a black color. During insertions and deletions, the node colors are utilized to ensure that the tree remains roughly balanced.

Properties

The properties of binary search trees should be followed.

Self-balancing.

Each node has a red or black color.

The root is dark in color (sometimes omitted).

All of the leaves (labeled NIL) are black.

Both of a node's children are black if it is red.

Every path between a node and any of its child nodes must pass through the same amount of black nodes.

Usage

As a foundation for computational geometry data structures.

In modern Linux kernels, it's used in the Completely Fair Scheduler.

Used in the Linux kernel's epoll system call implementation.

Have you ever wondered where does Facebook keeps all of yours and other millions of user's data?

Well the answer is simple- Databases.

But do you know how?

Well the answer is again simple- using Data structures

So what is a data structure?

->It is a way to store a large number of data in an organized manner so that it can be extracted and processed efficiently as and when required.Data can be stored in many ways or there are many types of data structures

1. Stack Stack (abstract data type)
2. Queue Queue (abstract data type)
3. Trees Tree (data structure)
4. Graph https://en.wikipedia.org/wiki/Graph_theory
5. Hashing Hash function
6. Hope this helps.cheers!

Sometimes a hash table can be used like a counting sort. It depends on whnon-zero ether you want the data in the order that the hash table puts it in (or something that you can simply derive from that order).

However, if you want the data in something like alphabetic order and your hash doesn’t preserve that (and most don’t) you will find you still need to sort the data after hashing it.

The one thing a hash gives you is that each bucket that has only 1 entry in it has a unique item. In that sense, if all you care about is duplicates, a hash table can be very useful. All duplicates will end up in the same buckets. So, if you find, you are adding a new entry to a bucket that already has an entry (e.g. there is a collision) there is a non-zero probability that those two entries are the same. You only need to check those cases for true duplicates.

That’s the simplest “decent” way of handling duplicates and hash clashes.

The linked list gets referred to as a bucket. Each bucket holds all the elements which calculated to a hash pointing to the same index in the hash table. Be that it was a duplicate or just a clash.

A more performant method is to use a binary search tree instead of those lists. This means the worst case situation for item search becomes O(log N) instead of the linked list’s O(N). Just that a BST is a bit more complex to implement, and could use up more space.

Most libraries containing such lookup data types already implement one or the other for you. You really do not need to make them yourself. As a rule of thumb, avoid re-implementing such things - you tend to never get the same performance levels as a system library already does, and you’re just wasting time.