经典排序记录

1、冒泡排序

平均复杂度：O(N^2),空间复杂度：O(1),稳定性：稳定

template<typename T>
void BubbleSort（T arr[],int len)
{
    int i,j;
    for(i=0;i<len-1;++i)
    {
        for(j=0;j<len-1-i;++j)
        {
            if(arr[j]>arr[j+1])
            {
                swap(arr[j],arr[j+1]);
            }
        }
    }
}

2、选择排序

平均复杂度：O(N^2), 空间复杂度：O(1),稳定性：不稳定

template<typename T>
void SelectSort(vector<T>& arr)
{
    for(int i=0;i<arr.size()-1;i++)
    {
        int min=i;
        for(int j=i+1;j<arr.size();j++)
        {
            if(arr[j]<arr[min]
            {
                min=j;
            }
        }
        swap[arr[i],arr[min]);
    }

3、插入排序

平均时间复杂度：0(N^2), 空间复杂度：O(1),稳定性：稳定

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[1 + end];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else 
			{
				break;
			}
			
		}
		a[end + 1] = tmp;
	}

}

4、希尔排序

平均时间复杂度：0(NlogN），空间复杂度：O(1) ，稳定性：不稳定

void ShellSort(int* a, int n)
{
	int gap;
	for (int i = 0; i < gap; i++)
	{
		for (int j = 0; j < n - gap; j += gap)
		{
			int end = j;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else 
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

5、归并排序

平均时间复杂度：0(NlogN），空间复杂度：O(N) ，稳定性：稳定

void _mergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
	{
		return;
	}
	int  mid = (begin + end) / 2;
	_mergeSort(a, begin, mid, tmp);
	_mergeSort(a, mid + 1, end, tmp);
	
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int tmpbegin = begin;
	while(begin1<=end1&&begin2<=end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[tmpbegin++] = a[begin1];
		}
		else {
			tmp[tmpbegin++] = a[begin2];
		}
	}
	memcpy(a+begin, tmp+begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	_mergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

6、快速排序

平均时间复杂度：0(NlogN），空间复杂度：O(logN) ，稳定性：不稳定

int PartSort(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		while (left<right&&a[right] >= a[keyi])
		{
			right--;
		}
		while (left<right&&a[left] <= a[keyi])
		{
			left++;
		}
		swap(a[left], a[right]);
	}
	swap(a[keyi], a[left]);  
	return left;
}
void QuickSort(int* a, int begin,int end)
{
	int keyi = PartSort(a, begin, end);
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);  
}

7、堆排序

平均时间复杂度：0(NlogN），空间复杂度：O(1) ，稳定性：不稳定

void Adjustdown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;

	while (child<n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(a[child], a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
	
}
void HeapSort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		Adjustdown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		swap(a[0], a[end]);
		Adjustdown(a, end, 0);
		end--;
	}
}