面试编程题（排序）

排序：快排、堆排序

/*直接插入排序
*设置哨兵[0]*/
void InsertSort(int data[],int length)
{
    for(int i = 2; i <= length; i++)
    {
        if(data[i] < data[i-1])
        {
            data[0] = data[i];
            data[i] = data[i-1];
            int j;
            for(j= i-2; data[0] < data[j]; j--)
                data[j+1] = data[j];
            data[j+1] = data[0];
        }

    }
}
/*直接插入排序
*不设置哨兵*/
void InsertSort2(int data[],int length)
{
    for(int i= 1; i<length; i++)
    {
        if(data[i]<data[i-1])
        {
            int tmp = data[i];
            int j;
            for(j=i-1; j>=0 && data[j] > tmp;j--)
                data[j+1] = data[j];
            data[j+1] = tmp;
        }
    }
}
/*希尔排序  用插入实现*/
void ShellSort(int data[],int n)
{
    for(int d = n/2; d >=1; d /=2 ) //步长
    {
        for(int i = d; i<n; i++)
        {
            if(data[i] < data[i-d])
            {
                int tmp = data[i];
                int j;
                for(j = i-d; j>=0 && data[j] > tmp; j-=d)
                    data[j+d] = data[j];
                data[j+d] = tmp;
            }
        }
    }
}
/*希尔排序  用交换实现*/
void ShellSort2(int data[],int n)
{
    for(int d = n/2; d >=1; d /=2 ) //步长
    {
        for(int i = d; i<n; i++)
        {
            for(int j = i-d; j>=0 && data[j] > data[j+d]; j-=d)
                swap(data[j],data[j+d]);
        }
    }
}

/*冒泡排序*/
void bubble_sort(int data[], int n)
{
    for(int i = 0;i<n;i++)
    {
        for(int j = 0; j < n - i-1 ; ++j)
        {
            if(data[j+1] < data[j])
                swap(data[j],data[j+1]);
        }
    }
}
/*Qsort*/
int Partition(int data[],int len,int low,int high)
{
    int pivotkey = data[low];
    while(low < high)
    {
        while(low<high && data[high] >= pivotkey) --high;
        swap(data[low],data[high]);
        while(low<high &&data[low] <=pivotkey) ++low;
        swap(data[low],data[high]);
    }
    return low;
}

int Partition2(int data[],int len,int low,int high)
{
    int tmp = data[low];
    int pivotkey = data[low];
    while(low<high)
    {
        while(low < high && data[high] >= pivotkey) --high;
        data[low] = data[high];
        while(low < high && data[low] <= pivotkey) ++low;
        data[high] = data[low];
    }
    data[low] = tmp;
    return low;
}

void Qsort(int data[],int len,int low,int high)
{
    if(low < high)
    {
        int pivotloc = Partition2(data,len,low,high);
        Qsort(data,len,low,pivotloc-1);
        Qsort(data,len,pivotloc+1,high);
    }
}

/*堆排序*/
void HeapAdjust(int data[],int start,int end)
{
    int tmp = data[start];
    for(int j=2*start+1;j<=end;j=2*j+1)
    {
        if(j<end && data[j]<data[j+1]) ++j;
        if(tmp > data[j]) break;
        data[start] = data[j];
        start = j;
    }
    data[start]= tmp;
}
void HeapSort(int data[],int len)
{
    //建堆
    for(int i=len/2-1;i>=0;i--)  //0 开始 最后一个非终端节点  为 n/2  向下取整 -1
                                //1开始  最后一个非终端节点   为n/2  向下取整
        HeapAdjust(data,i,len-1);
    for(int i=len-1;i>0;i--)
    {
        swap(data[0],data[i]);
        HeapAdjust(data,0,i-1);
    }
}

归并排序

 各排序算法比较   稳定  时间复杂度  空间复杂度