双向链表排序（C#取List的前几条数据）

本文目录

• C#取List的前几条数据
• 双向循环链表建立前驱和建立后继先后顺序
• C语言 双向链表 快速排序
• 求高手做个c语言设计一个双向链表的排序
• 这是个关于SCAN算法的c语言描述，程序无错，运行有错
• 双向链表排序c语言程序设计
• 用c++语言实现双向链表的排序
• c语言数据结构（双向链表排序）
• c++链表排序
• 双向循环链表怎么实现排序冒泡排序

C#取List的前几条数据

C#取List的前几条数据：(fromainkeyWordListorderbya.Totaldescendingselecta).Take(10).ToList();

list也是顺序容器的一种。只是list是一个双向链表。使用list需要包含头文件list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素。

list的用法和vector很类似，也拥有顺序容器中的常用方法，需要注意的是**list不支持使用下标随机存取元素。在list容器中，在已经定位到要增删元素的位置的情况下，增删元素能在常数时间内完成。如下图所示，在ai和ai+1之间插入一个元素，只需要修改ai和ai+1中的指针即可。

扩展资料

list的成员函数

voidpush_front(constT&val)将val插入链表最前面

voidpop_front()删除链表最前面的元素

voidsort()将链表从小到大排序

voidremove(constT&val)删除和val相等的元素

remove_if删除符合某种条件的元素

voidunique()删除所有和前一个元素相等的元素

voidmerge(list《T》&x)将链表x合并进来并清空x。要求链表自身和x都是有序的

voidsplice(iteratori,list《T》&x,iteratorfirst,iteratorlast)在位置i前面插入链表x中的区间[first,last)，并在链表x中删除该区间。链表自身和链表x可以是同一个链表，只要i不在[first,last)中即可

双向循环链表建立前驱和建立后继先后顺序

双向循环链表的排序 双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继双向循环链表中的节点有两个指针域和一个存放数据的地方,两个指针域一个存放下一个节点的地址,一个存放前一个指针的地址下面是...对于一个二叉树，可以将其分为左子树、根节点和右子树三部分。根据题目要求可知将BST化为一个排好序的双向链表实际上就是将其中序遍历序列对应的各个节点连接起来。同时还可以知道若根的左右子树非空，则根节点在链表中的前驱结点一定在其左子树中，后继结点一定在其右子树中。那么可以先找到并标记根节点的前驱和后继，然后连接。同时递归执行这一过程便能达到要求。

C语言 双向链表 快速排序

我说一下想法你看行不行直接在链表中排序太麻烦，不如把关键字和指针单独抽取出来放到一个结构体数组中然后对这个数组进行排序，排好后按相应指针顺序输出链表元素即可在输入规模不大的情况下增加了一些空间代价，但是却可使代码简化不少，应该是可行的。当然直接交换双向链表中的两个元素也非难事。

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

#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(); }

这是个关于SCAN算法的c语言描述，程序无错，运行有错

　　你的代码是有问题的，百度这个没法完整的上传代码

　　#include 《stdio.h》

　　#include 《stdlib.h》

　　#include 《malloc.h》

　　#include 《math.h》

　　typedef int status;

　　#define OK 1#define ERROR 0

　　typedef struct likelist

　　{

　　int data;

　　struct likelist *front,*next;//建立双向链表

　　} Listnode;

　　Listnode *Create_list(Listnode *head,int n)//建立链表

　　{

　　Listnode *p,*q;

　　int i;

　　head = (Listnode*)malloc(sizeof(Listnode));

　　if(!head)

　　{

　　exit(-1);  //创建不成功则退出程序

　　}

　　head-》next = NULL;

　　p = head-》next;

　　q = head;

　　printf("请输入%d个进程所要访问的磁道号:",n);

　　for( i = 0; i 《 n; i++)

　　{

　　p = (Listnode*)malloc(sizeof(Listnode));

　　if(!p)

　　{

　　exit(-1);

　　}

　　q-》next = p;

　　scanf("%d",&p-》data);

　　p-》front = q;

　　p-》next = NULL;

　　q = p;

　　}

　　printf("输入磁道号已经完成\n\n\n");   //用于测试程序在哪里执行出错

　　return head;

　　}

　　Listnode *Sort_list(Listnode *head)//对链表排序

　　{

　　int a;

　　if(!head-》next)

　　{

　　printf("表空！");

　　exit(-1);

　　}

　　Listnode *p,*q;

　　p = head-》next;

　　q = p-》next;

　　for(;q-》next != NULL; p = p-》next, q = q-》next)

　　{

　　if((p-》data) 》 (q-》data))

　　{

　　a = p-》data;

　　p-》data = q-》data;

　　q-》data = a;

　　}

　　} /* while(q-》next!=NULL) {  if((p-》data)》(q-》data)){a=p-》data;p-》data=q-》data;q-》data=a;}  p=p-》next;  q=q-》next; }*/

　　return head;

　　}

　　void Fangwen_list(Listnode *head, int n, int m)//访问链表，向磁道增加的方向，m用于记录开始访问的磁道号，n记录总共磁道号数目

　　{

　　Listnode *p,*q;    //定义指向节点的指针

　　int i,j;

　　float distance = 0;

　　float sum = 0;

　　float ave;

　　p = head-》next;

　　printf("将要从%d号磁道向磁道号增加的方向访问:\n\n",m);

　　printf("被访问的下一个磁道号\t本次移动的距离\n");

　　for( i = 0; i 《 n; i++)

　　{

　　if(p-》data 》= m)

　　{

　　q = p-》front;

　　j = i;

　　break;

　　}

　　else

　　{

　　continue;

　　}

　　}

　　for( ; i 《 n ; i++)

　　{

　　printf("\t%d",p-》data);

　　distance = (float)fabs( m - (p-》data) );

　　m = p-》data;

　　sum = (float)( sum + distance );

　　printf("\t\t%f\n",distance);   //用于格式化的输出，\t

　　p = p-》next;

　　}

　　printf("\n");

　　/*

　　for( ; q != head; )

　　{

　　printf("\t%d",q-》data);

　　distance = (float)fabs(m - q-》data);

　　m = q-》data;

　　sum = (float)(sum + distance);

　　printf("\t\t%f\n",distance);

　　q = q-》front;

　　}

　　printf("\n");

　　*/

　　ave = (float)sum / n;  //计算出平均长度

　　printf("平均寻道长度为:%.2f\n",ave);

　　}

　　int main()

　　{

　　Listnode *head;

　　int n;

　　int m;

　　printf("请输入进程要访问的磁道的总数:");

　　scanf("%d",&n);

　　head = Create_list( head, n );  //链表返回头指针应该赋值，

　　Sort_list( head );

　　printf("请输入你要最开始访问的磁道号:");

　　scanf("%d",&m);

　　Fangwen_list( head , n, m);

　　system("pause");

　　return 0;

　　}

双向链表排序c语言程序设计

/************************************************************************//*文件名doublelnk.h作用定义必要的结构体，并对双向链表的操作函数做声明*//************************************************************************/#ifndef DList_H#define DList_Htypedef  int Item;typedef struct Node * PNode;typedef PNode Position;/*定义节点类型*/typedef struct Node{Item id;/*编号*/Item data;/*数据域*/PNode previous; /*指向前驱*/PNode next;/*指向后继*/}Node;/*定义链表类型*/typedef struct{PNode head;/*指向头节点*/PNode tail;/*指向尾节点*/int size;}DList;enum enumSortType{ID,DATA};/*分配值为i的节点，并返回节点地址*/Position MakeNode(Item id, Item data);/*释放p所指的节点*/void FreeNode(PNode p);/*构造一个空的双向链表*/DList* InitList();/*摧毁一个双向链表*/void DestroyList(DList *plist);/*将一个链表置为空表，释放原链表节点空间*/void ClearList(DList *plist);/*返回头节点地址*/Position GetHead(DList *plist);/*返回尾节点地址*/Position GetTail(DList *plist);/*返回链表大小*/int GetSize(DList *plist);/*返回p的直接后继位置*/Position GetNext(Position p);/*返回p的直接前驱位置*/Position GetPrevious(Position p);/*将pnode所指节点插入第一个节点之前*/PNode InsFirst(DList *plist,PNode pnode);/*将链表第一个节点删除并返回其地址*/PNode DelFirst(DList *plist);/*获得节点的数据项*/Item GetItem(Position p);/*设置节点的数据项*/void SetItem(Position p,Item i);/*删除链表中的尾节点并返回其地址，改变链表的尾指针指向新的尾节点*/PNode Remove(DList *plist);/*在链表中p位置之前插入新节点S*/PNode InsBefore(DList *plist,Position p,PNode s);/*在链表中p位置之后插入新节点s*/PNode InsAfter(DList *plist,Position p,PNode s);/*返回在链表中第i个节点的位置*/PNode LocatePos(DList *plist,int i);void ListTraverse(DList *plist,void (*visit)(Node));/*对双向链表按照执行的排序方式进行排序*/void SortDLnk(DList * plist, enumSortType sortType);void SortDLnkbyID(DList * plist);void SortDLnkbyData(DList * plist);void swapnode(PNode anode, PNode bnode);#endif/************************************************************************//*文件名doublelnk.cpp作用对双向链表的操作函数进行具体实现*//************************************************************************/#include"doublelnk.h"#include《malloc.h》#include《stdlib.h》/*分配值为i的节点，并返回节点地址*/Position MakeNode(Item id, Item data){PNode p = NULL; p = (PNode)malloc(sizeof(Node));if(p!=NULL){p-》id =id;p-》data = data;p-》previous = NULL;p-》next = NULL;}return p;}/*释放p所指的节点*/void FreeNode(PNode p){free(p);}/*构造一个空的双向链表*/DList * InitList(){DList *plist = (DList *)malloc(sizeof(DList));PNode head = MakeNode(0, 0); if(plist!=NULL){if(head!=NULL){plist-》head = head;plist-》tail = head;plist-》size = 0;}elsereturn NULL;}return plist;}/*摧毁一个双向链表*/void DestroyList(DList *plist){ClearList(plist);free(GetHead(plist));free(plist);}/*判断链表是否为空表*/int IsEmpty(DList *plist){if(GetSize(plist)==0&&GetTail(plist)==GetHead(plist))return 1;elsereturn 0;}/*将一个链表置为空表，释放原链表节点空间*/void ClearList(DList *plist){PNode temp,p;p = GetTail(plist);while(!IsEmpty(plist)){temp = GetPrevious(p);FreeNode(p);p = temp;plist-》tail = temp;plist-》size--;}}/*返回头节点地址*/Position GetHead(DList *plist){return plist-》head;}/*返回尾节点地址*/Position GetTail(DList *plist){return plist-》tail;}/*返回链表大小*/int GetSize(DList *plist){return plist-》size;}/*返回p的直接后继位置*/Position GetNext(Position p){return p-》next;}/*返回p的直接前驱位置*/Position GetPrevious(Position p){return p-》previous;}/*将pnode所指节点插入第一个节点之前*/PNode InsFirst(DList *plist,PNode pnode){Position head = GetHead(plist);if(IsEmpty(plist))plist-》tail = pnode;plist-》size++;pnode-》next = head-》next;pnode-》previous = head;if(head-》next!=NULL)head-》next-》previous = pnode;head-》next = pnode;return pnode; }/*将链表第一个节点删除,返回该节点的地址*/PNode DelFirst(DList *plist){Position head = GetHead(plist);Position p=head-》next;if(p!=NULL){if(p==GetTail(plist))plist-》tail = p-》previous;head-》next = p-》next;head-》next-》previous = head;plist-》size--;}return p;}/*获得节点的数据项*/Item GetItem(Position p){return p-》data;}/*设置节点的数据项*/void SetItem(Position p,Item i){p-》data = i;}/*删除链表中的尾节点并返回地址，改变链表的尾指针指向新的尾节点*/PNode Remove(DList *plist){Position p=NULL;if(IsEmpty(plist))return NULL;else{p = GetTail(plist);p-》previous-》next = p-》next;plist-》tail = p-》previous;plist-》size--;return p;}}/*在链表中p位置之前插入新节点s*/PNode InsBefore(DList *plist,Position p,PNode s){s-》previous = p-》previous;s-》next = p;p-》previous-》next = s;p-》previous = s;plist-》size++;return s;}/*在链表中p位置之后插入新节点s*/PNode InsAfter(DList *plist,Position p,PNode s){s-》next = p-》next;s-》previous = p;if(p-》next != NULL)p-》next-》previous = s;p-》next = s;if(p = GetTail(plist))plist-》tail = s;plist-》size++;return s;}/*返回在链表中第i个节点的位置*/PNode LocatePos(DList *plist,int i){int cnt = 0;Position p = GetHead(plist);if(i》GetSize(plist)||i《1)return NULL;while(++cnt《=i){p=p-》next;}return p;}/*依次对链表中每个元素调用函数visit()*/  void ListTraverse(DList *plist,void (*visit)(Node))  {  Position p = GetHead(plist);  if(IsEmpty(plist))  exit(0);  else  {  while(p-》next!=NULL)  {  p = p-》next;  visit(*p);            }         }  }  void SortDLnk(DList * plist, enumSortType sortType){switch(sortType){case ID:SortDLnkbyID(plist);break;case DATA:SortDLnkbyData(plist);break;}}void SortDLnkbyID(DList * plist){PNode head = plist-》head;Node tmpnode;Position currnode = head;Position bianlinode;while ((currnode=currnode-》next) != NULL){bianlinode =currnode;while((bianlinode=bianlinode-》next) != NULL){if (currnode-》id 》 bianlinode-》id){swapnode(currnode, bianlinode);}}}}void SortDLnkbyData(DList * plist){PNode head = plist-》head;Node tmpnode;Position currnode = head;Position bianlinode;while ((currnode=currnode-》next) != NULL){bianlinode =currnode;while((bianlinode=bianlinode-》next) != NULL){if (currnode-》data 》 bianlinode-》data){swapnode(currnode, bianlinode);}}}}void swapnode(PNode anode, PNode bnode){// 这里面要特别注意防止前驱节点是头结点和后驱节点是Null的情况Node tmpnode;tmpnode.id = anode-》id;tmpnode.data = anode-》data;anode-》id = bnode-》id;anode-》data = bnode-》data;bnode-》id = tmpnode.id;bnode-》data = tmpnode.data;}/************************************************************************//*文件名program.cpp作用对双向链表的操作函数进行测试*//************************************************************************/#include"doublelnk.h"#include《stdio.h》void print(Node node){printf("数据项: id=%d, data=%d \n",node.id, node.data);}int main(){DList *plist = NULL;PNode p = NULL;plist = InitList();p = InsFirst(plist,MakeNode(12, 23));InsBefore(plist,p,MakeNode(2, 54));InsAfter(plist,p,MakeNode(3, 34));printf("p前驱位置的值为%d\n",GetItem(GetPrevious(p)));printf("p位置的值为%d\n",GetItem(p));printf("p后继位置的值为%d\n",GetItem(GetNext(p)));printf("遍历输出各节点数据项:\n");ListTraverse(plist,print);printf("按照ID排序后遍历输出:\n");SortDLnk(plist, ID);ListTraverse(plist,print);printf("按照Data排序后遍历输出:\n");SortDLnk(plist, DATA);ListTraverse(plist,print);printf("除了头节点该链表共有%d个节点\n",GetSize(plist));FreeNode(DelFirst(plist));printf("删除第一个节点后重新遍历输出为:\n");ListTraverse(plist,print);printf("除了头节点该链表共有%d个节点\n",GetSize(plist));DestroyList(plist);printf("链表已被销毁\n");return 0;}

程序总共分三部分， 分别是双向链表的头文件、源文件和测试程序

建立工程后，分别建立相应的文件并添加相应代码应该就可以

***隐藏网址***

用c++语言实现双向链表的排序

#include 《stdio.h》#include 《stdlib.h》#include 《time.h》struct _Node {int data;struct _Node *next;};typedef struct _Node Node;// 交换两个结点的数据void SwapNodeData(Node *p1, Node *p2) {int temp = p1-》data;p1-》data = p2-》data;p2-》data= temp;}// 冒泡排序对链表进行排序void BubbleSort(Node *head) {Node *pTemp;int maxIdx, idx;// 计算链表长度maxIdx = 0;for (pTemp = head; pTemp != NULL; pTemp = pTemp-》next)++maxIdx;idx = 0;while (idx 《 maxIdx-1) {for (pTemp = head; idx 《 maxIdx-1; pTemp = pTemp-》next, ++idx) {if (pTemp-》data 》 pTemp-》next-》data)SwapNodeData(pTemp, pTemp-》next);}idx = 0;--maxIdx;}}int main(void){Node *head = NULL, *temp = NULL, *p = NULL;int i;srand((unsigned int)time(NULL));// 产生随机数链表head = (Node *)malloc(sizeof(Node));head-》data = rand() % 40;p = head;for (i = 1; i 《 20; ++i) {temp = (Node *)malloc(sizeof(Node));temp-》data = rand() % 40;p-》next = temp;p = p-》next;}p-》next = NULL;// 输出随机数链表for (p = head; p != NULL; p = p-》next)printf("%d ", p-》data);printf("\n");// 对链表排序BubbleSort(head);// 输出以排序的链表for (p = head; p != NULL; p = p-》next)printf("%d ", p-》data);printf("\n");// 释放资源for (p = head-》next; p != NULL; p = p-》next) {free(head);head = p;}free(head);head = NULL;getchar();return 0;

c语言数据结构（双向链表排序）

#include《stdio.h》#include《malloc.h》#define ElemType intint count=0;typedef struct DulNode{ ElemType data; DulNode *prior; DulNode *next;}DulNode,*DulLinkList;//初始化链表，结束后产生一个头结点指针void InitDLList(DulLinkList *L){ (*L)=(DulLinkList)malloc(sizeof(DulNode)); (*L)-》next=*L; (*L)-》prior=(*L)-》next;}//对链表进行插入操作void ListInsert(DulLinkList *L){ int i=0,n; ElemType temp; DulNode *s,*p; p=(*L)-》next; printf("请输入插入元素数量：\n"); scanf("%d",&n); count=n; printf("请输入%d个自然数\n",n); while(i《n) { scanf("%d",&temp); s=(DulNode*)malloc(sizeof(DulNode)); s-》data=temp; while((p!=(*L))&&(p-》data《temp))//查找所要插入的位置 { p=p-》next; } s-》prior=p-》prior;//新节点的插入 s-》next=p; p-》prior-》next=s; p-》prior=s; p=(*L)-》next;//将指针回指到链表第一个非空节点，主要是为了下次查找插入位置 i++; }}void Display(DulLinkList L){ DulNode *p; p=L-》next; printf("双向链表中的数据为:\n"); while(p!=L) { printf("%d ",p-》data); p=p-》next; } printf("\n");}void Sort(DulLinkList *L){ ElemType temp; DulNode *p,*q; p=(*L)-》next; q=(*L)-》prior; if(count%2!=0) q=q-》prior; p=p-》next; while(p!=q) { temp=p-》data; p-》data=q-》data; q-》data=temp; p=p-》next;if(p!=q) //第二题只需交换节点数据 q=q-》prior;//这几个if else语句需要仔细 else break; if(p!=q) p=p-》next; else break; if(p!=q) q=q-》prior; else break; }}void main(){ DulLinkList L; InitDLList(&L);//初始化链表 ListInsert(&L);//顺序插入数据 Display(L);//显示结果 Sort(&L);//第二题操作 Display(L);//第二题输出结果}

c++链表排序

虽然分很少.但是我给你做出来了.而且我不重视这分的.只是把这题当作作业自己做做.代码如下:#include "iostream"#include "fstream"#include "string"using namespace std; //class List; struct Student{ string ID; string name; string gender; string speciality; string RoomId; }; class ListNode{ public: //friend class List; ListNode(){} ListNode(Student a):data(a),link(NULL){} void SetNode(ListNode *temp){this-》link=temp;} friend int find(string ID2); friend void sort(); friend void changeNode(ListNode *a,ListNode *b); friend void printf(); friend void read(); private: Student data; ListNode *link; }; ListNode *first; void printf(){ ListNode *a=first; while(a) { cout《《a-》data.ID《《" "《《a-》data.name《《" "《《a-》data.gender《《" "《《a-》data.speciality 《《" "《《a-》data.RoomId《《endl; a=a-》link; } } void changeNode(ListNode *a,ListNode *b){ Student temp; temp=a-》data;a-》data=b-》data;b-》data=temp; } int find(string ID2){ ListNode *a=first; while(a) {if(a-》data.ID==ID2){cout《《"Find:"《《endl; cout《《a-》data.ID《《" "《《a-》data.name《《" "《《a-》data.gender《《" "《《a-》data.speciality 《《" "《《a-》data.RoomId《《endl; return 1; } else a=a-》link; } cout《《"无此记录!"《《endl; return 0; } void sort(){ ListNode *a=first,*b,*c; while(a) { c=a; b=a-》link; while(b) { if(c-》data.ID》b-》data.ID)c=b; b=b-》link; } if(a!=c)changeNode(a,c); a=a-》link; } printf(); }/*class list{ public: list(Listnode a){first=a;} private: ListNode *first; };*/ void read(){ string s; Student head; head.gender="0"; head.ID="0"; head.name="0"; head.RoomId="0"; head.speciality="0"; ListNode *headNode=new ListNode(head); first=headNode; ifstream input; input.open("c:\\data\\studentdata.txt"); if(!input)cout《《"error!"《《endl; else while(input》》s) { Student newstudent; newstudent.ID=s; input》》s; newstudent.name=s; input》》s; newstudent.gender=s; input》》s; newstudent.speciality=s; input》》s; newstudent.RoomId=s; ListNode *newnode=new ListNode(newstudent); headNode-》SetNode(newnode); headNode=headNode-》link; } first=first-》link; }int main(){ read(); cout《《"读取完毕!"《《endl; printf(); while(1){ cout《《"1.我要查询"《《endl; cout《《"2.我要排序"《《endl; cout《《"3.我要退出"《《endl; int n; cin》》n; if(n==1){string findID; cout《《"请输入要查询的学号:"; cin》》findID; find(findID); } else if(n==2){sort();} else if(n==3)exit(0); }}在VC++2008编译上通过.本人花了二小时做出来的,绝对达到你的要求了.在别的编译器上有问题的可以自己调试,应该问题不大.别忘了记得建立文件.而且文件里的格式如下:004 wk M computer 116001 dd F computer 114002 as F english 113003 aq M computer 114

双向循环链表怎么实现排序冒泡排序

#include 《stdio.h》#include 《string.h》typedef struct Node{int num;struct Node *pre;struct Node *next;}My_Node;// head为双向链表表头// dir为排序方向：0为升序，1为降序void sort_list(My_Node *head, int dir){if(head == NULL) return ;My_Node *now_item = head;My_Node *next_item = NULL;int tmp = 0;while(now_item-》next != NULL){next_item = now_item-》next;while(next_item != NULL && next_item-》pre != head && (next_item-》pre-》num 》 next_item-》num) ^ dir){tmp = next_item-》num;next_item-》num = next_item-》pre-》num;next_item-》pre-》num = tmp;next_item = next_item-》pre;}now_item = now_item-》next;}}//打印排序后结果void print_list(My_Node *head){My_Node *p = head-》next;while(p != NULL){printf("%d ", p-》num);p = p-》next;}printf("\n");}//测试数据void test(){int list = {4, 2, 5, 6, 1, 9, 7, 3, 8, 0};int i;My_Node *head = (My_Node *)malloc(sizeof(My_Node));My_Node *p = NULL;head-》pre = head-》next = NULL;for(i=0; i《10; i++){p = (My_Node *)malloc(sizeof(My_Node));p-》num = list;p-》next = head-》next;if(head-》next != NULL) head-》next-》pre = p;head-》next = p;p-》pre = head;}printf("原序列: ");print_list(head);sort_list(head, 0);printf("升序排序: ");print_list(head);sort_list(head, 1);printf("降续排序: ");print_list(head);}int main(){test();return 0;}//贴上来格式都没了。。