快速排序与堆排序的实现

快速排序

1.递归方法：

    void qsort(int a[],int l,int h){
        int t=a[l];
        int i=l;
        int j=h;
        while(i<j){
            while(i<j&&a[j]>=t){
                j--;
            }
           if(i<j)
               a[i]=a[j];
            while(i<j&&a[i]<=t){
                i++;
            }
            if(i<j)
                 a[j]=a[i];
        }
        a[j]=t;
        if(j-1>l){
            qsort(a,l,j-1);
        }
        if(j+1<h){
            qsort(a,j+1,h);
        }
    }

2.非递归方法：

int patision(int a[],int l,int h){
        int t=a[l];
        int i=l;
        int j=h;
        while(i<j){
            while(i<j&&a[j]>=t){
                j--;
            }
            a[i]=a[j];
            while(i<j&&a[i]<=t){
                i++;
            }
            a[j]=a[i];
        }
        a[j]=t;
        return j;
    }

void qsort(int a[],int size){
        int *stk=(int *)malloc(sizeof(int)*size);
        int h,l,m,q=0;
        int j;
        stk[q++]=0;
        stk[q++]=size-1;
        while(q!=0){
            h=stk[--q];
            l=stk[--q];
            if(l<h){
                m=patision(a,l,h);
                if(m-1>l){
                    stk[q++]=l;
                    stk[q++]=m-1;
                }
                if(m+1<h){
                    stk[q++]=m+1;
                    stk[q++]=h;  
                }
            }
            
        }
        free(stk);
    }

堆排序

堆排序思想：以大根堆为例，从编号最大的非叶子节点开始调整大根堆，然后依次减小编号，直到根节点，而调整堆的方法就是保证父节点总是比子节点大，否则父节点与较小的子节点交换，然后继续往下调整直到整棵子树满足大根堆的要求，最后堆的根节点就是最大的节点，与最后一个节点交换位置，然后除去最后一个节点外，其他的再次调整，一次类推，得到升序排列

代码实现如下：

void adjust_heap(int a[],int s,int m){
	int i,t;
        t=a[s];
        for(i=2*s+1;i<=m;i=2*i+1){
            if(i<m&&a[i]<a[i+1]){
                i++;
            }
            if(t>a[i]){
                break;
            }
            a[s]=a[i];
            s=i;
        }
        a[s]=t;
            
    }
	void hsort(int a[],int size){
        int i;
        int n=size;
        for(i=n/2-1,i>=0,i--){
            adjust_heap(a,i,n-1);
        }
        for(i=n-1;i>0;i--){
            a[0]=a[0]^a[i];
            a[i]=a[0]^a[i];
            a[0]=a[0]^a[i];
            adjust_heap(a,0,i-1);
        }
    }