Algorithm to divide a rectangle to smaller retangles?

Question

What's the algorithm to divide a rectangle (c struct with 4 ints) to a random number of smaller rectangles (return a list of structs)? Even better if the max and min dimension of the smaller rectangles can be controlled by a parameter.

e.g.

+----------+            +-------+--+
|          |            |       |  |
|          |            |       |  |
|          |    -->     |---+---+--| (good)
|          |            |   |      |
|          |            +---+      |
|          |            |   |      |
+----------+            +---+------+

smaller shapes should be 4-sided, the following is not good:

+----------+            +-------+--+
|          |            |       |  |
|          |            |       |  |
|          |    -->     |---+---+--| (not good)
|          |            |          |
|          |            +---+      |
|          |            |   |      |
+----------+            +---+------+

Thanks!

Appendix: (rectangle for Moron's discussion)

  +----+--------+
  |    |        |
  |    +---+----+
  |    |   |    | (rectangle-chase)
  +----+---+    |
  |        |    |
  +--------+----+

Answer 1

Split the rectangle into two. Recurse.

Answer 2

Choose a random point p on one edge and divide the rectangle there with a line to the opposite edge. You can then recurse on both halves, stopping the recursion randomly or at a specified limit.

Answer 3

It's a bit odd to ask this question without specifying what conditions under which the rectangles are split.

However, I suspect that what you're looking for is a kd-tree. The kd-tree is a binary tree in which nodes are split with two resulting child nodes based on a condition. http://en.wikipedia.org/wiki/Kd-tree

There's also a quad-tree which can be slightly simpler to implement. It involves splitting nodes into 4 equal-sized children. Each child is recursively split this way until some stop condition. http://en.wikipedia.org/wiki/Quadtree