五种排序（冒泡排序、选择排序、插入排序、快速排序）

五种排序Python和C++实现

Python代码

import random
a = []
while len(a)<10:
    a.append(random.randrange(1,20))
# 生成一个待排序的列表
print(a)

'''冒泡排序：每轮从前往后两两比较，每轮可排序好一个位置'''
def MaopaoSort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > a[j+1]:
                temp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = temp
    return arr
# 验证
print(MaopaoSort(a))

'''选择排序：数组中每个位置都进行一轮遍历，与后面元素比较，将最小的元素放到前面'''
def ChooseSort(arr):
    n = len(arr)
    for i in range(n):
        minind = i
        for j in range(i+1,n):
            if arr[j] < arr[minind]:
                # 记录最小值的索引
                minind = j
        if minind != i:
            temp = arr[minind]
            arr[minind] = arr[i]
            arr[i] = temp
    return arr
# 验证
print(ChooseSort(a))

'''插入排序：第一轮把数组第一个元素当作有序序列，第二个到最后的元素当作无序序列，
从头到尾扫描无序序列，取出元素插入到有序序列合适的位置（如果相等插到后面）'''
def InsertSort(arr):
    n = len(arr)
    for i in range(n):
        preind = i-1
        current = arr[i]
        # 如果有序序列的元素大于current，那么把current插入到正确的位置，
        # 并且那些大于有序序列中大于current的索引向后+1
        while preind >= 0 and arr[preind] > current:
            arr[preind+1] = arr[preind]
            preind-=1
        arr[preind+1] = current
    return arr
# 验证
print(InsertSort(a))

'''快速排序：选择数组左边第一个数作为基准数，分别从左右两边与基准数比较，
左边出发找到大于基准数的与右边出发小于基准数的交换，最终相遇时那个index是基准数的，
注意：由于我们是先从右往左找，r最后到的位置是小于基准数的，所以交换他们就完成这一阶段排序，
然后开始递归'''
def QuickSort(arr):
    n = len(arr)

    def quick(left,right):
        if left>=right:
            return arr
        key = left
        l = left
        r = right
        while l<r:
            while l < r and arr[r] >= arr[key]:
                r -= 1
            while l < r and arr[l] <= arr[key]:
                l += 1
            arr[l], arr[r] = arr[r], arr[l]
        arr[key], arr[r] = arr[r], arr[key]
        quick(left, r-1)
        quick(r+1, right)
        return arr

    return quick(0, n-1)
# 验证
print(QuickSort(a))


//归并排序
'''归并排序练习'''
import random
a = []
while len(a)<10:
    a.append(random.randrange(1, 20))
# 生成一个待排序的列表
print(a)
def Merge(nums, left, mid, right):
    n1 = mid - left + 1
    n2 = right - mid
    temp1 = [0 for i in range(n1)]
    temp2 = [0 for i in range(n2)]
    for i in range(0, n1):
        temp1[i] = nums[left+i]
    for i in range(0, n2):
        temp2[i] = nums[mid+1+i]
    i = 0
    j = 0
    k = left
    while i < n1 and j < n2:
        if temp1[i] <= temp2[j]:
            nums[k] = temp1[i]
            i += 1
        else:
            nums[k] = temp2[j]
            j += 1
        k += 1
    while i < n1:
        nums[k] = temp1[i]
        i += 1
        k += 1
    while j < n2:
        nums[k] = temp2[j]
        j += 1
        k += 1

def MergeSort(nums, left, right):
    if left >= right:
        return
    mid = (right + left) // 2

    MergeSort(nums, left, mid)
    MergeSort(nums, mid+1, right)
    Merge(nums, left, mid, right)

MergeSort(a, 0, 9)
print(a)

归并排序python实现这里有几个坑，一个是python里整除用//，之前C++写多了只有/就行，再有就是temp1和temp2那里如果不弄成数组装数而是选择append进去会出现temp2或者temp1是空的，但是后面索引他报错的情况

C++代码

#include<iostream>
using namespace std;
#include<vector>

// 冒泡排序
vector<int> MaopaoSort(vector<int>& arr){
   int n = arr.size();
   for(int i=0;i<n;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;         
         }
      }
   }
   return arr;
}

// 选择排序
vector<int> SelectSort(vector<int>& arr){
   int n = arr.size();
   for(int i=0;i<n;i++){
      int minind = i;
      for(int j=i+1;j<n;j++){
         if(arr[j]<arr[minind]){
            minind = j;
         }
      }
      if(minind!=i){
         int temp = arr[minind];
         arr[minind] = arr[i];
         arr[i] = temp;
      }
   }
   return arr;
}

// 插入排序
vector<int> InsertSort(vector<int>& arr){
   int n = arr.size();
   for(int i=0;i<n;i++){
      int preind = i-1;
      int current = arr[i];
      while(preind>=0 && arr[preind]>current){
         arr[preind+1] = arr[preind];
         preind--;
      }
      arr[preind+1]=current;
   }
   return arr;
}

// 快速排序
vector<int> quick(vector<int>& arr,int left,int right){
   if(left>=right) return arr;
   int key = left;
   int l = left;
   int r = right;
   while(l<r){
      while(l<r && arr[r]>=arr[key]) r--;
      while(l<r && arr[l]<=arr[key]) l++;
      swap(arr[l],arr[r]);
   }
   swap(arr[key],arr[r]);
   quick(arr,left,l-1);
   quick(arr,l+1,right);
   return arr;
}
vector<int> QuickSort(vector<int>& arr){
   int n = arr.size();
   return quick(arr,0,n-1);
}

int main(){
   // 定义输入多少个数的数组
   int n; 
   cin>>n;
   vector<int> arr(n);
   for(int i=0;i<n;i++){
      cin>>arr[i];
   }
   // vector<int> res = MaopaoSort(arr);
   // vector<int> res = SelectSort(arr);
   // vector<int> res = InsertSort(arr);
   vector<int> res = QuickSort(arr);
   for(int i=0;i<n;i++){
      cout<<res[i]<<" ";
   }
   return 0;
}