排序算法

冒泡排序：每一次遍历过程中，依次比较相邻元素的大小，从而将最小的元素往上浮，时间复杂度为O(n^2)。

void bubbleSort(int a[],int n)
{
	int i,j;
	for(i=0;i<n-1;i++)  //往上浮 
	{
		for(j=i;j<n-1;j++)
		{
			if(a[j]>a[j+1])
			{
				swap(a[j],a[j+1]);
			}
		}
	}
	for(i=0;i<n-1;i++)     //往下沉 
	{
		for(j=0;j<n-i-1;j++)
		{
			if(a[j]<a[j+1])
			{
				swap(a[j],a[j+1]);
			}
		}
	}
}

插入排序：时间复杂度O(n^2)，对于排好序的数组，时间复杂度为O(n)

void insertSort(int a[],int n)
{
	int i,j;
	for(i=1;i<n;i++)
	{
		int j=i;
		while(j>0&&a[j]<a[j-1])
		{
			swap(a[j],a[j-1]);
			j--;
		}
	}
} 

快速排序：时间复杂度为O(nlogn)

void q_sort(int a[],int l,int r)
{
	if(l>=r)return;
	int x=a[l];
	int i=l,j=r;
	while(i<j)
	{
			while(i<j&&a[j]>=x)
			j--;
			if(j>i)
			a[i++]=a[j];
			while(i<j&&a[i]<x)
			i++;
			if(i<j)
			a[j--]=a[i];
	}
	a[i]=x;
	q_sort(a,l,i-1);
	q_sort(a,i+1,r);
}

归并排序：时间复杂度为O(nlogn)

void mergearray(int a[],int first,int mid,int last,int temp[])
{
	int i=first,j=mid+1;
	int n=mid,m=last;
	int k=0;
	while(i<=n&&j<=m)
	{
		if(a[i]>a[j])
		temp[k++]=a[j++];
		else
		temp[k++]=a[i++];
	}
	while(i<=n)
	temp[k++]=a[i++];
	while(j<=m)
	temp[k++]=a[j++];
	for(i=0;i<k;i++)
	a[first+i]=temp[i];
}
void mergesort(int a[],int first,int last,int temp[])
{
	if(first<last)
	{
		int mid=(first+last)/2;
		mergesort(a,first,mid,temp);
		mergesort(a,mid+1,last,temp);
		mergearray(a,first,mid,last,temp);
	}
}

堆排序：时间复杂度为O(nlogn)

// 新加入i结点  其父结点为(i - 1) / 2 
void MinHeapFixup(int a[],int i)
{
	int temp=a[i];
	int j=(i-1)/2;
	while(j>=0&&i!=0)
	{
		if(temp>=a[j])break;
		a[i]=a[j];
		a[j]=temp;
		i=j;
		j=(i-1)/2;
	}
} 

//在最小堆中加入新的数据nNum 
void MinHeapAddNumber(int a[],int n,int nNum)
{
	a[n]=nNum;
	MinHeapFixup(a,n);
}


// 从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2
void MinHeapFixdown(int a[], int i, int n)  
{  
    int j, temp;  
  
    temp = a[i];  
    j = 2 * i + 1;  
    while (j < n)  
    {  
        if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
            j++;  
  
        if (a[j] >= temp)  
            break;  
  
        a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
        i = j;  
        j = 2 * i + 1;  
    }  
    a[i] = temp;  
} 
//在最小堆中删除数  
void MinHeapDeleteNumber(int a[], int n)  
{  
    swap(a[0], a[n - 1]);  
    MinHeapFixdown(a, 0, n - 1);  
}  


//建立最小堆  
void MakeMinHeap(int a[],int n)
{
	for(int i=n/2-1;i>=0;i--)
	{
		MinHeapFixdown(a,i,n);
	}
}


//堆排序
void MinheapsortTodescendarray(int a[], int n)  
{  
    for (int i = n - 1; i >= 1; i--)  
    {  
        swap(a[i], a[0]);  
        MinHeapFixdown(a, 0, i);  
    }  
}