算法学习之-基本排序算法（时间复杂度O(n^2)）

1.选择排序

  基本逻辑是：从0开始遍历选出最大值与0位交换，从1开始遍历再次选出最大值与1交换........，下面是代码，使用模板方法实现且增加了如何对自定以类进行排序

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

///选择排序,每次循环选出最大值，依次放到数组的[0][1][2]....中
template <class T>
void selectionSort(T arr[],int size)
{
	for(int i=0;i<size;i++)
	{
		int minIndex = i;
		for(int j=i;j<size;j++)
		{
			if(arr[minIndex]<arr[j])
				minIndex = j;
		}
		swap(arr[i],arr[minIndex]);
	}
}

///输出数组
template <typename T>
void printArr(T arr[],int size)
{
	cout<<"[";
	for(int i=0;i<size;i++)
	{
		if(i==size-1)
			cout<<arr[i];
		else
			cout<<arr[i]<<",";
	}
	cout<<"]"<<endl;
}

///自定义类型排序
struct student{
	int score;
	string name;

	bool operator<(student otherStudent)
	{
		return score!=otherStudent.score ? score<otherStudent.score : name<otherStudent.name;
	}

	friend ostream& operator<<(ostream& os,student st)
	{
		os<<"Student "<<st.name<<" "<<"Score"<<st.score<<endl;
		return os;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	//整形数组
	int arr[10] = {3,5,3,6,5,1,9,8,7,0};
	selectionSort(arr,10);
	printArr(arr,10);
	//double型
	double dArr[10] = {3.2,3.4,9.0,8.8,7,3,7,5,9,8.96};
	selectionSort(dArr,10);
	printArr(dArr,10);
	//char型
	char cArr[5] = {'D','M','Y','K','T'};
	selectionSort(cArr,5);
	printArr(cArr,5);
	//自定义类型
	student students[4] = {{88,"A"},{89,"I"},{97,"K"},{90,"L"}};
	selectionSort(students,4);
	printArr(students,4);

	cin.get();
	return 0;
}

2.插入排序

   基本逻辑是：从0到n依次取值，每次取值使得arr[i-1] < arr[i]，代码实现如下：

template<typename T>
static void insertSort(T arr[],int size)
{
	for(int i=1;i<size;i++)
	{
		for(int j=i;j>0;j--)
		{
			if(arr[j]<arr[j-1])
				swap(arr[j],arr[j-1]);
			else
				break;
		}
	}
}

插入排序与选择排序的比较：选择排序对于第二层循环每次都要全部执行一遍，而插入排序可以提前退出，但这并不意味着插入排序的效率优于选择排序，因为选择排序的更多步骤是取值比较，交换操作很少，插入排序频繁的进行交换操作，交换操作更耗费时间。

3.插入排序优化（实用）

基本思想是在插入排序的基础上用赋值减少交换操作，代码实现如下：

template<typename T>
static void insertSortPlus(T arr[],int size)
{
	for(int i=1;i<size;i++)
	{
		T num = arr[i];
		int j;
		for(j=i;j>0;j--)
		{
			if(num<arr[j-1])
			{
				//swap(arr[j],arr[j-1]);
				arr[j] = arr[j-1];
			}
			else
			{
				break;
			}
		}
		arr[j] = num;
	}
}

在进入二层循环前保存arr[i]，这样使得之前的交换数组元素操作（三次赋值）简化成了一次赋值，效率提高了接近三倍。而且在对本身就接近有序的数组排序时非常高效，比O(nlogn)时间复杂度的算法还要高效很多，因此O(n^2)算法在某些情况下是更好的选择。

3.冒泡排序

冒泡排序和选择排序有些相似，但在实际应用中意义不大，基本思路是：从0到n遍历（n递减），如果arr[n]>arr[n+1]，则交换数组元素。这样第k次循环后top k最大值放在了数组的倒数第k个位置。代码如下

template<class T>
static void bubbleSort(T arr[],int size)
{
	for(int i=size;i>0;i--)
	{
		for(int j=1;j<i;j++)
		{
			if(arr[j-1]>arr[j])
				swap(arr[j-1],arr[j]);
		}
	}
}