排序算法！~

排序算法很多，这里主要列出几个比较经典的排序算法。

最开始我们最先接触到的排序算法是冒泡排序，冒泡排序是一种比较简单的排序算法，重复的扫描排序过的数组，直到没有数字交换的情况。时间复杂度O（n^2）。

冒泡排序：

void Bullesort(int a[], int n)
{
int i, j, temp;
for(i = 0; i < n; i++)
{
for(j = 0; j < n - 1; j++)
{
if(a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}

选择排序也是比较简单的排序算法，简单来讲，就是找到最小的数或最大的数放在第一位，以此类推。时间复杂度O（n^2）。

选择排序：

void SelectSort(int a[], int n)
{
int i, j, k;
for(i = 0; i < n - 1; i++)
{
k = i;
for(j = i + 1; j < n; j++)
if(a[k] > a[j])
k = j;
if(k != i)
{
a[k] = a[k] ^ a[i];
a[i] = a[i] ^ a[k];
a[k] = a[k] ^ a[i];
}
}
}

插入排序，也是一种简单的排序方法，简单来说，就是将要排序的数组按大小插入到已经排序好的数组中。时间复杂度O（n^2）。

void InertSort(int a[], int n)
{
int i, j;
for(i = 2; i <= n; i++)
{
if(a[i] < a[i - 1])
{
a[0] = a[i];
a[i] = a[i - 1];
for(j = i - 1; a[0] < a[j]; j--)
a[j + 1] = a[j];
a[j + 1] = a[0];
}
}
}

快速排序，一种较为高效的排序方法，简单来说，就是选择一个标志，将大于这个标志的数放在右边，小于的放在左边，然后递归左右两个区间，知道区间只有一个数。时间复杂度为O（n*logn）。

void quicksort(int a[], int n)
{
int i = 0, j = n - 1, val = a[0];
if(n > 1)
{
while(i < j)
{
for(; j > i; j--)
if(a[j] < val)
{
a[i++] = a[j];
break;
}
for(; i < j; i++)
if(a[i] > val)
{
a[j--] = a[i];
break;
}
}
a[i] = val;
quicksort(a, i);
quicksort(a + i + 1, n - i - 1);
}
}

归并排序，也是比较高效的排序方法，简单来说，就是将数组递归分成两个小区间，然后再来合并区间，合并过程中，将区间变成有序。时间复杂度为O（n*logn）。n比较小的时候，归并排序比快排要快，但是n如果很大的话，快排就体现出了优势。

void MergeSort(int a[], int first, int end)
{
void Sort(int a[], int first, int mid, int end);
int mid;
if(first < end)
{
mid = (first + end) / 2;
MergeSort(a, first, mid);
MergeSort(a, mid + 1, end);
Sort(a, first, mid, end);
}
}
void Sort(int a[], int first, int mid, int end)  //合并的函数
{
int i, j, k, temp[10];
i = first; j = mid + 1; k = first;
while(i <= mid && j <= end)
{
if(a[i] > a[j])
{
temp[k++] = a[j++];
}
else
{
temp[k++] = a[i++];
}
}
while(i <= mid)
{
temp[k++] = a[i++];
}
while(j <= end)
{
temp[k++] = a[j++];
}
for(i = first; i <= end; i++)
a[i] = temp[i];
}