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

#include

#include

#include

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;

}

}