数据结构入门小结之排序

（1）直接插入排序：

void InsertSort(int a[], int n)   
{
	int tmp;
	int p, j;
	for (p = 1; p < n; ++p)
	{
		tmp = a[p];
		for(j = p; j >= 1 && a[j-1] > tmp; --j)
		{
			a[j] = a[j-1];
		}
		a[j] = tmp;
	}
}

（2）希尔排序：

void ShellSort(int a[], int n)  
{
	int p, j, increment;
	int tmp;
	for (increment = n/2; increment > 0; increment /= 2)
	{
		for(p = increment; p < n; ++p)
		{
			tmp = a[p];
			for (j = p; j >= increment && a[j - increment] > tmp; j -=increment)
			{
				a[j] = a[j-increment];
			}
			a[j] = tmp;
		}
	}
}

（3）冒泡排序：

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

（4）快速排序：

递归实现：

int partion(int r[], int i, int j)
{
	int pivot = int r[i];
	int tmp;
	while (i < j)
	{
		while(i < j && r[j] >= pivot)
			--j;
		tmp = r[i];
		r[i] = r[j];
		r[j] = tmp;
		while(i < j && r[i] <= pivot)
			++i;
		tmp = r[i];
		r[i] = r[j];
		r[j] = tmp;
	}
	return i;
}

void quicksort(int r[], int i, int j)
{
	if (i < j)
	{
		int newloc = partion(r, i, j);
		quicksort(r, i, newloc - 1);
		quicksort(r, newloc + 1, j);
	}
}

改进后的递归实现：

int partion(int r[], int i, int j)
{
	int pivot = int r[i];
	int tmp;
	while (i < j)
	{
		while((i < j) && (r[j] >= pivot))
		     --j;
		r[i] = r[j];
		while((i < j) && (r[i] <= pivot))
		     ++i;
		r[j] = r[i];
	}
	r[i] = pivot;
	return i;
}

（5）简单选择排序：

void SelectSort(int r[], int n)  //每趟排序在待排序序列中选择关键码最小的元素，顺序添加到已排好序的有序序列的最后
{
	for (int i = 0; i < n - 1; ++i)
	{
		int index = i;
		int tmp;
		for(int j = i + 1; j <= n - 1; ++j)
			if(r[j] < r[index])
				index = j;
		if (index != i)
		{
			tmp = r[i];
			r[i] = r[index];
			r[index] = tmp;
		}
	}
}

（6）堆排序（根节点存放于r[1]）：

void sift(int r[], int k, int m) //m为编号最大的叶子结点的编号
{
      int i = k;
	  int j = 2*i;        //i是要筛选的结点，j是i的左孩子
      while (j <= m)
      {
          if((j < m) && (r[j] > r[j+1]))
		j++;   //j 是左右孩子中较小者
            if(r[i] < r[j]) 
		break;      //符合小根堆的条件，结束
            else
            { 
                int tmp = r[i];     
                r[i] = r[j] ;        //根结点与孩子结点交换
                r[j] = tmp;     
                i = j;    
                j= 2*i;
            }
      }
}

void HeapSort(int r[],  int n)
{
    for(int i = n/2; i >= 1; --i)      //建堆
         sift(r, i, n);
    for(i = 1; i < n; ++i)       //输出堆顶元素，重新建堆
    {
         int tmp= r[1] ;  
         r[1] = r[n-i+1];
         r[n-i+1] = tmp;
         sift(r, 1, n-i);
    }
}