根据权威信息源，常见的四种基础排序算法包括： 冒泡排序、选择排序、插入排序和快速排序 。以下是具体介绍：

一、冒泡排序（Bubble Sort）

• 原理 ：通过重复比较相邻元素并交换顺序错误的元素，将最大（或最小）的元素逐步“冒泡”到数列末端。

• 特点 ：实现简单，但效率较低，平均和最坏时间复杂度均为O（n²）。

• 示例代码 （Java）：

  public static void bubbleSort(int[] arr) {
      int n = arr.length;
      for (int i = 0; i < n-1; i++) {
          for (int j = 0; j < n-i-1; j++) {
              if (arr[j] > arr[j+1]) {
                  int temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
              }
          }
      }
  }
  

二、选择排序（Selection Sort）

• 原理 ：每次从未排序部分选择最小（或最大）的元素，放到已排序部分的末尾。

• 特点 ：代码简洁，但效率低下，时间复杂度为O（n²）。

• 示例代码 （Java）：

  public static void selectionSort(int[] arr) {
      int n = arr.length;
      for (int i = 0; i < n-1; i++) {
          int minIndex = i;
          for (int j = i+1; j < n; j++) {
              if (arr[j] < arr[minIndex]) {
                  minIndex = j;
              }
          }
          int temp = arr[minIndex];
          arr[minIndex] = arr[i];
          arr[i] = temp;
      }
  }
  

三、插入排序（Insertion Sort）

• 原理 ：将未排序元素逐个插入到已排序部分的适当位置，类似整理扑克牌。

• 特点 ：适用于小规模数据，平均时间复杂度为O（n²），但实际运行效率优于选择排序。

• 示例代码 （Java）：

  public static void insertionSort(int[] arr) {
      int n = arr.length;
      for (int i = 1; i < n; i++) {
          int key = arr[i];
          int j = i-1;
          while (j >=0 && arr[j] > key) {
              arr[j+1] = arr[j];
              j--;
          }
          arr[j+1] = key;
      }
  }
  

四、快速排序（Quick Sort）

• 原理 ：采用分治策略，通过基准元素将数组分为两部分，递归排序子数组。

• 特点 ：平均时间复杂度为O（n log n），效率较高，但实现较复杂。

• 示例代码 （Java）：

  public static void quickSort(int[] arr, int low, int high) {
      if (low < high) {
          int pi = partition(arr, low, high);
          quickSort(arr, low, pi-1);
          quickSort(arr, pi+1, high);
      }
  }
  
  private static int partition(int[] arr, int low, int high) {
      int pivot = arr[high];
      int i = (low-1);
      for (int j=low; j<high; j++) {
          if (arr[j] < pivot) {
              i++;