在计算机编程中，排序是一种常见的操作，用于将一组数据按照特定的顺序进行排列。以下是一些常见的排序算法及其实现：
冒泡排序（Bubble Sort） 原理
：通过重复遍历待排序的列表，比较相邻两个元素的大小并交换位置，直到整个列表有序。
时间复杂度：O（n^2）
稳定性：稳定
实现 ```python def bubble_sort（arr）: n = len（arr） for i in range（n）: for j in range（0, n-i-1）: if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] ```选择排序（Selection Sort）
原理：每次从待排序的数据中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
时间复杂度：O（n^2）
稳定性：不稳定
实现 ```python def selection_sort（arr）: n = len（arr） for i in range（n）: min_idx = i for j in range（i+1, n）: if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] ```插入排序（Insertion Sort）
原理：将待排序的序列分为已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的正确位置。
时间复杂度：O（n^2）（最好情况O（n））
稳定性：稳定
实现 ```python def insertion_sort（arr）: n = len（arr） for i in range（1, n）: key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key ```快速排序（Quick Sort）
原理：采用分治的思想，通过一趟排序将待排序序列分割成两部分，其中一部分的所有元素都比另一部分小，然后递归地对两部分进行排序。
时间复杂度：O（nlogn）
稳定性：不稳定
实现 ```python def quick_sort（arr）: if len（arr） <= 1: return arr pivot = arr[len（arr） // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort（left） + middle + quick_sort（right） ```归并排序（Merge Sort）
原理：采用分治的思想，将待排序序列分割成若干个子序列，分别进行排序，然后将排好序的子序列合并成最终的有序序列。
时间复杂度：O（nlogn）
稳定性：稳定
实现