A tree is a structure that includes a value and zero or more children. The value can be anything; the children must be trees. (So this is a recursively defined structure.)
A binary tree is a tree with a value, an optional left child, and an optional right child. The children must be binary trees. A binary tree with only a left child is different from a binary tree with the same value and the same subtree as its right child (and no left child). That is, it matters on which side you put the child if there's just one.
A binary search tree is a binary tree in which the values are numbers (or some other fully ordered type), and every value in the left child is smaller than the tree's value, and every value in the right child is larger than the tree's value.
So, if you're lucky, in every subtree the left child and the right child are of equal size, i.e., the tree's value is the median of all the values in that tree's children.
So how do you search for a value? Let's say I'm looking for the value x. If the value of the tree is x, I've found it. If x is less than the value of the tree, then it can't be in the right child, so I can ignore all those values (half of the values in the tree!). Recursively look again in the left child. Eventually either I find x or I hit an empty left or right child; in the latter case x isn't in the tree.
How long does this search take? At each step I eliminate half the values, so in at most $$(\log_2 n)$$ steps I reach the bottom, where $$n$$ is the total number of values in the tree.
Unfortunately, a binary search tree doesn't have to be balanced. If you build the tree in the easiest possible way, new values are always added at the bottom. So if you add values to the tree in order, then the smallest value will be in the top (root) node, the next-smallest value will be the root of the right child, etc. No node will have a left child. In this case it takes up to $$n$$ steps to find x or to find out that x isn't in the tree. This extremely unbalanced tree is essentially just a list of values.
A balanced binary search tree is one in which you use a more complicated algorithm to insert a new value. One such algorithm inserts the new value in the easy way, so it's somewhere at the bottom, then checks whether the parent of the new value is balanced or not. If not, it juggles the parent, the new value, and the other child of the parent to make that set of values balanced. Then it looks at the parent's parent, sees if it's balanced, and if not, juggle the parent's value, left child, and right child to make it balanced. And so on. working your way up the tree until the whole thing is balanced. Although the steps of this algorithm are a little complicated, each step only takes constant time, and the maximum number of steps to reach the top is $$\log_2 n$$, so search is maximally fast (because the tree is always balanced) and insertion is just a constant factor slower than the easy insertion algorithm, which already takes $$\log_2 n$$ steps.
There are other balanced insertion algorithms that use more complicated, but a little faster, algorithms. For example, look up red-black tree in Wikipedia.