Development and Implementation of Algorithms

This article is a glossary entry on Searching, Sorting and Recursion – including exam questions and tags.

In a Nutshell

Algorithms are precise computational instructions. In software development, they are important for searching, sorting and recursive problem solving, among other things.

Compact Technical Description

• Search algorithms: linear search, binary search
• Sorting algorithms: Bubble Sort, Merge Sort, Quick Sort
• Recursion: function calls itself until termination condition is reached

Good algorithms are characterized by correctness, efficiency (runtime) and robustness.

Exam-Relevant Key Points

• Binary search only works with pre-sorted data (IHK-relevant)
• Bubble Sort inefficient (O(n^2))
• Recursion can cause StackOverflow (security aspect)
• Runtime determines scalability (economic aspect)
• Big-O helps with comparison
• Documentation: pseudocode, complexity, test cases

Core Components

1. Linear search
2. Binary search
3. Bubble Sort
4. Merge Sort
5. Quick Sort
6. Recursion
7. Iterative alternatives
8. Runtime analysis (Big-O)
9. Error handling/termination
10. Test cases

Practical Example: Binary Search (Python)

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

Explanation: Search in O(log n) (assuming sorted list).

Advantages and Disadvantages

Advantages

• Reusable and testable
• Optimizes critical program sections

Disadvantages

• Wrong choice costs performance
• Recursion can become dangerous without termination

Typical Exam Questions (with Brief Answer)

1. When is binary search possible? Only with sorted data.
2. Disadvantage of Bubble Sort? O(n^2).
3. What is recursion? Self-call until termination.
4. What does O(n log n) mean? Typical efficiency class, e.g. for Merge Sort.

Learning Strategy

1. Visualize sorting algorithms (e.g. VisuAlgo).
2. Implement at least 3 sorting methods yourself.
3. Write pseudocode + specify complexity.
4. Test termination conditions for recursion.

Most Important Sources

1. https://visualgo.net
2. https://www.bigocheatsheet.com/