常用排序算法

一，选择排序

二，冒泡排序

def buble_sort(a):
    count = 0
    for i in range(len(a)):
        for j in range(len(a)-i-1):
            count += 1
            if a[j]>a[j+1]:
                a[j],a[j+1] = a[j+1],a[j]
    print('count is ',count)

def buble_sort1(a):
    flag = True
    count = 0
    while flag:
        flag = False
        for j in range(len(a)-1):
            count += 1
            if a[j]>a[j+1]:
                a[j],a[j+1] = a[j+1],a[j]
                flag = True
    print('count is ',count)
    
def buble_sort2(a,n,m):
    flag = m
    count = 0
    while flag>0:
        flag = 0
        for j in range(n,m-1):
            count += 1
            if a[j]>a[j+1]:
                a[j],a[j+1] = a[j+1],a[j]
                flag = m
    print('count is ',count)
                
if __name__ == '__main__':
    b = [1,2,3,4,6,5,4]
    b = [3,2,1,4,4,5,6]
    b1 = [3,2,1,4,4,5,6]
    b2 = [3,2,1,4,4,5,6]
    buble_sort(b)
    buble_sort1(b1)
    buble_sort2(b2,0,3)
    print(b)
    print(b1)
    print(b2)

运行结果如下：

count is  21
count is  18
count is  6
[1, 2, 3, 4, 4, 5, 6]
[1, 2, 3, 4, 4, 5, 6]
[1, 2, 3, 4, 4, 5, 6]

三，希尔排序

原理：将一组数据，以增量形式分为div组，然后对每组进行排序，增量再继续减少，直到div=1，具体实现代码如下：

#include <iostream>
using namespace std;
void swap(int&a,int&b)
{
	int c = a;
	a = b;
	b = c;
}

void shell_sort(int a[],int count)
{
	int div = count;
	do
	{
		div = div/3 + 1;//增量的选择
		for(int i = 0; i < div; i++)
			for(int j = i; j < count-div; j+=div)//对每一列进行选择排序
				for(int k = j+div; k < count;k+=div)
				{
					if(a[j] > a[k]) swap(a[j],a[k]);
				}
	}while(div > 1);//当增量为1时进行最后一次排序结束
}
int main()
{
	int a[10] = {1,3,5,7,9,2,4,6,8,0};
	shell_sort(a,10);
	for(int i = 0; i < 10; i++)
		cout << a[i] << endl;
	system("pause");
	return 0;
}

四，插入排序

这是针对一个序列，前面部分为有序的序列而言，插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

#include <iostream>
using namespace std;

void insert_sort(int a[],unsigned int first,unsigned int last)
{
	for(int i = first+1; i < last; i++)
	{
		int j = i-1;
		int temp = a[i];
		while(j >= 0 && a[j] > temp)
		{
			a[j+1] = a[j];
			j--;
		}
		a[j+1] = temp;
	}
}
int main()
{
	int a[10] = {1,2,5,7,9,3,4,6,8,0};
	insert_sort(a,4,10);
	for(int i = 0; i < 10; i++)
		cout << a[i] << endl;
	system("pause");
	return 0;
}

五，快速排序

#include <iostream>
using namespace std;

void quick_sort(int a[],int low,int high)
{
	if(low >= high) return;
	int left = low;
	int right = high;
	int key = a[low];
	while(left < right)
	{
		while(left < right && a[right] >= key)
			right--;
		a[left] = a[right];
		while(left < right && a[left] <= key)
			left++;
		a[right] = a[left];
		
	}
	a[left] = key;
	quick_sort(a,low,left-1);
	quick_sort(a,left+1,high);
}
int main()
{
	
	int a[11] = {1,7,5,7,9,2,4,6,8,10,11};
	int t[11];
	quick_sort(a,0,10);
	for(int i = 0; i < 11 ; i++)
		cout << a[i] << endl;
	system("pause");
	return 0;
}

 

六，归并排序

 

采用的思想主要就是分治，分而治之，具体思路如下：

 

合并图解如下：

最后将temp全数拷贝到原数组中，具体代码实现如下：

#include <iostream>
using namespace std;
/************合并******************/
/*将组数组的两边为有序合并为一组，如a[10] = {0,2,4,6,,8,1,3,5,7,9}——>a[10]={0,1,2,3,4,5,6,7,8,9}*/
/*********************************************/
void merg(int a[],int t[],int start,int mid,int end)
{
	
	int i = start;
	//mid = (start+end)/2;
	int j = mid +1;
	int k = start;
	while(i <= mid && j <= end)
	{
		if(a[i] > a[j])
			t[k++] = a[j++];
		else
			t[k++] = a[i++];
	}
	while(i <= mid)
		t[k++] = a[i++];
	while(j <= end)
		t[k++] = a[j++];
	k = 0;
	while(k <= end)
		a[k] = t[k++];

}
/*******************将一个数组一直分直到不可再分*****************/
void merg_sort(int a[],int t[],int start,int end)
{
	
	if(start < end)
	{
		int mid = (start+end)/2;
		merg_sort(a,t,start,mid);
		merg_sort(a,t,mid+1,end);
		merg(a,t,start,mid,end);
	}
}
int main()
{
	
	int a[11] = {1,7,5,7,9,2,4,6,8,10,11};
	int t[11];
	merg_sort(a,t,0,10);
	for(int i = 0; i < 11 ; i++)
		cout << a[i] << endl;
	system("pause");
	return 0;
}