一、基本的排序算法
1、冒泡排序
基本思想：
n个数一共要进行n-1趟排序，每一趟排序都是两两比较，小的数一路交换着往前走，大的数就自然往后靠，每一趟排序都会确定一个数的最终位置。
#冒泡排序python实现
def BubbleSort():
arr = [9,5,12,8,3,11]
for i in range(len(arr)-1):
for j in range(i+1,len(arr)):
if arr[j]//冒泡排序c++实现
#include
#include "stdio.h"
using namespace std;
void BubbleSort(){
int arr[6] = {9,5,12,8,3,11};
int length = sizeof(arr)/sizeof(arr[0]);
for(int i=0;i 2、选择排序
基本思想：
从下标0开始遍历整个数组，找到最小的数与下标为0的数交换位置，然后从下标1开始遍历数组，找到最小的与下标为1的数交换位置......直到遍历完整个数组。
#选择排序python实现
def SelectSort():
arr = [9,5,12,8,3,11]
for i in range(len(arr)):
indexOfmin = i
for j in range(i+1,len(arr)):
if arr[j]//选择排序c++实现
#include
#include "stdio.h"
using namespace std;
void SelectSort(){
int arr[6] = {9,5,12,8,3,11};
int length = sizeof(arr)/sizeof(arr[0]);
for(int i=0;i 3、插入排序
基本思想：
对于一个待排序的数组，把下标为0的第一个数字看作是“排好序”的数组，然后从下标为1的第二个数开始，依次与“排好序”的数字比较，并适当移动“排好序”的数字并把该数字插到合适的位置，直到整个数组遍历完毕。
#插入排序python实现
def InsertSort():
arr = [9,5,12,8,3,11]
for i in range(len(arr)-1):
for j in range(i+1,0,-1):
if arr[j]//插入排序c++实现
#include
#include "stdio.h"
using namespace std;
void InsertSort(){
int arr[6] = {9,5,12,8,3,11};
int length = sizeof(arr)/sizeof(arr[0]);
for(int i=0;i0;j--){
if(arr[j] 4、快速排序
基本思想：
使用分治法（Divide and conquer）策略来把一个序列分为较小和较大的2个子序列，然后递归地排序两个子序列。
1、挑选基准值：从数列中挑出一个元素，称为“基准”（pivot），
2、分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成，
3、递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。
看这个图我觉得能很好的帮助你理解原理。
#快速排序python实现
def Partition(arr, left, right):#切分：找基准点
i,j = left,right
# i < j 意味着还没有找到基准点
while (i < j):
# 从右边开始，保证i < j并且arr[i]小于或者等于arr[j]，即左边的数小于等于右边的数
while (i < j and arr[i] <= arr[j]):
j-=1
# 跳出循环，两种可能：j >= i 或者arr[i]大于arr[j]。如果是前者，就直接跳出大循环了，返回基准点；如果是后者，那就意味着右边的数小于左边的数了，所以需要将两个数交换位置。
if (i < j):
arr[i],arr[j] = arr[j],arr[i]
#右边的数小于左边的数，交换位置之后就要从左边往右边开始遍历、比较、交换。
while (i < j and arr[i] <= arr[j]):
i+=1
if (i < j):
arr[i],arr[j] = arr[j],arr[i]
# i>=j 说明基准点已经找到了
return i
def QuickSort(arr,left,right):#递归调用：对由基准点分开的小数组进行排序
if (left//快速排序c++实现
#include
#include "stdio.h"
using namespace std;
int Partition(int arr[],int left,int right){
while(left=arr[right]){
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
while(left=arr[right]){
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
}
return left;
}
int QuickSort(int arr[],int left,int right){
if(left 5、希尔排序
基本思想：
希尔排序又称为“缩小增量排序”。对于有n个待排序元素的序列，首先取一个整数step(step 堆排序是利用堆这个数据结构而设计的一种排序算法。堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 归并排序的核心思想是“分治”。主要就是两个步骤：#希尔排序python实现
def ShellSort(arr):
step = len(arr)//2
while step>=1:
for i in range(step,len(arr)):
for j in range(i,step-1,-step):
if arr[j]//希尔排序c++实现
#include 6、堆排序
基本思想：
主要步骤为：1、建堆；2、交换调整。#堆排序python实现
def BuildHeap(arr,start,length):
while 2*start+1 <= length :
j = 2*start+1
if j//堆排序c++实现
#include 7、归并排序
基本思想：
分割：递归地把当前序列平均分割成两半。
#归并排序python实现
def merge_sort(alist):
if len(alist) <= 1:
return alist
# 将大数组分解成一个个只有一个元素的数组
num = len(alist) // 2
left = merge_sort(alist[:num])
right = merge_sort(alist[num:])
# 返回合并后的结果
return merge(left, right)
def merge(left, right):
'''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
# l与r为两个有序数组left[]和right[]的下标索引
l, r = 0, 0
result = []
#两个有序数组left[]和right[]都没有合并完就一直比较下去
while l < len(left) and r < len(right):
if left[l] < right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
#跳出while循环，把两个有序数组left[]和right[]剩下的元素直接加到大数组后面
result += left[l:]
result += right[r:]
return result
print(merge_sort([9,5,12,8,3,11]))
//归并排序c++实现
#include