Javatpoint Logo
Javatpoint Logo


Introduction to greedy algorithm:

A greedy algorithm is a simple and intuitive strategy for solving optimization problems. It is an algorithmic paradigm that follows the problem-solving heuristic of making the locally optimal choice at each stage with the hope of finding a global optimum. The idea is to make the best possible decision at each step without considering the consequences of that decision on future steps.

The key characteristic of greedy algorithms is that they make a series of choices by selecting the best available option at each step without revisiting or undoing previous choices. This approach often leads to a suboptimal solution, but in many cases, it provides an acceptable solution and has the advantage of being computationally efficient.

Here are some common characteristics of problems that can be solved using greedy algorithms:

  1. Optimal Substructure: The solution to the problem can be constructed from optimal solutions to sub problems.
  2. Greedy Choice Property: A global optimum can be arrived at by selecting a local optimum (the best available option at the current step).

While greedy algorithms are relatively straightforward and efficient, they may only sometimes guarantee the best solution for some problems. The lack of backtracking and consideration of future consequences can lead to suboptimal solutions. Therefore, the choice of using a greedy algorithm depends on the specific problem at hand and whether the greedy approach is suitable for that scenario.

Examples of problems often solved using greedy algorithms include:

- Activity Selection: Given a set of activities with start and finish times, find the maximum number of non-overlapping activities that can be performed.

- Fractional Knapsack Problem: Given a set of items with weights and values, determine the maximum value that can be obtained by putting a fraction of each item into a knapsack of limited capacity.

- Dijkstra's Shortest Path Algorithm: Find the shortest path from a source vertex to all other vertices in a weighted graph.

- Huffman Coding: Construct an optimal prefix-free binary tree for encoding characters based on their frequencies.

It's important to note that while greedy algorithms are powerful and efficient in certain scenarios, there may be better choices for some types of optimization problems. Thorough analysis and understanding of the problem's characteristics are crucial before applying a greedy approach.

Introduction to divide and conquer algorithm:

A divide-and-conquer algorithm is a problem-solving strategy that breaks a problem into smaller subproblems, solves them independently, and then combines their solutions to solve the original problem. The term "divide and conquer" encapsulates the core idea of breaking down a complex problem into simpler, more manageable parts.

The typical structure of a divide-and-conquer algorithm involves three steps:

  1. Divide: Break the problem into smaller, more manageable subproblems. This step continues recursively until the subproblems become simple enough to be solved directly.
  2. Conquer: Solve the subproblems. This is the base case of the recursion where the problem is small enough that it can be solved directly without further subdivision.
  3. Combine: Merge the solutions of the subproblems to obtain the solution for the original problem.

The divide-and-conquer approach is often implemented using recursion, where the algorithm calls itself to solve the subproblems. Each recursive call works on a smaller instance of the problem until the base case is reached, at which point the solutions are combined to build the result.

Some classic examples of algorithms that use the divide-and-conquer paradigm include:

  1. Merge Sort: It divides the array into two halves, recursively sorts each half, and then merges the sorted halves to obtain a fully sorted array.
  2. Quick Sort: It chooses a pivot element, partitions the array into two subarrays based on the pivot, recursively sorts each subarray, and then combines them.
  3. Binary Search: Given a sorted array, it divides the array in half, compares the target value to the middle element, and continues the Search in the appropriate subarray.
  4. Strassen's Matrix Multiplication: It splits the matrices into submatrices, recursively computes products, and combines them using additions and subtractions.

The divide-and-conquer paradigm is powerful because it often leads to algorithms with efficient time complexity. However, it's essential to carefully design the algorithm to ensure that the subproblems are disjoint and that the combination step is efficient. Additionally, the recursive nature of divide-and-conquer algorithms may result in extra space requirements due to the function call stack.

In summary, divide-and-conquer algorithms provide an effective way to solve complex problems by breaking them down into simpler subproblems, solving them independently, and then combining their solutions.

Types of Greedy algorithms:

Example algorithms for greedy Search here are a few:

  • Greedy Algorithm for Minimum Spanning Tree (MST):
    • Problem: Given a connected, undirected graph with weighted edges, find a minimum spanning tree (MST).
    • Algorithm: Start with an arbitrary vertex and greedily choose the edge with the smallest weight that connects a vertex in the MST to a vertex outside the MST. Repeat until all vertices are included in the MST.
  • Fractional Knapsack Problem:
    • Problem: Given a set of items, each with a weight and a value, determine the maximum value of items to include in a knapsack of limited capacity.
    • Algorithm: Greedily select items based on the ratio of value to weight. Choose items with the highest value-to-weight ratio until the knapsack is full.

Dijkstra's Shortest Path Algorithm:

  • Problem: Given a graph with weighted edges, find the shortest path from a source vertex to all other vertices.
  • Algorithm: Maintain a set of vertices whose shortest distance from the source is known. At each step, choose the vertex with the smallest known distance, relax its neighbors' distances, and add it to the set. Repeat until all vertices are included.

Huffman Coding:

  • Problem: Given a set of characters and their frequencies, find a binary encoding that minimizes the total length of the encoded message.
  • Algorithm: Build a binary tree by repeatedly combining the two characters with the lowest frequencies. Assign binary codes to the edges based on the path in the tree.

Activity Selection Problem:

  • Problem: Given a set of activities with start and finish times, find the maximum number of non-overlapping activities that can be performed.
  • Algorithm: Sort the activities based on their finish times. Greedily select the activities with the earliest finish times that do not overlap with the previously selected ones.

These are just a few examples of greedy algorithms. Greedy algorithms make locally optimal choices at each stage with the hope of finding a global optimum. It's important to note that while greedy algorithms are easy to design and implement, they may only sometimes guarantee an optimal solution for every problem.


Implementation of the greedy algorithm by using an example of the Huffman algorithm.




The provided Python code implements the Huffman coding algorithm for lossless data compression. The `build_huffman_tree` function constructs a binary tree representing character frequencies. Huffman codes, assigning shorter codes to more frequent characters, are generated using the `build_huffman_codes` function. The `huffman_encoding` function encodes input data using these Huffman codes, producing a compressed binary representation. The encoded data, along with the Huffman tree, can later be used to decode the original data. This algorithm efficiently compresses data by representing frequent characters with shorter codes, resulting in reduced overall bit usage for encoding. The implementation uses priority queues and binary trees to manage the construction of the Huffman tree and the generation of Huffman codes.

Applications or examples of divide and conquer algorithm:

Divide and Conquer is a powerful problem-solving paradigm applied across various domains. In the realm of computer science and algorithms, classic examples include the quick sort and merge sort algorithms. Quick sort efficiently sorts an array by partitioning it into smaller sub arrays, sorting each sub array, and combining the results. Merge sort divides an array into halves; recursively sorts each half, and then merges them to produce a fully sorted array. Another notable example is the binary search algorithm, which repeatedly divides a sorted array to locate a specific element efficiently.

Outside of computer science, divide and conquer principles are applied in diverse fields. In robotics, path-planning algorithms often use a divide-and-conquer strategy to navigate complex environments. Additionally, in mathematical problem-solving, algorithms like the fast Fourier transform (FFT) use divide and conquer for efficient signal processing. This versatile approach continues to find applications in solving intricate problems by breaking them down into more manageable components.

Implementation of divide and conquer algorithm.




The provided Python code implements the binary search algorithm, a classic example of a divide-and-conquer strategy. The function `binary_search` takes a sorted array (`arr`) and a target element (`target`) as parameters. It initializes two pointers (`low` and `high`) at the beginning and end of the array, respectively. It then iteratively calculates the middle index and compares the corresponding element to the target. If the middle element is equal to the target, the index is returned. Otherwise, the search space is halved by adjusting the pointers based on the comparison results. This process continues until the target is found or the search space is empty, at which point -1 is returned. The example usage demonstrates searching for an element in a sorted array, showcasing the algorithm's efficiency in logarithmic time complexity.

Divide and Conquer vs Greedy approach.

  1. D&C approach is a solution-based technique, whereas greedy is an optimization approach.
  2. D&C can work efficiently on low-complexity problems such as sorting, whereas the greedy approach becomes effective when the complexity of the problems increases, for example, the Fractional Knapsack problem and Huffman coding compression.
  3. D&C implements recursion in order to achieve a solution, whereas greedy takes an iterative approach to solve the sub-problems.
  4. D&C uses the top-bottom approach, i.e., it breaks the larger problem into smaller sub-problems and then solves them to build a solution. Greedy uses the bottom-top approach, where it solves the sub-problems first, which will lead to an optimal solution.
  5. The D&C approach is recursive, so it is slower than the iterative greedy approach.

Divide and Conquer and Greedy are two prominent algorithmic paradigms with distinct strategies for problem-solving.

Divide and Conquer is characterized by breaking down a problem into smaller, more manageable sub problems, solving them recursively, and combining their solutions to obtain the overall result. This paradigm is well-suited for problems that can be naturally divided into independent subparts, such as the classic example of quicksort for sorting arrays. It often results in algorithms with a logarithmic time complexity.

On the other hand, the Greedy approach involves making locally optimal choices at each step with the hope that they will lead to a globally optimal solution. Greedy algorithms are efficient and simple but may only guarantee the best possible solution in some cases. Examples include Dijkstra's algorithm for finding the shortest path in a graph and Huffman coding for data compression.

While Divide and Conquer emphasizes problem decomposition and recursive solving, Greedy focuses on making the best choice at each step without reconsidering previous decisions. The selection between these approaches depends on the problem at hand; Divide and Conquer tend to be more versatile for a broader range of problems, while Greedy is often chosen for its simplicity and efficiency in specific scenarios.


In conclusion, Divide and Conquer and Greedy algorithms are distinct problem-solving strategies with differing philosophies. Divide and conquer excels in problems where breaking them into independent subproblems and solving them recursively leads to an efficient solution, often achieving logarithmic time complexity. Greedy algorithms, in contrast, make locally optimal choices at each step, aiming for a globally optimal solution. While Greedy algorithms are simpler and more intuitive, they may only guarantee the optimal solution in some cases. The choice between these paradigms depends on the nature of the problem at hand, with Divide and Conquer offering more versatility across a broader range of scenarios and Greedy providing efficiency in specific, well-defined contexts.

Divide and Conquer and Greedy are both widely used algorithm paradigms that find their uses in various problem statements. We cannot say which one is better than the other since it is entirely dependent on the problem.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA