Algorithm Complexity Analyzer

**Context**: 
Algorithm complexity analysis is a crucial step in the development of efficient software systems. It helps developers understand the performance and scalability of their algorithms, which is essential for ensuring that the software can handle large inputs and perform well under various conditions. The goal of this task is to design an algorithm complexity analyzer that can take an algorithm as input, analyze its complexity, and provide a detailed report on its performance.

**Detailed Instructions**:
Design an algorithm complexity analyzer that can analyze the time and space complexity of a given algorithm. The analyzer should be able to handle a wide range of algorithms, including sorting, searching, graph traversal, and dynamic programming algorithms. The analyzer should provide a detailed report on the algorithm's complexity, including the Big O notation, the number of operations performed, and any potential bottlenecks.

The analyzer should be able to analyze algorithms written in a variety of programming languages, including but not limited to Python, Java, C++, and JavaScript. The analyzer should also be able to handle algorithms with multiple inputs and outputs.

The analyzer should provide the following features:
- Time complexity analysis: The analyzer should be able to calculate the time complexity of the algorithm, including the best-case, average-case, and worst-case scenarios.
- Space complexity analysis: The analyzer should be able to calculate the space complexity of the algorithm, including the amount of memory used and any potential memory leaks.
- Bottleneck detection: The analyzer should be able to identify any potential bottlenecks in the algorithm, including loops, recursive functions, and memory-intensive operations.
- Optimization suggestions: The analyzer should be able to provide suggestions for optimizing the algorithm, including reducing the number of operations, improving memory usage, and parallelizing tasks.

**Output Format**:
The output of the algorithm complexity analyzer should be a detailed report in JSON format, including the following fields:
- `algorithm_name`: The name of the algorithm being analyzed.
- `time_complexity`: The time complexity of the algorithm, including the Big O notation and the number of operations performed.
- `space_complexity`: The space complexity of the algorithm, including the amount of memory used and any potential memory leaks.
- `bottlenecks`: A list of potential bottlenecks in the algorithm, including loops, recursive functions, and memory-intensive operations.
- `optimization_suggestions`: A list of suggestions for optimizing the algorithm, including reducing the number of operations, improving memory usage, and parallelizing tasks.

**Examples**:
For example, if the input algorithm is a simple sorting algorithm, the output report might look like this:
```
{
  "algorithm_name": "Bubble Sort",
  "time_complexity": {
    "best_case": "O(n)",
    "average_case": "O(n^2)",
    "worst_case": "O(n^2)"
  },
  "space_complexity": {
    "memory_used": "O(1)",
    "memory_leaks": "None"
  },
  "bottlenecks": [
    {
      "type": "loop",
      "location": "line 10"
    }
  ],
  "optimization_suggestions": [
    {
      "type": "reduce_operations",
      "description": "Use a more efficient sorting algorithm, such as QuickSort or MergeSort"
    }
  ]
}
```
Similarly, if the input algorithm is a graph traversal algorithm, the output report might look like this:
```
{
  "algorithm_name": "Depth-First Search",
  "time_complexity": {
    "best_case": "O(|V| + |E|)",
    "average_case": "O(|V| + |E|)",
    "worst_case": "O(|V| + |E|)"
  },
  "space_complexity": {
    "memory_used": "O(|V|)",
    "memory_leaks": "None"
  },
  "bottlenecks": [
    {
      "type": "recursive_function",
      "location": "line 20"
    }
  ],
  "optimization_suggestions": [
    {
      "type": "improve_memory_usage",
      "description": "Use an iterative approach instead of a recursive approach"
    }
  ]
}
```