冒泡排序和快速排序C++和python实现

冒泡排序(BubbleSort ['bʌbl] [sɔrt] )

基本思想
比较相邻的两个元素，将值大的元素交换到右边（降序则相反）
步骤：
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。
python实现：

# -*- coding: utf-8 -*-
def BubbleSort(array):
    lengths = len(array)
    for i in range(lengths-1):
        for j in range(lengths-i-1):
            if array[j]>array[j+1]:
                array[j+1],array[j]=array[j],array[j+1]
    return array

array=[1,5,8,9,7,6,2,4,3]
print('Original arry:',array)
array=BubbleSort(array)
print("BubbleSort:",array)

array1=input("input array1")
print('Original arry1:',array1)
# 例如输入的line是：1 2 3 4
# 对于字符串，先使用split方法按空格进行分割，结果为：['1', '2', '3', '4']
# 然后map函数将int函数迭代作用到每个元素上，最后用list使其成为一个整型数组
list_input=list(map(int,array1.split()))
list_input=BubbleSort(list_input)
print("BubbleSort:",list_input)

C++实现：

#include <iostream>
using namespace std;

void bubbleSort(int* pData, int length)
{
	int temp;
	for (int i = 0; i <= length-1; i++)
	{
		for (int j = 0; j <= length - 1 -i-1;j++)
		{
			if (pData[j] > pData[j+1])
			{
				temp = pData[j];
				pData[j] = pData[j+1];
				pData[j+1] = temp;
			}
		}
	}
}

void print(int* pData, int length)
{
	for (int i = 0; i <= length - 1; i++)
	{
		cout << pData[i] << " ";
	}
	cout << endl;
}

int main(int argc, const char * argv[])
{
	int pData[] = { 2,3,7,1,6 };
	bubbleSort(pData, 5);

	cout << "the result is:";

	print(pData, 5);

	return 0;
}

快速排序（quick sort）

基本思想
快速排序（quick sort）：通过一趟排序将待排列表分隔成独立的两部分，其中一部分的所有元素均比另一部分的所有元素小，则可分别对这两部分继续重复进行此操作，以达到整个序列有序。（这个过程，我们可以使用递归快速实现）
步骤
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
从数列中挑出一个元素，称为 “基准”（pivot），这里我们通常都会选择第一个元素作为prvot；
重新排序数列，将比基准值小的所有元素放在基准前面，比基准值大的所有元素放在基准的后面（相同的数可以到任一边）。这样操作完成后，该基准就处于新数列的中间位置，即将数列分成了两部分。这个操作称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数按上述操作进行排序。这里的递归结束的条件是序列的大小为0或1。此时递归结束，排序就完成了。
python实现：

def QuickSort(array,start,end):
    lengths=len(array)
    i=start
    j=end
    if i>=j:
        return
    pivot=array[i]
    while i<j:
        while i<j and pivot<=array[j]:
            j-=1
        array[i]=array[j]
        while i<j and pivot>=array[i]:
            i+=1
        array[j]=array[i]
    array[i]=pivot
    QuickSort(array,start,i-1)
    QuickSort(array,i+1,end)
    return array
if __name__=='__main__':
    array=[1,5,8,44,67,6,15,3]
    print("origianl array",array)
    QuickSort(array,0,len(array)-1)
    print("QuickSort:",array)
       

c++实现：

#include <iostream>// 快速排序函数（递归法）
using namespace std;

 void QuickSort(double list[], int start, int end)
	   {   
		int i = start;
	    int j = end;// 结束排序（左右两索引值见面，即相等，或者左索引>右索引）
		if (i >= j)
		{
			return;
		}
// 保存首个数值（以首个数值作为基准）
// 这个位置很重要，一定要在if i >= j判断语句之后，否则就索引溢出了
		double pivot = list[i];// 一次排序，i和j的值不断的靠拢，然后最终停止，结束一次排序
		
// 一层循环实现从左边起大于基准的值替换基准的位置，右边起小于基准的值位置替换从左起大于基准值的索引
//（从右往左）和最右边的比较，如果 >= pivot, 即满足要求，不需要交换，然后j - 1，慢慢左移，即拿基准值与前一个值比较; 如果值<pivot，那么就交换位置
		while (i < j) {
			while (i < j && pivot <= list[j])
			{
				--j;
			}
		list[i] = list[j];// 交换位置后，（从左往右）然后在和最左边的值开始比较，如果 <= pivot, 然后i + 1，慢慢的和后一个值比较; 如果值>pivot，那么就交换位置
		while (i < j && pivot >= list[i])
		{
			++i;
		}
		list[j] = list[i];
		
		}// 列表中索引i的位置为基准值，i左边序列都是小于基准值的，i右边序列都是大于基准值的，当前基准值的索引为i，之后不变
		list[i] = pivot;
	       // 左边排序
		QuickSort(list, start, i - 1);
		       // 右边排序
		QuickSort(list, i + 1, end);
	    }	
void main()
{
		int i;
	    double a[8] = { 2, 8, 6, 7, 9, 3,1, 4 };
		cout << "original array is:";
		for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
		{
			cout << a[i]<<" ";
			
		}
		cout << endl;
		
		QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
		cout << "quicksort array is:";
		for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
		{
			cout << a[i] << " ";
		}
		cout << endl;
		  
	}