五种经典排序算法C++实现及总结

1、冒泡排序（交换排序，稳定）

冒泡排序（Bubble Sort）,它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

1.1 算法描述

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

1.2 代码实现

void bubbleSort(int *arr, int n)
{
    int tmp = 0;
    int flag = 0;
    for (int i = n - 1; i != 0; --i)
    {
        for (int j = 0; j != i; ++j)
        {
            if (arr[j] > arr[j + 1])
            {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = 1;
            }
        }

        if (flag == 0)
        {
            break;
        }
    }
}


void main()
{   
    int arr[] = { 1, 7, 6, 5, 4, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    print(arr, n);
}

2、简单选择排序（选择排序，不稳定）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 初始状态：无序区为R[1..n]，有序区为空；
• 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
• n-1趟结束，数组有序化了。

2.2 代码实现

void selectionSort(int *arr, int n)
{
    int tmp = 0;
    int min_index = 0;
    for (int i = 0; i != n; ++i)
    {
        min_index = i;
        for (int j = i + 1; j != n; ++j)
        {
           if (arr[min_index] > arr[j])
           {
               min_index = j;
           }
        }

        tmp = arr[i];
        arr[i] = arr[min_index];
        arr[min_index] = tmp;
    }
}

void main()
{   
    int arr[] = { 1, 7, 6, 5, 4, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    print(arr, n);
}

3、简单插入排序（插入排序， 稳定）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

3.2 代码实现

void insertSort(int *arr, int n)
{
    int tmp = 0;
    for (int i = 1; i != n; ++i)
    {
        int j = i - 1;
        tmp = arr[i];
        while (j >= 0 && arr[j] > tmp)
        {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j + 1] = tmp;
    }
}

void main()
{   
    int arr[] = { 1, 7, 6, 5, 4, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    insertSort(arr, n);
    print(arr, n);
}

4、快速排序排序（交换排序， 不稳定）

4.1 算法描述

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

4.2 代码实现

void quickSort(int *arr, int left, int right)
{
    int len = sizeof(arr) / sizeof(arr[0]);
    if (left < right)
    {
        int q = partition(arr, left, right);
        quickSort(arr, left, q - 1);
        quickSort(arr, left + 1, right);
    }
}

int partition(int *arr, int left, int right)
{
    int mid_num = arr[right];
    int mid_index = right;
    for (int i = left; i < right; ++i)
    {
        if (arr[i] > mid_num)
        {
            if (i < mid_num)
            {
                int tmp = arr[i];
                arr[i] = arr[mid_index];
                arr[mid_index] = tmp;
                mid_index = i;
            }
        }
    }
    return mid_index;
}

void main()
{   
    int arr[] = { 1, 7, 6, 5, 4, 2, 3 };
    int arr2[] = { 5, 4, 45, 878, 45 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int n2 = sizeof(arr2)/sizeof(arr2[0]);
    shellSort(arr, n);
    print(arr, n);
    quickSort(arr2, 0, n2);
    print(arr2, n2);
}

5、快速排序排序（插入排序， 不稳定）

5.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

5.2 代码实现

void shellSort(int *arr, int n)
{
    int i, j;
    int increment = n;
    do
    {
        increment = increment / 3 + 1;
        for (i = increment; i != n; ++i)
        {
            if (arr[i] < arr[i - increment])
            {
                int tmp = arr[i];
                for (j = i - increment; j >= 0 && tmp < arr[j]; j -= increment)
                {
                    arr[j + increment] = arr[j];
                }
                arr[j + increment] = tmp;
            }      
        }
    } 
    while (increment > 1);
}

void main()
{   
    int arr[] = { 1, 7, 6, 5, 4, 2, 3 };
    int arr2[] = { 5, 4, 45, 878, 45 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int n2 = sizeof(arr2)/sizeof(arr2[0]);
    shellSort(arr, n);
    print(arr, n);
    quickSort(arr2, 0, n2);
    print(arr2, n2);
}

 

python实现部分算法：

# -- coding: utf-8 --
#冒泡排序
def bubbleSort(arr):
	count = len(arr)		#数组数量
	for i in range (0, count):
		flag = 0			#标志位，判断是否可以提前结束循环
		for j in range(0, count - 1 - i):
			if (arr[j] > arr[j + 1]):
				arr[j], arr[j + 1] = arr[j + 1], arr[j]
				flag = 1
	
		if flag == 0:
			break
			
#选择排序			
def selectionSort(arr):
	count = len(arr)
	min_index = 0
	for i in range (0, count):
		min_index = i
		for j in range(i + 1, count):
			if arr[min_index] > arr[j]:
				min_index = j
		
		arr[i], arr[min_index] = arr[min_index], arr[i]
			
			
#插入排序
def inserSort(arr):
	count = len(arr)
	tmp = 0
	for i in range(0, count):
		j = i - 1
		tmp = arr[i]
		while j >= 0 and arr[j] > tmp:
			arr[j + 1] = arr[j]
 			--join
		arr[j + 1] = tmp	
			
			
			
			
			
if __name__ == '__main__':
	li = [32, 12, 66, 17, 80, 58, 25, 74]
	print(li)
	bubbleSort(li)
	#print('bubbleSort:')
	#print(li)
	# print('selectionSort:')
	# print(li)
	print('inserSort:')
	print(li)