Divide and conquer is a strategy for designing algorithms in three steps: divide the problem into smaller subproblems that look like the original, conquer those subproblems by solving them recursively, and combine their solutions into an answer for the full problem. When a subproblem becomes small enough, it is solved directly as a base case rather than divided further.
Many of the most familiar algorithms follow this shape. Merge sort splits a list in half, sorts each half recursively, and merges the two sorted halves. Quicksort partitions a list around a pivot and sorts each side. Binary search repeatedly halves a sorted range to locate a value. Each gains its efficiency from cutting the problem size down at every step.
The MIT 6.046J “Design and Analysis of Algorithms” lecture notes treat divide and conquer as a foundational paradigm, using examples such as finding the convex hull of a set of points and computing a median to show how splitting a problem can lead to faster solutions than handling it whole.
Because a divide-and-conquer algorithm calls itself on smaller inputs, its running time is naturally described by a recurrence relation that expresses the cost of a problem of size n in terms of the cost of its smaller pieces. Analyzing that recurrence is how one shows, for example, that merge sort runs in time proportional to n log n.