归并排序C语言实现

tinyfisher 发表于 2012-06-03

话不多说,直接上代码

void swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
void merge_array(int a[],int low,int mid,int high,int result[])
{
    int i,j,k;
    i=low;
    j=mid+1;
    k=0;
    while(i<=mid&&j<=high)
    {
        if(a[i]<a[j])
        {
            result[k]=a[i];
            i++;
            k++;
        }
        else
        {
            result[k]=a[j];
            k++;
            j++;
        }
    }
    while(i<=mid)
    {
        result[k]=a[i];
        i++;
        k++;
    }
    while(j<=high)
    {
        result[k]=a[j];
        j++;
        k++;
    }
    for(i=0;i<k;i++)    //注意 需要这一步
    {
        a[low+i]=result[i];  //low+i
    }
}
void merge_sort(int a[],int low,int high,int temp[])
{
	int mid=(low+high)/2;
	if(low<high)
	{
		merge_sort(a,low,mid,temp);
		merge_sort(a,mid+1,high,temp);
		merge_array(a,low,mid,high,temp);
	}
}

快速排序C语言实现

tinyfisher 发表于 2012-05-24

快速排序,经典必须掌握

void swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
int partition (int input[],int low,int high)
{
    int position=low-1;
    int key=input[high];
    while(low<high)
    {
        if(input[low]<key)
        {
            position++;
            swap(&input[position],&input[low]);
        }
        low++;
    }
    position++;
    swap(&input[position],&input[high]);
    return position;

}
void q_sort(int a[],int low,int high)
{
    if(low < high)               //不是while,因为是递归调用
    {
        int p;
        p=partition(a,low,high);
        q_sort(a,low,p-1);
        q_sort(a,p+1,high);
     }
}

堆排序C语言实现

tinyfisher 发表于 2012-05-15

堆的概念这里不再描述,这里主要实现堆排序,堆排序主要分为两步:
1.堆化数组(最小堆);
2.交换首尾元素,(则最后一个元素为最小),调整前n-1个元素,使前n-1个元素仍为为最小堆,循环,直到还剩一个元素;这样排序下来,数组为倒序。
代码如下:

void swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
void FixdownMinHeap(int a[],int index,int len)   //向下调整堆
{
    int father_index=index;
    int left_child_index=2*father_index+1;
    int right_child_index=2*father_index+2;
    int min=0;
    int min_index=0;
    while(left_child_index<len)   //重要  判断father_index不是叶子节点  
    {

        if(a[left_child_index]>a[right_child_index]&&right_child_index<len) //右节点存在且最小
        {
            min=a[right_child_index];
            min_index=right_child_index;
        }
        else
        {
            min=a[left_child_index];
            min_index=left_child_index;
        }

        if(a[father_index]>min)
        {
            swap(&a[father_index],&a[min_index]);
        }

        father_index=left_child_index;
        left_child_index=2*father_index+1;
        right_child_index=2*father_index+2;
    }
}
void createMinHeap(int a[],int n)//堆化数组
{
    int i=(n-1-1)/2; //因为n是数组长度,(n-1-1)/2表示最大父节点index
    while(i>=0)
    {
        FixdownMinHeap(a,i,n);
        i--;
    }
}
void MinHeapSort(int a[],int n)
{
    createMinHeap(a,n);
    int i=0;
    for(i=n-1;i>0;i--)
    {
        swap(&a[i],&a[0]);  //交换首尾元素
        FixdownMinHeap(a,0,i);  //调整堆
    }
}