建立一个双向链表,快速排序算法排序

#include <stdio.h>
#include <stdlib.h>
/*双链表的定义:*/
typedef char DataType;
typedef struct dlistnode /* 结点 类型 定义*/
{ DataType data;
struct dlistnode *prior,*next;
}DListNode;
typedef DListNode *DLinkList;void main()
{
DLinkList head;
DListNode *p;
DataType x;
int i;
DLinkList DCreateList(void);
DLinkList DGetNode(DLinkList head,int i);
void DInsertBefore(DLinkList p,DataType x);
void DPrintList(DLinkList head);
head=DCreateList(); /*建立双链表*/
DPrintList(head); /*打印双链表*/
printf("请输入欲插入的元素:");
scanf("%c",&x);
printf("请输入欲插入元素的位置:");
scanf("%d",&i);
p=DGetNode(head,i); /*寻找第i个结点*/
if(p==NULL)
{ printf("插入位置非法\n");
exit(0);
}
DInsertBefore(p,x);
DPrintList(head); /*打印双链表*/
} /*双链表的建立:*/
DLinkList DCreateList(void)
{ char ch;
DLinkList head=(DListNode *)malloc(sizeof(DListNode));
DListNode *s,*r;
head->next=NULL;
head->prior=NULL;
r=head; /*尾指针初值指向头结点*/
while ((ch=getchar())!='\n')
{ s=(DListNode *)malloc(sizeof(DListNode)); /*生成新结点*/
s->data=ch;
r->next=s;
s->prior=r;
r=s;

}
r->next=head;
head->prior=r;
return head; /*返回 头指针 */
}/*双链表的打印:*/
void DPrintList(DLinkList head)
{
DListNode *p;
for(p=head->next;p!=head;p=p->next)
printf("%c",p->data);
printf("\n");
}/*双链表的查找*/
DLinkList DGetNode(DLinkList head,int i)
{/*在带头结点的双链表head中查找第i个结点*/
int j;
DListNode *p;
p=head;j=0; /*从头结点开始扫描*/
while (p->next!=head && j<i)
{ p=p->next;
j++;
}
if (i==j)
return p; /*找到了第i个结点*/
else
return NULL; /*找不到满足条件的结点*/
}
  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是 C 语言双向链表的快速排序实现: ```c #include <stdio.h> #include <stdlib.h> typedef struct node { int val; struct node *prev; struct node *next; } Node; Node *partition(Node *head, Node *tail) { int pivot = tail->val; Node *i = head->prev; for (Node *j = head; j != tail; j = j->next) { if (j->val <= pivot) { i = (i == NULL) ? head : i->next; int tmp = i->val; i->val = j->val; j->val = tmp; } } i = (i == NULL) ? head : i->next; int tmp = i->val; i->val = tail->val; tail->val = tmp; return i; } void quick_sort(Node *head, Node *tail) { if (tail != NULL && head != tail && head != tail->next) { Node *p = partition(head, tail); quick_sort(head, p->prev); quick_sort(p->next, tail); } } void print_list(Node *head) { while (head != NULL) { printf("%d ", head->val); head = head->next; } printf("\n"); } int main() { Node *head = (Node *)malloc(sizeof(Node)); head->val = 5; head->prev = NULL; head->next = (Node *)malloc(sizeof(Node)); head->next->val = 2; head->next->prev = head; head->next->next = (Node *)malloc(sizeof(Node)); head->next->next->val = 8; head->next->next->prev = head->next; head->next->next->next = (Node *)malloc(sizeof(Node)); head->next->next->next->val = 3; head->next->next->next->prev = head->next->next; head->next->next->next->next = NULL; printf("Before sorting: "); print_list(head); quick_sort(head, head->next->next->next); printf("After sorting: "); print_list(head); return 0; } ``` 解释: - `partition` 函数实现了快速排序的分区操作,其输入参数为链表头和尾节点,返回值为分区点; - `quick_sort` 函数实现了快速排序的递归操作; - `print_list` 函数用于打印链表; - 在 `main` 函数中初始化了一个双向链表,并对其进行排序。 注意: - 在 `partition` 函数中,我们选择尾节点作为基准点(pivot),这是快速排序的常规选择; - 在 `partition` 函数中,我们使用了一种经典的双指针算法,分别指向小于等于基准点和大于基准点的元素; - 在 `partition` 函数中,我们使用了链表节点值的交换,而不是节点指针的交换,因为我们需要维护链表节点的 prev 和 next 指针; - 在 `quick_sort` 函数中,我们需要判断链表头和尾是否相等,以及链表头是否为尾的下一个节点,这是递归终止条件; - 在 `main` 函数中,我们需要手动创建链表并初始化,这是为了方便演示。在实际应用中,链表可能是从其他函数或模块中传入的,或者是动态创建的。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值