{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 选择排序和冒泡排序\n",
    "\n",
    "- 排序与排序算法\n",
    "- 经典排序算法简介\n",
    "- 选择排序\n",
    "- 冒泡排序\n",
    "- 其他排序方式\n",
    "- 排序算法应用\n",
    "\n"
   ],
   "id": "6445a693779d292e"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 1.选择排序\n",
    "\n",
    "【原理】：首先在未排序序列中找到最小(大)元素，存放在排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推"
   ],
   "id": "9ac59d03d4b50a03"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 寻找数组中最小元素的索引\n",
    "def findSmallest(arr):\n",
    "    smallest = arr[0]\n",
    "    smallestIndex = 0\n",
    "    for i in range(1,len(arr)):\n",
    "        if arr[i] < smallest:\n",
    "            smallest = arr[i]\n",
    "            smallestIndex = i\n",
    "    return smallestIndex\n",
    "\n",
    "# 排序算法\n",
    "def selectionSort(arr):\n",
    "    sortedArr = []\n",
    "    for _ in range(len(arr)):\n",
    "        smallest = findSmallest(arr)\n",
    "        sortedArr.append(arr.pop(smallest))\n",
    "    return sortedArr"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def test_selection_sort():\n",
    "    # 测试用例1：正常情况（无序数组）\n",
    "    print(\"=== 测试1：普通无序数组 ===\")\n",
    "    arr1 = [64, 25, 12, 22, 11]\n",
    "    print(\"原数组:\", arr1)\n",
    "    sorted_arr1 = selectionSort(arr1)\n",
    "    print(\"排序后:\", sorted_arr1)\n",
    "    assert sorted_arr1 == [11, 12, 22, 25, 64], \"测试1失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例2：已排序数组\n",
    "    print(\"=== 测试2：已排序数组 ===\")\n",
    "    arr2 = [1, 2, 3, 4, 5]\n",
    "    print(\"原数组:\", arr2)\n",
    "    sorted_arr2 = selectionSort(arr2)\n",
    "    print(\"排序后:\", sorted_arr2)\n",
    "    assert sorted_arr2 == [1, 2, 3, 4, 5], \"测试2失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例3：逆序数组\n",
    "    print(\"=== 测试3：逆序数组 ===\")\n",
    "    arr3 = [5, 4, 3, 2, 1]\n",
    "    print(\"原数组:\", arr3)\n",
    "    sorted_arr3 = selectionSort(arr3)\n",
    "    print(\"排序后:\", sorted_arr3)\n",
    "    assert sorted_arr3 == [1, 2, 3, 4, 5], \"测试3失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例4：有重复元素的数组\n",
    "    print(\"=== 测试4：重复元素数组 ===\")\n",
    "    arr4 = [3, 1, 2, 1, 4]\n",
    "    print(\"原数组:\", arr4)\n",
    "    sorted_arr4 = selectionSort(arr4)\n",
    "    print(\"排序后:\", sorted_arr4)\n",
    "    assert sorted_arr4 == [1, 1, 2, 3, 4], \"测试4失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例5：单元素数组\n",
    "    print(\"=== 测试5：单元素数组 ===\")\n",
    "    arr5 = [42]\n",
    "    print(\"原数组:\", arr5)\n",
    "    sorted_arr5 = selectionSort(arr5)\n",
    "    print(\"排序后:\", sorted_arr5)\n",
    "    assert sorted_arr5 == [42], \"测试5失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例6：空数组\n",
    "    print(\"=== 测试6：空数组 ===\")\n",
    "    arr6 = []\n",
    "    print(\"原数组:\", arr6)\n",
    "    sorted_arr6 = selectionSort(arr6)\n",
    "    print(\"排序后:\", sorted_arr6)\n",
    "    assert sorted_arr6 == [], \"测试6失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例7：负数和大数混合\n",
    "    print(\"=== 测试7：负数和大数混合 ===\")\n",
    "    arr7 = [-5, 1000000, -2, 0, 42]\n",
    "    print(\"原数组:\", arr7)\n",
    "    sorted_arr7 = selectionSort(arr7)\n",
    "    print(\"排序后:\", sorted_arr7)\n",
    "    assert sorted_arr7 == [-5, -2, 0, 42, 1000000], \"测试7失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    print(\"所有测试用例通过！\")\n",
    "\n",
    "# 运行测试\n",
    "test_selection_sort()"
   ],
   "id": "e1e240699278a058",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 2.冒泡排序\n",
    "\n",
    "【原理】：比较相邻元素，如果第一个大，就交换它们两个"
   ],
   "id": "11e47300cb73f996"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def bubbleSort(arr):\n",
    "    n = len(arr)\n",
    "    while n > 1:\n",
    "        for i in range(n-1):\n",
    "            if arr[i] > arr[i+1]:\n",
    "                arr[i], arr[i+1] = arr[i+1], arr[i]\n",
    "        n -= 1\n",
    "    return arr"
   ],
   "id": "62f3bfcca2c774b9",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def test_bubble_sort():\n",
    "    # 测试用例1：普通无序数组\n",
    "    print(\"=== 测试1：普通无序数组 ===\")\n",
    "    arr1 = [64, 25, 12, 22, 11]\n",
    "    print(\"原数组:\", arr1)\n",
    "    sorted_arr1 = bubbleSort(arr1.copy())\n",
    "    print(\"排序后:\", sorted_arr1)\n",
    "    assert sorted_arr1 == [11, 12, 22, 25, 64], \"测试1失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例2：已排序数组\n",
    "    print(\"=== 测试2：已排序数组 ===\")\n",
    "    arr2 = [1, 2, 3, 4, 5]\n",
    "    print(\"原数组:\", arr2)\n",
    "    sorted_arr2 = bubbleSort(arr2.copy())\n",
    "    print(\"排序后:\", sorted_arr2)\n",
    "    assert sorted_arr2 == [1, 2, 3, 4, 5], \"测试2失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例3：逆序数组\n",
    "    print(\"=== 测试3：逆序数组 ===\")\n",
    "    arr3 = [5, 4, 3, 2, 1]\n",
    "    print(\"原数组:\", arr3)\n",
    "    sorted_arr3 = bubbleSort(arr3.copy())\n",
    "    print(\"排序后:\", sorted_arr3)\n",
    "    assert sorted_arr3 == [1, 2, 3, 4, 5], \"测试3失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例4：有重复元素的数组\n",
    "    print(\"=== 测试4：重复元素数组 ===\")\n",
    "    arr4 = [3, 1, 2, 1, 4]\n",
    "    print(\"原数组:\", arr4)\n",
    "    sorted_arr4 = bubbleSort(arr4.copy())\n",
    "    print(\"排序后:\", sorted_arr4)\n",
    "    assert sorted_arr4 == [1, 1, 2, 3, 4], \"测试4失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例5：单元素数组\n",
    "    print(\"=== 测试5：单元素数组 ===\")\n",
    "    arr5 = [42]\n",
    "    print(\"原数组:\", arr5)\n",
    "    sorted_arr5 = bubbleSort(arr5.copy())\n",
    "    print(\"排序后:\", sorted_arr5)\n",
    "    assert sorted_arr5 == [42], \"测试5失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例6：空数组\n",
    "    print(\"=== 测试6：空数组 ===\")\n",
    "    arr6 = []\n",
    "    print(\"原数组:\", arr6)\n",
    "    sorted_arr6 = bubbleSort(arr6.copy())\n",
    "    print(\"排序后:\", sorted_arr6)\n",
    "    assert sorted_arr6 == [], \"测试6失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试用例7：负数和大数混合\n",
    "    print(\"=== 测试7：负数和大数混合 ===\")\n",
    "    arr7 = [-5, 1000000, -2, 0, 42]\n",
    "    print(\"原数组:\", arr7)\n",
    "    sorted_arr7 = bubbleSort(arr7.copy())\n",
    "    print(\"排序后:\", sorted_arr7)\n",
    "    assert sorted_arr7 == [-5, -2, 0, 42, 1000000], \"测试7失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    print(\"所有测试用例通过！\")\n",
    "\n",
    "# 运行测试\n",
    "test_bubble_sort()"
   ],
   "id": "7afe1d23b60c8337",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 3.插入排序\n",
    "\n",
    "【原理】：维持一个已排序好的子列表，其位置始终在列表的前部，然后逐步扩大这个子列表到全表"
   ],
   "id": "f53a1ccea8305c80"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def insert_last(arr,i):\n",
    "    \"\"\"在arr[:,i]已经排好序的情况下，排序arr[:i+1]\"\"\"\n",
    "    if i > 0 and arr[i] < arr[i-1]:\n",
    "        arr[i] , arr[i-1] = arr[i-1], arr[i]\n",
    "        insert_last(arr,i-1)\n",
    "\n",
    "def insertSort(arr,i=None):\n",
    "    if i is None:\n",
    "        i = len(arr)-1\n",
    "    if i > 0:\n",
    "        insertSort(arr,i-1)\n",
    "        insert_last(arr,i)"
   ],
   "id": "16730f3acc1d6f29",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# 双循环方法实现\n",
    "def insertionSort(arr):\n",
    "    for i in range(1,len(arr)):\n",
    "        curr = arr[i]\n",
    "        pos = i\n",
    "        while pos > 0 and curr < arr[pos-1]:\n",
    "            arr[pos] = arr[pos-1]\n",
    "            pos -= 1\n",
    "        arr[pos] = curr\n",
    "    return arr"
   ],
   "id": "ea2a6844455c12d6",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def test_insertion_sort():\n",
    "    # 测试1：普通无序数组\n",
    "    arr1 = [5, 2, 4, 6, 1, 3]\n",
    "    assert insertionSort(arr1.copy()) == [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "    # 测试2：已排序数组\n",
    "    arr2 = [1, 2, 3, 4, 5]\n",
    "    assert insertionSort(arr2.copy()) == [1, 2, 3, 4, 5]\n",
    "\n",
    "    # 测试3：逆序数组\n",
    "    arr3 = [5, 4, 3, 2, 1]\n",
    "    assert insertionSort(arr3.copy()) == [1, 2, 3, 4, 5]\n",
    "\n",
    "    # 测试4：重复元素\n",
    "    arr4 = [3, 1, 2, 1, 4]\n",
    "    assert insertionSort(arr4.copy()) == [1, 1, 2, 3, 4]\n",
    "\n",
    "    # 测试5：单元素数组\n",
    "    arr5 = [42]\n",
    "    assert insertionSort(arr5.copy()) == [42]\n",
    "\n",
    "    # 测试6：空数组\n",
    "    arr6 = []\n",
    "    assert insertionSort(arr6.copy()) == []\n",
    "\n",
    "    print(\"✓ 所有测试通过！\")\n",
    "\n",
    "test_insertion_sort()"
   ],
   "id": "a0243f8aa2ab5771",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 4.希尔排序（递减增量排序）\n",
    "\n",
    "【插入排序的劣势】：\n",
    "- 插入排序在对几乎已经排好序的数据操作时，效率高，几乎可以达到线性排序的效率\n",
    "- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位\n",
    "\n",
    "【原理】：将整个待排序的记录序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序"
   ],
   "id": "b172b544adb68b93"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "【记录】：在重复数据时曾出现过错误，发现自己没有把start固定",
   "id": "b404c28d7471fbe6"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def gapInsertionSort(arr,start=0,gap=None):\n",
    "    for i in range(start,len(arr),gap):\n",
    "        curr = arr[i]\n",
    "        pos = i\n",
    "        while pos >= gap and curr < arr[pos-gap]:\n",
    "            arr[pos] = arr[pos-gap]\n",
    "            pos -= gap\n",
    "        arr[pos] = curr\n",
    "\n",
    "def shellSort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    length = len(arr)\n",
    "    gap = length // 2\n",
    "    while gap > 0:\n",
    "        for start in range(gap):\n",
    "            gapInsertionSort(arr,start,gap)\n",
    "        gap = gap // 2\n",
    "    return arr"
   ],
   "id": "aa1f167cc54bef12",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "def test_shell_sort():\n",
    "    # 测试1：普通无序数组\n",
    "    print(\"=== 测试1：普通无序数组 ===\")\n",
    "    arr1 = [64, 25, 12, 22, 11, 99, 3]\n",
    "    print(\"原数组:\", arr1)\n",
    "    sorted_arr1 = shellSort(arr1.copy())\n",
    "    print(\"排序后:\", sorted_arr1)\n",
    "    assert sorted_arr1 == [3, 11, 12, 22, 25, 64, 99], \"测试1失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试2：已排序数组\n",
    "    print(\"=== 测试2：已排序数组 ===\")\n",
    "    arr2 = [1, 2, 3, 4, 5]\n",
    "    print(\"原数组:\", arr2)\n",
    "    sorted_arr2 = shellSort(arr2.copy())\n",
    "    print(\"排序后:\", sorted_arr2)\n",
    "    assert sorted_arr2 == [1, 2, 3, 4, 5], \"测试2失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试3：逆序数组\n",
    "    print(\"=== 测试3：逆序数组 ===\")\n",
    "    arr3 = [9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
    "    print(\"原数组:\", arr3)\n",
    "    sorted_arr3 = shellSort(arr3.copy())\n",
    "    print(\"排序后:\", sorted_arr3)\n",
    "    assert sorted_arr3 == [1, 2, 3, 4, 5, 6, 7, 8, 9], \"测试3失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试4：重复元素数组\n",
    "    print(\"=== 测试4：重复元素数组 ===\")\n",
    "    arr4 = [5, 2, 5, 1, 3, 2, 1, 4]\n",
    "    print(\"原数组:\", arr4)\n",
    "    sorted_arr4 = shellSort(arr4.copy())\n",
    "    print(\"排序后:\", sorted_arr4)\n",
    "    assert sorted_arr4 == [1, 1, 2, 2, 3, 4, 5, 5], \"测试4失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试5：单元素数组\n",
    "    print(\"=== 测试5：单元素数组 ===\")\n",
    "    arr5 = [42]\n",
    "    print(\"原数组:\", arr5)\n",
    "    sorted_arr5 = shellSort(arr5.copy())\n",
    "    print(\"排序后:\", sorted_arr5)\n",
    "    assert sorted_arr5 == [42], \"测试5失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试6：空数组\n",
    "    print(\"=== 测试6：空数组 ===\")\n",
    "    arr6 = []\n",
    "    print(\"原数组:\", arr6)\n",
    "    sorted_arr6 = shellSort(arr6.copy())\n",
    "    print(\"排序后:\", sorted_arr6)\n",
    "    assert sorted_arr6 == [], \"测试6失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试7：大范围数值\n",
    "    print(\"=== 测试7：大范围数值 ===\")\n",
    "    arr7 = [-5, 1000000, -2, 0, 42, -999, 77]\n",
    "    print(\"原数组:\", arr7)\n",
    "    sorted_arr7 = shellSort(arr7.copy())\n",
    "    print(\"排序后:\", sorted_arr7)\n",
    "    assert sorted_arr7 == [-999, -5, -2, 0, 42, 77, 1000000], \"测试7失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    print(\"✓✓✓ 所有测试用例通过！ ✓✓✓\")\n",
    "\n",
    "# 运行测试\n",
    "test_shell_sort()"
   ],
   "id": "3d4c62afb38a33c3",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 5.归并排序\n",
    "\n",
    "【原理】：两两归并"
   ],
   "id": "b0ea0d1220ac33cb"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-10T13:09:30.076338Z",
     "start_time": "2025-05-10T13:09:30.053027Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def mergeSort(arr,a=0,b=None):\n",
    "    if b is None:\n",
    "        b = len(arr)\n",
    "    if b - a > 1:\n",
    "        c = (a+b+1)//2\n",
    "        mergeSort(arr,a,c)\n",
    "        mergeSort(arr,c,b)\n",
    "        L,R = arr[a:c],arr[c:b]\n",
    "        merge(L,R,arr,len(L),len(R),a,b)\n",
    "\n",
    "def merge(L,R,arr,i,j,a,b):\n",
    "    if a < b:\n",
    "        if (j <= 0) or (i > 0 and L[i-1] > R[j-1]):\n",
    "            arr[b-1] = L[i-1]\n",
    "            i -= 1\n",
    "        else:\n",
    "            arr[b-1] = R[j-1]\n",
    "            j -= 1\n",
    "        merge(L,R,arr,i,j,a,b-1)"
   ],
   "id": "732a1c692a23aef1",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-10T13:09:31.472674Z",
     "start_time": "2025-05-10T13:09:31.463173Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def test_merge_sort():\n",
    "    # 测试1：普通无序数组\n",
    "    print(\"=== 测试1：普通无序数组 ===\")\n",
    "    arr1 = [38, 27, 43, 3, 9, 82, 10]\n",
    "    print(\"原数组:\", arr1)\n",
    "    sorted_arr1 = arr1.copy()\n",
    "    mergeSort(sorted_arr1)\n",
    "    print(\"排序后:\", sorted_arr1)\n",
    "    assert sorted_arr1 == [3, 9, 10, 27, 38, 43, 82], \"测试1失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试2：已排序数组\n",
    "    print(\"=== 测试2：已排序数组 ===\")\n",
    "    arr2 = [1, 2, 3, 4, 5]\n",
    "    print(\"原数组:\", arr2)\n",
    "    sorted_arr2 = arr2.copy()\n",
    "    mergeSort(sorted_arr2)\n",
    "    print(\"排序后:\", sorted_arr2)\n",
    "    assert sorted_arr2 == [1, 2, 3, 4, 5], \"测试2失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试3：逆序数组\n",
    "    print(\"=== 测试3：逆序数组 ===\")\n",
    "    arr3 = [9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
    "    print(\"原数组:\", arr3)\n",
    "    sorted_arr3 = arr3.copy()\n",
    "    mergeSort(sorted_arr3)\n",
    "    print(\"排序后:\", sorted_arr3)\n",
    "    assert sorted_arr3 == [1, 2, 3, 4, 5, 6, 7, 8, 9], \"测试3失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试4：重复元素数组\n",
    "    print(\"=== 测试4：重复元素数组 ===\")\n",
    "    arr4 = [5, 2, 5, 1, 3, 2, 1, 4]\n",
    "    print(\"原数组:\", arr4)\n",
    "    sorted_arr4 = arr4.copy()\n",
    "    mergeSort(sorted_arr4)\n",
    "    print(\"排序后:\", sorted_arr4)\n",
    "    assert sorted_arr4 == [1, 1, 2, 2, 3, 4, 5, 5], \"测试4失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试5：单元素数组\n",
    "    print(\"=== 测试5：单元素数组 ===\")\n",
    "    arr5 = [42]\n",
    "    print(\"原数组:\", arr5)\n",
    "    sorted_arr5 = arr5.copy()\n",
    "    mergeSort(sorted_arr5)\n",
    "    print(\"排序后:\", sorted_arr5)\n",
    "    assert sorted_arr5 == [42], \"测试5失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试6：空数组\n",
    "    print(\"=== 测试6：空数组 ===\")\n",
    "    arr6 = []\n",
    "    print(\"原数组:\", arr6)\n",
    "    sorted_arr6 = arr6.copy()\n",
    "    mergeSort(sorted_arr6)\n",
    "    print(\"排序后:\", sorted_arr6)\n",
    "    assert sorted_arr6 == [], \"测试6失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    # 测试7：大范围数值\n",
    "    print(\"=== 测试7：大范围数值 ===\")\n",
    "    arr7 = [-5, 1000000, -2, 0, 42, -999, 77]\n",
    "    print(\"原数组:\", arr7)\n",
    "    sorted_arr7 = arr7.copy()\n",
    "    mergeSort(sorted_arr7)\n",
    "    print(\"排序后:\", sorted_arr7)\n",
    "    assert sorted_arr7 == [-999, -5, -2, 0, 42, 77, 1000000], \"测试7失败\"\n",
    "    print(\"✓ 通过\\n\")\n",
    "\n",
    "    print(\"✓✓✓ 所有测试用例通过！ ✓✓✓\")\n",
    "\n",
    "# 运行测试\n",
    "test_merge_sort()"
   ],
   "id": "43f2ff5b3b1c85fa",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== 测试1：普通无序数组 ===\n",
      "原数组: [38, 27, 43, 3, 9, 82, 10]\n",
      "排序后: [3, 9, 10, 27, 38, 43, 82]\n",
      "✓ 通过\n",
      "\n",
      "=== 测试2：已排序数组 ===\n",
      "原数组: [1, 2, 3, 4, 5]\n",
      "排序后: [1, 2, 3, 4, 5]\n",
      "✓ 通过\n",
      "\n",
      "=== 测试3：逆序数组 ===\n",
      "原数组: [9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "排序后: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "✓ 通过\n",
      "\n",
      "=== 测试4：重复元素数组 ===\n",
      "原数组: [5, 2, 5, 1, 3, 2, 1, 4]\n",
      "排序后: [1, 1, 2, 2, 3, 4, 5, 5]\n",
      "✓ 通过\n",
      "\n",
      "=== 测试5：单元素数组 ===\n",
      "原数组: [42]\n",
      "排序后: [42]\n",
      "✓ 通过\n",
      "\n",
      "=== 测试6：空数组 ===\n",
      "原数组: []\n",
      "排序后: []\n",
      "✓ 通过\n",
      "\n",
      "=== 测试7：大范围数值 ===\n",
      "原数组: [-5, 1000000, -2, 0, 42, -999, 77]\n",
      "排序后: [-999, -5, -2, 0, 42, 77, 1000000]\n",
      "✓ 通过\n",
      "\n",
      "✓✓✓ 所有测试用例通过！ ✓✓✓\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Q1 合并两个有序数组\n",
    "\n",
    "给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列.\n",
    "\n",
    "注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n\n",
    "\n",
    "【示例】：\n",
    "- 输入：nums1 = \\[1,2,3,0,0,0], m = 3, nums2 = \\[2,5,6], n = 3\n",
    "- 输出：\\[1,2,2,3,5,6]\n",
    "- 解释：需要合并 \\[1,2,3] 和 \\[2,5,6] 。\n",
    "- 合并结果是 \\[1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素"
   ],
   "id": "9b0fcb6a01c3a170"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Q2:分发饼干\n",
    "\n",
    "假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干\n",
    "\n",
    "对每个孩子 i，都有一个胃口值 g\\[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s\\[j] 。如果 s\\[j] >= g\\[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。\n",
    "\n",
    "【示例】：\n",
    "- 输入: g = \\[1,2,3], s = \\[1,1]\n",
    "- 输出: 1\n",
    "- 解释:\n",
    "- 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。所以你应该输出1。"
   ],
   "id": "1595164a554697b2"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Q3:算法复杂度分析\n",
    "\n",
    "【归并排序】：\n",
    "- merge函数分析：\n",
    "    - 基础情况：n=0时，数组是空的，函数直接返回，不执行任何操作\n",
    "    - 假设：对于n=k时，merge能正确归并，且时间复杂度为θ(k)\n",
    "    - 归纳：当n=k+1时，\n",
    "        - 每次递归调用时选择L或R分支的最大值，并放入arr\\[b-1]，是θ(1)操作\n",
    "        - 根据假设，n-1的时间复杂度为θ(k)\n",
    "        - 总时间复杂度为:T(k+1) = T(k) + θ(1)\n",
    "        - 解得T(n) = θ(n)，也可表示为O(n)\n",
    "\n",
    "- mergeSort函数分析：\n",
    "    - 基础情况:n=1时，数组只有一个元素，已经被分类好\n",
    "    - 假设：对于所有n>k，归并排序能在T(k)=θ(klogk)时间内完成排序\n",
    "    - 归纳：对规模为n的数组\n",
    "        - 分割：将数组分为两半，各规模为n/2，递归排序，时间复杂度为T(n/2) = θ($\\frac{n}{2}log\\frac{n}{2}$)\n",
    "        - 合并：耗时为θ(n)\n",
    "        - 总时间：T(n) = 2θ($\\frac{n}{2}log\\frac{n}{2}$)+θ(n) = θ(nlogn)，也可表示为O(nlogn)\n",
    "\n",
    "【希尔排序】：\n",
    "- gapInserionSort函数分析：\n",
    "\n",
    "对每个gap值，子序列个数为gap个，子序列的长度为n/gap，最坏情况下，插入排序的时间复杂度为O($(\\frac{n}{gap})^2$)，总时间为个数×单个时间 = O($\\frac{n^2}{gap}$)\n",
    "\n",
    "而gap的取值为n/2,n/4,...,1，T(n)等于每个gap值的时间的总和，求和得T(n)=O(n^2)"
   ],
   "id": "89c24fb57b4919c9"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-10T14:23:03.681832Z",
     "start_time": "2025-05-10T14:22:51.093654Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import timeit\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "\n",
    "# 修改后的非递归归并排序实现\n",
    "def mergeSort(arr):\n",
    "    current_size = 1\n",
    "    n = len(arr)\n",
    "\n",
    "    while current_size < n:\n",
    "        left = 0\n",
    "        while left < n:\n",
    "            mid = min(left + current_size - 1, n - 1)\n",
    "            right = min(left + 2 * current_size - 1, n - 1)\n",
    "\n",
    "            # 合并arr[left..mid]和arr[mid+1..right]\n",
    "            temp = []\n",
    "            i, j = left, mid + 1\n",
    "            while i <= mid and j <= right:\n",
    "                if arr[i] <= arr[j]:\n",
    "                    temp.append(arr[i])\n",
    "                    i += 1\n",
    "                else:\n",
    "                    temp.append(arr[j])\n",
    "                    j += 1\n",
    "            while i <= mid:\n",
    "                temp.append(arr[i])\n",
    "                i += 1\n",
    "            while j <= right:\n",
    "                temp.append(arr[j])\n",
    "                j += 1\n",
    "\n",
    "            for i in range(len(temp)):\n",
    "                arr[left + i] = temp[i]\n",
    "\n",
    "            left = right + 1\n",
    "        current_size *= 2\n",
    "    return arr\n",
    "\n",
    "# 其他排序算法保持不变\n",
    "def gapInsertionSort(arr, start=0, gap=None):\n",
    "    if gap is None:\n",
    "        gap = 1\n",
    "    for i in range(start, len(arr), gap):\n",
    "        curr = arr[i]\n",
    "        pos = i\n",
    "        while pos >= gap and curr < arr[pos-gap]:\n",
    "            arr[pos] = arr[pos-gap]\n",
    "            pos -= gap\n",
    "        arr[pos] = curr\n",
    "\n",
    "def shellSort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    length = len(arr)\n",
    "    gap = length // 2\n",
    "    while gap > 0:\n",
    "        for start in range(gap):\n",
    "            gapInsertionSort(arr, start, gap)\n",
    "        gap = gap // 2\n",
    "    return arr\n",
    "\n",
    "def insertionSort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        curr = arr[i]\n",
    "        pos = i\n",
    "        while pos > 0 and curr < arr[pos-1]:\n",
    "            arr[pos] = arr[pos-1]\n",
    "            pos -= 1\n",
    "        arr[pos] = curr\n",
    "    return arr\n",
    "\n",
    "def bubbleSort(arr):\n",
    "    n = len(arr)\n",
    "    while n > 1:\n",
    "        for i in range(n-1):\n",
    "            if arr[i] > arr[i+1]:\n",
    "                arr[i], arr[i+1] = arr[i+1], arr[i]\n",
    "        n -= 1\n",
    "    return arr\n",
    "\n",
    "def findSmallest(arr):\n",
    "    smallest = arr[0]\n",
    "    smallestIndex = 0\n",
    "    for i in range(1, len(arr)):\n",
    "        if arr[i] < smallest:\n",
    "            smallest = arr[i]\n",
    "            smallestIndex = i\n",
    "    return smallestIndex\n",
    "\n",
    "def selectionSort(arr):\n",
    "    sortedArr = []\n",
    "    for _ in range(len(arr)):\n",
    "        smallest = findSmallest(arr)\n",
    "        sortedArr.append(arr.pop(smallest))\n",
    "    return sortedArr\n",
    "\n",
    "# 测试函数\n",
    "def test_sorting_algorithms():\n",
    "    # 测试数据规模\n",
    "    sizes = [100, 500, 1000, 2000, 5000]\n",
    "    algorithms = {\n",
    "        'Merge Sort': mergeSort,\n",
    "        'Shell Sort': shellSort,\n",
    "        'Insertion Sort': insertionSort,\n",
    "        'Bubble Sort': bubbleSort,\n",
    "        'Selection Sort': selectionSort\n",
    "    }\n",
    "\n",
    "    # 存储时间结果\n",
    "    results = {name: [] for name in algorithms}\n",
    "\n",
    "    for size in sizes:\n",
    "        # 生成随机测试数据\n",
    "        test_data = [random.randint(0, 10000) for _ in range(size)]\n",
    "\n",
    "        for name, algorithm in algorithms.items():\n",
    "            # 复制数据以避免修改原始数据\n",
    "            data = test_data.copy()\n",
    "\n",
    "            # 测量执行时间（运行3次取平均）\n",
    "            if name in ['Merge Sort', 'Shell Sort'] and size > 2000:\n",
    "                runs = 1  # 大数据规模减少运行次数\n",
    "            else:\n",
    "                runs = 3\n",
    "\n",
    "            time_taken = timeit.timeit(\n",
    "                lambda: algorithm(data.copy()),\n",
    "                number=runs\n",
    "            ) / runs\n",
    "\n",
    "            results[name].append(time_taken)\n",
    "            print(f\"{name} with size {size}: {time_taken:.6f} sec\")\n",
    "\n",
    "    # 绘制结果图表\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    for name, times in results.items():\n",
    "        plt.plot(sizes, times, 'o-', label=name)\n",
    "\n",
    "    plt.xlabel('Data Size (N)')\n",
    "    plt.ylabel('Execution Time (seconds)')\n",
    "    plt.title('Sorting Algorithm Performance Comparison')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 运行测试\n",
    "test_sorting_algorithms()"
   ],
   "id": "b79cfc2e1c5efa92",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merge Sort with size 100: 0.000291 sec\n",
      "Shell Sort with size 100: 0.000212 sec\n",
      "Insertion Sort with size 100: 0.000403 sec\n",
      "Bubble Sort with size 100: 0.000730 sec\n",
      "Selection Sort with size 100: 0.000317 sec\n",
      "Merge Sort with size 500: 0.001764 sec\n",
      "Shell Sort with size 500: 0.001413 sec\n",
      "Insertion Sort with size 500: 0.009596 sec\n",
      "Bubble Sort with size 500: 0.016052 sec\n",
      "Selection Sort with size 500: 0.005246 sec\n",
      "Merge Sort with size 1000: 0.003405 sec\n",
      "Shell Sort with size 1000: 0.002858 sec\n",
      "Insertion Sort with size 1000: 0.035202 sec\n",
      "Bubble Sort with size 1000: 0.082035 sec\n",
      "Selection Sort with size 1000: 0.022516 sec\n",
      "Merge Sort with size 2000: 0.007122 sec\n",
      "Shell Sort with size 2000: 0.006942 sec\n",
      "Insertion Sort with size 2000: 0.156455 sec\n",
      "Bubble Sort with size 2000: 0.343759 sec\n",
      "Selection Sort with size 2000: 0.116718 sec\n",
      "Merge Sort with size 5000: 0.020754 sec\n",
      "Shell Sort with size 5000: 0.021697 sec\n",
      "Insertion Sort with size 5000: 1.025421 sec\n",
      "Bubble Sort with size 5000: 1.764146 sec\n",
      "Selection Sort with size 5000: 0.503047 sec\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 5
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}