双向链表快速排序，交换关键字

Question

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef int Status;
typedef enum {ERROR,OK
             } KEY;
typedef struct student {
    long id;
    char name[10];
    float grade;
} student,*stu;

typedef student ElemType;

typedef struct DuLNode {
    ElemType data;
    struct DuLNode *next,*prior;
} DuLNode,*DuLinkList;

 

Status InitList_DuL(DuLinkList &L); //双向链表初始化
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e); //双向链表插入；
void CreateList_DuL(DuLinkList &L,int n); //创建含有n个元素的双向链表； 
void ShowList_DuL(DuLinkList L); //输出双向链表； 

void QuickSort(DuLinkList L);//快速排序 
void QSort(DuLinkList L,DuLinkList low,DuLinkList high);//对链表low节点到high节点部分进行快速排序 
DuLinkList Partition(DuLinkList L,DuLinkList low,DuLinkList high);// 对链表low...high节点进行非递减排序；
int main() 
{
    DuLinkList H=NULL;
    InitList_DuL(H);//创建带头结点的双向链表； 
    CreateList_DuL(H,10);
    ShowList_DuL(H);
    //QuickSort(H);
    printf("\n");
    Partition(H,H->next,H->prior);
    ShowList_DuL(H);
    return 0;
}

void QuickSort(DuLinkList L)//快速排序 
{
    QSort(L,L->next,L->prior);
}

void QSort(DuLinkList L,DuLinkList low,DuLinkList high)//对链表low节点到high节点部分进行快速排序 
{
    DuLinkList pivotloc=NULL;
    if(low!=high)
    {
        pivotloc=Partition(L,low,high);
        QSort(L,low,pivotloc->prior);
        QSort(L,pivotloc->next,high);
    }    
}

//这个子函数为什么不能能排序？？？
DuLinkList Partition(DuLinkList L,DuLinkList low,DuLinkList high)// 对链表low...high节点进行非递减排序； 
{
    L->data=low->data;//链表头结点存储枢轴记录； 
    int pivotkey=low->data.grade;//记录枢轴记录关键字 
    while(low!=high)
    {
        while(low!=high&&high->data.grade>=pivotkey)//寻找小于pivotkey的节点； 
            high=high->prior;
        low->data=high->data;//将小于pivotkey的记录存储到low节点； 
        while(low!=high&&low->data.grade<=pivotkey)//寻找大于pivotkey的节点； 
            low=low->next;
        high->data=low->data;//将大于pivotkey的记录存储到high节点； 
    }
    low->data=L->data;//最后将最开始的pivotkey存放到low中，使序列 L.[low...high]左边都小于pivotkey右边都大于pivotkey； 
    return low;
}

Status InitList_DuL(DuLinkList &L) //双向链表初始化
{ 
    L=(DuLinkList)malloc(sizeof(DuLNode));
    if(!L)
        return ERROR;
    L->next=L->prior=L;
    L->next->prior=L;
    
    return OK;
}
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e) //双向链表插入； 
{
    if(!L||i<1)
        return ERROR;
    DuLinkList curr=(DuLinkList)malloc(sizeof(DuLNode));
    if(!curr)
        return ERROR;
    curr->data=e;
    DuLinkList tmp=L;
    int j;
    for(j=1; tmp&&j<=i ; j++)//找到要插入的第i个节点； 
        tmp=tmp->next;
    curr->prior=tmp->prior;
    curr->next=tmp;
    tmp->prior->next=curr;//tmp的前节点的next节点指向curr； 
    tmp->prior=curr;
    if(tmp->next==L)
        L->prior=tmp;
    return OK;
}

void CreateList_DuL(DuLinkList &L,int n) //创建含有n个元素的双向链表； 
{
    ElemType e;
    int i;
    for(i=1; i<=n; i++)
    { 
        e.grade=n-i;
        ListInsert_DuL(L,i,e);        
    } 
}

void ShowList_DuL(DuLinkList L) //输出双向链表； 
{
    DuLinkList curr=L->next;
    while(curr!=L) 
    {
        printf("%.2f ",curr->data.grade);
        curr=curr->next;
    }
}