1. 冒泡排序 (Bubble Sort)

概述： 冒泡排序是一种简单的排序算法，通过多次遍历待排序的数组，比较相邻元素并将较大的元素逐步“冒泡”到末尾。

优缺点：

  • 优点：
  • 实现简单，容易理解。
  • 稳定排序。
  • 缺点：
  • 平均和最坏时间复杂度为 O(n²)，效率较低。

应用场景：

  • 适合小规模数据的排序。

代码示例（C#）：

using System;

class Program
{
    static void BubbleSort(int[] arr)
    {
        int n = arr.Length;
        for (int i = 0; i < n - 1; i++)
       {
            for (int j = 0; j < n - 1 - i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    static void Main()
    {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
        BubbleSort(arr);
        Console.WriteLine(string.Join(", ", arr)); // 输出排序后的数组
    }
}

2. 快速排序 (Quick Sort)

概述： 快速排序使用分治法策略，选择一个“基准”元素，将数组划分为两个子数组，然后递归地对这两个子数组进行排序。

优缺点：

  • 优点：
  • 平均时间复杂度为 O(n log n)，性能优越。
  • 缺点：
  • 最坏情况下时间复杂度为 O(n²)。
  • 不稳定排序。

应用场景：

  • 适合大规模数据的排序。

代码示例（C#）：

using System;

class Program
{
    static void QuickSort(int[] arr, int left, int right)
    {
        if (left < right)
        {
            int pivotIndex = Partition(arr, left, right);
            QuickSort(arr, left, pivotIndex - 1);
            QuickSort(arr, pivotIndex + 1, right);
        }
    }

    static int Partition(int[] arr, int left, int right)
    {
        int pivot = arr[right];
        int i = left - 1;
        for (int j = left; j < right; j++)
        {
            if (arr[j] < pivot)
            {
                i++;
                // 交换
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 将基准元素放到正确的位置
        int temp1 = arr[i + 1];
        arr[i + 1] = arr[right];
        arr[right] = temp1;
        return i + 1;
    }

    static void Main()
    {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
        QuickSort(arr, 0, arr.Length - 1);
        Console.WriteLine(string.Join(", ", arr)); // 输出排序后的数组
    }
}

3. 二分查找 (Binary Search)

概述： 二分查找是一种高效的查找算法，用于已排序数组，通过每次将查找范围减半，来快速找到目标元素。

优缺点：

  • 优点：
  • 时间复杂度为 O(log n)，查找效率高。
  • 缺点：
  • 仅适用于已排序的数据。

应用场景：

  • 大规模已排序数据中的查找。

代码示例（C#）：

using System;

class Program
{
    static int BinarySearch(int[] arr, int target)
    {
        int left = 0, right = arr.Length - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (arr[mid] == target)
            {
                return mid; // 找到目标
            }
            else if (arr[mid] < target)
            {
                left = mid + 1; // 查找右半边
            }
            else
            {
                right = mid - 1; // 查找左半边
            }
        }
        return -1; // 未找到目标
    }

    static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int target = 5;
        int result = BinarySearch(arr, target);
        Console.WriteLine(result); // 输出结果：4（目标元素的索引）
    }
}

git上也都有这些简单算法题，后续我也会更新其他算法题

Gitee链接：https://gitee.com/telldream/basic-algorithm-questions