Question

求高手做个c语言设计一个双向链表的排序

要求:输入一个双向链表,显示这些双向链表并对次双向链表排序
在适当的地方麻烦用中文注明下
希望能运行通过啊 我小白 老找不出错误T_T

Answer 1

#include <stdio.h>
typedef struct Link/*双向链表结构体*/
{
int data;
struct Link *lift;
struct Link *right;
}linkx,*linky;
linky Init();/*建立双向链表*/
void PrLink(linky p);/*输出双向链表*/
linky Sort(linky head);/*对双向链表排序*/
linky Swap(linky head,linky one,linky two);/*任意交换双向链表两个结点的地址*/
void main(void)
{
linky head;
head=Init();
head=Sort(head);
PrLink(head);
}
linky Init()/*建立链表*/
{
linky p,q,head;
int n=0;
head=p=q=(linky)malloc(sizeof(linkx));
clrscr();
printf("please input 10 num: ");
scanf("%d",&p->data);/*输入数据*/
head->lift=NULL;
n++;
while(n!=10)/*一直输入到规定的数字个数停止*/
{
q=p;
p=(linky)malloc(sizeof(linkx));
scanf("%d",&p->data);/*输入数据*/
q->right=p;
p->lift=q;
n++;
}
p->right=NULL;
return(head);
}
linky Swap(linky head,linky one,linky two)/*任意交换两个结点*/
{linky temp;
if(one->lift==NULL&&two->right==NULL)/*首和尾巴的交换*/
{
if(one->right==two)/*只有两个结点的情况下*/
{
two->right=one;
two->lift=NULL;
one->lift=two;
one->right=NULL;
head=two;
}
else/*有间隔的首尾交换*/
{
one->right->lift=two;
two->lift->right=one;
two->right=one->right;
one->lift=two->lift;
two->lift=one->right=NULL;
head=two;/*尾结点成为头结点*/
}
}
else if(two->right==NULL)/*尾和任意一个交换*/
{
if(one->right==two)/*交换最后两个结点*/
{
one->lift->right=two;
two->lift=one->lift;
two->right=one;
one->lift=two;
one->right=NULL;
}
else/*和前面其他结点交换*/
{
temp=two->lift;
temp->right=one;
one->lift->right=two;
one->right->lift=two;
two->lift=one->lift;
two->right=one->right;
one->lift=temp;
one->right=NULL;
}
}
else if(one->lift==NULL)/*头和任意一个交换*/
{
if(one->right==two)/*交换头两个结点*/
{
two->right->lift=one;
one->right=two->right;
one->lift=two;
two->right=one;
two->lift=NULL;
head=two;
}
else/*头结点和后面其他结点交换*/
{
temp=one->right;
temp->lift=two;
one->lift=two->lift;
one->right=two->right;
two->lift->right=one;
two->right->lift=one;
two->right=temp;
two->lift=NULL;
head=two;/*交换的结点成为头结点*/
}
}
else/*当中的任意两个交换*/
{
if(one->right==two)/*交换连在一起的两个结点*/
{
temp=one->lift;
one->lift->right=two;
one->right->lift=two;
one->lift=two;
one->right=two->right;
two->right->lift=one;
two->right=one;
two->lift=temp;
}
else/*交换隔开的两个结点*/
{
one->lift->right=two;
one->right->lift=two;
one->lift=two->lift;
temp=one->right;
one->right=two->right;
two->lift->right=one;
two->right->lift=one;
two->right=temp;
two->lift=one->lift;
}
}
return(head);
}
linky Sort(linky head)/*对链表排序*/
{
linky i,j,t,p;
int max;
p=head;
for(i=p;i->right!=NULL;i=i->right)/*用选择法的思想对这些结点排序*/
{
max=i->data;
for(j=i->right;j!=NULL;j=j->right)
if(j->data<max)
{
max=j->data;
t=j;
}
if(max!=i->data)/*如果没有找到比i小的结点*/
{
head=Swap(head,i,t);/*因为最终返回的是头结点,而头结点又有可能变化,所以每次头结点返回*/
i=t;
}
}
return(head);
}
void PrLink(linky p)/*输出链表*/
{
linky q;
printf("Now the link: ");
do
{
q=p;
printf("%d ",p->data);
p=p->right;
free(q);/*释放输出结点*/
}
while(p!=NULL);
getch();
}

Answer 2

给你一个程序，此程序创建双向链表，创建的双向链表自动的按照升序排列，可以显示链表中的值。都有注释
//包含头文件
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <conio.h>

//定义结构体，链表中的节点
typedef struct student
{
int data;
struct student* next;//双向链表，指向后一个节点
struct student* pre;//指向前一个节点
}dnode;
typedef struct student* pnode;

//创建节点，返回节点指针
//输入：节点的值
//输出：节点的指针
pnode createNode(int n)
{
pnode p=NULL;
p=(pnode)malloc(sizeof(dnode));
p->next =NULL;
p->pre = NULL;
p->data =n;
return p;
}
//在链表中按data升序插入节点
//输入：链表头指针，节点指针
//输出：链表头指针
pnode insert(pnode head,pnode temp)
{
pnode p=NULL;
pnode k=NULL;//
if(NULL==temp)//如果插入空节点，直接退出返回头节点指针
{
return head;
}
if(NULL==head)//如果头指针为空，
{
head = temp;//节点就作头
}else
{
if(head->data > temp->data)
{//如果头指针的值大于插入节点的值
//节点插入到最前面作为头节点
temp->next = head;
head->pre = temp;
head = temp;
}else
{
p = head->next;//从第二个节点开始比较
k = head;
while(NULL!=p)
{//如果插入节点值比当前节点值小，那插入到当前节点前面
//如果比当前节点值大，那么与下一节点值比较
if(temp->data < p->data)
{
k = p->pre;//记住当前节点的前一节点
temp->next = p;//新插入节点的后节点是当前节点
p->pre = temp;//当前节点的前一节点是新插入节点

k->next = temp;
temp->pre =k;

break;//节点插入，退出比较
}else
{
p = p->next;//下一节点
k=p;
}
}
if(NULL==p)//此条件成立,插入节点值比最后一个节点值大，节点插入到最后面
{//此时k是最后面节点
k->next =temp;
temp->pre =k;
}
}
}
return head;//返回头节点指针
}

//创建双链表
//返回链表头指针
pnode create()
{
pnode head=NULL,p=NULL;
int x,cycle=1;
while(cycle)
{
printf("\n输入整数值(输入0 结束链表的创建):");
scanf("%d",&x);
if(x!=0)
{
p=createNode(x);//创建一个节点
head = insert(head,p);//在链表中加入一个节点。按照升序的方式加入
}else
{
cycle=0;//此条件退出while循环
}
}

return head;//返回新建链表的头指针
}
//得到双链表的深度，双链表中有多少个节点
//输入参数：双链表的头指针
//输出：双链表的节点个数
int length(pnode head)
{
int n=0;
pnode p=head;
while(NULL!=p)
{
p=p->next;
n++;
}
return n;
}
//输出双链表
//输入参数：双链表头指针
void print(pnode head)
{
pnode p=head;
int n=0;
n=length(head);
if(0==n)
{
printf("\n链表里面没有节点");
return;
}else
{
printf("\n共有%d个节点：",n);
while(NULL!=p)
{
printf("\n%d",p->data);
p=p->next;
}
}
}

//主函数
int main(int argc, char* argv[])
{
pnode head=NULL;
int n=0;
head = create();//创建链表
print(head);//显示链表
system("pause");
return 0;
}

Answer 3

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#define N 10

typedef struct node
{
char name[20];
struct node *llink,*rlink;
}stud;/*双链表的结构定义*/

/*双链表的创建*/
stud * creat(int n)
{
stud *p,*h,*s;
int i;
if((h=(stud *)malloc(sizeof(stud)))==NULL)
{
printf("cannot find space!\n");
exit(0);
}
h->name[0]='\0';
h->llink=NULL;
h->rlink=NULL;
p=h;
for(i=0;i<n;i++)
{
if((s= (stud *) malloc(sizeof(stud)))==NULL)
{
printf("cannot find space!\n");
exit(0);
}
p->rlink=s;
printf("please input the %d man's name:",i+1);
scanf("%s",s->name);
s->llink=p;
s->rlink=NULL;
p=s;
}
h->llink=s;
p->rlink=h;
return(h);
}

/*从小到大排序*/
int sort (stud *h){
stud *pre,*next;
char *str,*str2,*tem;
if(h==NULL){
printf(node is empty.);
return 0;
}
pre=h;

while(pre->rlink!=NULL)
{
next=pre->rlink;
if(strcmp(pre->name,next->name)<0){
if((tem= (stud *)malloc(sizeof(stud)))==NULL){
printf("cannot find space!\n");
}
strcpy(tem->name,pre->name);
tem->rlink=next->rlink;
tem->llink=next;
next->rlink=tem;
next->llink=pre;
pre->rlink=tem->rlink;
pre->llink=tem->llink;
free(tem);
}
pre++;
}
}

/*打印输出*/
void print(stud *h)
{
stud *p;
p=h->rlink;
printf("the information of the dlist is:\n");
while(p!=h)
{
printf("%s ",&*(p->name));
p=p->rlink;
}
printf("\n");
}

/*主函数*/
main()
{
int number;
char studname[20];
stud *head,*searchpoint;
number=N;
//clrscr();
head=creat(number);
print(head);
printf("please input the name which you want to find:");
scanf("%s",studname);
searchpoint=search(head,studname);
printf("the name you want to find is:%s\n",*&searchpoint->name);
del(searchpoint);
print(head);
sort(head);
print(head);
}

Answer 4

#include <malloc.h>
#include <stdio.h>

struct Node
{
int data;

struct Node* next;
struct Node* prev;
};

struct Node* create_list(int N)
{
struct Node *head = NULL;
struct Node *p = NULL, *q = NULL;

int i = 0, data = 0;

for (i = 0; i < N; i++)
{
printf("请输入结点%d的值：", i+1);
scanf("%d", &data);
p = (struct Node*)malloc(sizeof(struct Node));
p->next = NULL;
p->data = data;
if (i == 0)
{
head = p;
p->prev = NULL;
}
else
{
p->prev = q;
q->next = p;
}
q = p;
}

return head;
}

void free_list(struct Node* head)
{
struct Node* p = head;
struct Node* q = NULL;
while (p != NULL)
{
q = p;
p = p->next;
delete q;
}
}

void display_list(struct Node* head)
{
struct Node* p = head;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}

struct Node* get_max_node(struct Node* node)
{
struct Node* max_node = node;
while (node != NULL)
{
if (node->data > max_node->data)
{
max_node = node;
}
node = node->next;
}

return max_node;
}

void swap_node(struct Node* node1, struct Node* node2)
{
int temp;

if (node1 == node2)
{
return;
}

free_list(head);

return 0;
}
我好不容易帮你找的，2楼大白痴，抄袭我的！！！

Answer 5

鄙视作业帖