链表使用典型例题
链表参考例题
1. 在D盘根目录中有两个数据文件Source1.dat和Source2.dat;2. 在Source1.dat和Source2.dat文件中以二进制方式分别存放了若干个用于表示工人的结构体类型数据。
结构体的声明如下:struct Worker{int num; //工号char name[10]; //姓名int age; //年龄int sex; //性别(0-男1-女)float salary; //工资};3. 编写一个函数,将Source1.dat文件中的数据读出,并且构建1个工人链表;4. 编写一个函数,显示上述第3步中生成的链表中的所有工人信息,每个工人的数据占一行,显示内容和格式要求如下:上述示意内容中斜体和线条部分仅用于说明题意的说明信息,不需要实际显示出来。
5. 编写一个函数,将上述第3步中生成的链表按照工号从大到小的顺序进行排序。
然后显示排序操作完成后链表中的所有工人信息,格式和第4步中相同。
6. 编写一个函数,删除上述第5步中生成的链表中年龄小于40岁的男性工人和工号大于650的女性工人。
然后显示删除操作完成后链表中的所有工人信息,格式和第4步中相同。
7. 编写一个函数,将Source2.dat文件中的数据依次读出,并且将所读出的每个工人数据依次插入到经过第6步处理后的工人链表中,要求仍然保持链表中工人工号的降序排列。
然后显示插入操作完成后链表中的所有工人信息,格式和第4步中相同。
8. 编写一个函数,求出经过第7步处理后的链表中所有年龄大于30岁的男性工人的平均工资,以及工资小于3000元的女性工人的最大年龄。
并在主函数中将所要求的计算结果显示在屏幕上,每个结果占一行。
注意:计算结果的显示必须安排在主函数中进行!9. 编写一个函数,对经过第7步处理的链表中全部工人数据保存到D盘根目录中的文本文件res.txt中,每个工人的数据占一行。
输出内容和格式和上述第4中要求相同。
链表的经典习题
链表的经典习题练习1•:链式栈//链式栈(top指向第⼀位⽆效的头结点)public class LinkedStack<E> {Node<E> top;//内部类class Node<E> {protected E data;protected Node<E> next;public Node(E data) {this.data = data;}}public LinkedStack() {top = new Node(new Object());}//头插法public void push(E val){Node<E> newNode=new Node(val) ;//创建⼀个值为val的节点newNode.next=top.next; //新插⼊节点的next指向原top指向的nexttop.next=newNode;//再把top.next指向新节点}//获取栈顶元素并删除public E remove(){if(top.next==null){throw new UnsupportedOperationException("the stack has been empty");}E result=top.next.data;top.next=top.next.next;return result;}public E peek(){if(top.next==null){throw new UnsupportedOperationException("the stack has been empty");}return top.next.data;}//从top节点的下⼀个开始遍历,不为空则⼀直的打印public void show(){Node<E> tmp=top.next;while (tmp!=null){System.out.print(tmp.data+" ");tmp=tmp.next;}System.out.println();}public static void main(String[] args) {LinkedStack<Integer> l=new LinkedStack();l.push(3);l.push(4);l.push(5);l.show();System.out.println(l.peek());l.remove();//删除5l.show();l.remove();//删除4l.show();l.remove();//删除3l.show();}}练习2:查找链表中倒数第k个节点//单链表查找倒数第k个节点class FindLastK<E> {Node<E> head;class Node<E> {protected E data;protected Node<E> next;public Node(E data,Node<E> next) {this.data = data;this.next=next;}}////构造函数,第⼀个头结点有效,所以不需要构造函数// public FindLastK() {// this.head = new Node(new Object(),null);// }//找倒数第k个数的⽅法public E lastK(int k){Node<E> cur1=this.head.next;Node<E> cur2=this.head;//cur2指向头if(head==null){return null;}if(k>getLenth()||k<=0){return null;}else if(k==getLenth()){return head.data;}for(int i=1;i<=k;i++) {cur2=cur2.next;if(cur2==null){return null;}}while (cur2.next!=null){cur2=cur2.next;cur1=cur1.next;}return cur1.data;}//获取链表长度public int getLenth(){int length=0;Node<E> cu=head;if(head==null){return 0;}while (cu!=null){ //应该让cur去遍历,不能让head直接遍历,否则打印⼀次后show再次打印链表就会空 length++;cu=cu.next;}return length;}//尾插法public void add(E val) {Node<E> newNode = new Node(val,null);Node<E> current = head;if(head==null){head=newNode;return;}while (current.next != null) {current = current.next;}current.next = newNode;// newNode.next=null;}public void show() {Node<E> current = head;if(current==null){System.out.println("链表空!!");return;}while (current!=null&¤t.next!= null) {System.out.print(current.data + " ");current = current.next;}System.out.println(current.data);}}public class FindLastKTest{public static void main(String[] args) {FindLastK<Integer> f=new FindLastK<>();f.add(3);f.add(4);f.add(5);f.add(6);f.show();System.out.println("该链表的长度:"+f.getLenth());System.out.println(stK(1));//6System.out.println(stK(4));//3System.out.println(stK(5));//nullf.show();}}练习3:找到带环链表的⼊⼝节点import sun.awt.image.ImageWatched;//单链表查找倒数第k个节点public class LinkedExercise<E> {Node<E> head;static class Node<E> {protected E data;public Node<E> next;public Node(E data, Node<E> next) {this.data = data;this.next = next;}}////构造函数,第⼀个头结点有效,所以不需要构造函数// public FindLastK() {// this.head = new Node(new Object(),null);// }//找倒数第k个数的⽅法public E lastK(int k) {Node<E> cur1 = this.head.next;Node<E> cur2 = this.head;//cur2指向头if (head == null) {return null;} else if (k > getLenth() || k <= 0) {return null;}//如果找的倒数第k个恰好为链表长度,直接将头结点的数返回else if (k == getLenth()) {return head.data;}for (int i = 1; i <= k; i++) {cur2 = cur2.next;if (cur2 == null) {return null;}}//两个节点同时遍历,快节点遍历到最后⼀个节点时,慢节点指向的节点就是要找的节点while (cur2.next != null) {cur2 = cur2.next;cur1 = cur1.next;}return cur1.data;}//获取链表长度public int getLenth() {int length = 0;Node<E> cu = head;if (head == null) {return 0;}while (cu != null) { //应该让cur去遍历,不能让head直接遍历,否则打印⼀次后show再次打印链表就会空 length++;cu = cu.next;}return length;}//判断单链表是否有环/*** 快慢指针,先通过两个指针找到环内的节点,然后再⼀个节点从相交节点出发,* 另⼀个节点从头结点出发,再次相交的节点就是环的⼊⼝节点** @return*/public E getLinkCirclrVal() {Node<E> slow = this.head;Node<E> fast = this.head;//找到了相交节点while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (slow == fast) {break;}}if (fast == null) {return null;} else {fast = this.head;while (fast != slow) {fast = fast.next;slow = slow.next;}return slow.data;}}//尾插法public void add(E val) {Node<E> newNode = new Node(val, null);Node<E> current = head;if (head == null) {head = newNode;return;}while (current.next != null) {current = current.next;}current.next = newNode;// newNode.next=null;}public void show() {Node<E> current = head;if (current == null) {System.out.println("链表空!!");return;}while (current != null && current.next != null) {System.out.print(current.data + " ");current = current.next;}System.out.println(current.data);}//构造带环的链表public void con(LinkedExercise<E> link){//将两个节点都指向头LinkedExercise.Node list=link.head;LinkedExercise.Node p=link.head;//list遍历到最后⼀个节点while (list.next!=null){list=list.next;}//让最后⼀个节点的写⼀个指向头结点的下⼀个 6指向5list.next=p.next.next;}public static void main(String[] args) {LinkedExercise<Integer> f = new LinkedExercise<>();f.add(3);f.add(4);f.add(5);f.add(6);f.show();System.out.println("该链表的长度:" + f.getLenth());System.out.println(stK(1));//6System.out.println(stK(4));//3System.out.println(stK(5));//nullf.con(f);System.out.println("环的⼊⼝节点:"+f.getLinkCirclrVal());}}练习4:合并两个有序的链表(头结点⽆效时)包含头结点⽆效的⼤多数函数:class SingleLinekdListTakeHead<E extends Comparable> {protected Node<E> head;//头节点class Node<E> {protected E data;//数据域protected Node<E> next;//next引⽤域public Node(E data, Node<E> next) {this.data = data;this.next = next;}}//初始化headpublic SingleLinekdListTakeHead() {head = new Node(new Object(), null);}//在head之后直接插⼊⼀个节点,头插法public void addHead(E element) {Node<E> newNode = new Node(element, null);newNode.next = head.next;//先让新添加的节点的下⼀个指向原head节点指向的 head.next = newNode;//再让head节点指向新节点}//尾插法public void addTail(E element) {Node<E> newNode = new Node(element, null);Node<E> tail = head;//定义⼀个节点从头⾛到尾//tail⾛到当前链表的尾部while (tail.next != null) {tail = tail.next;}tail.next = newNode;newNode.next=null;}/*** 固定位置插⼊⼀个节点* 判断参数合法性* 找到pos位置的前⼀个节点* @param pos 固定位置* @param element 元素*/public void addPos(int pos, E element) {if (pos <= 0 || pos > getLength()) {return;}Node<E> prev = head.next;int index = 1;while (index++ < pos - 1) {prev = prev.next;}Node<E> newNode = new Node<>(element, null);newNode.next = prev.next;prev.next = newNode;}//删除元素为element的节点public boolean remove(E element) {//如果只有⼀个头结点,返回falseif (head.next == null) {return false;}//找到该元素所对应的节点 + 该元素所对应的节点的前⼀个 //从头结点开始遍历Node<E> tmp = head;while (tmp != null) {if (tmp.next != null && tmp.next.data == element) {//tmp.next是我们要删除的节点 tmp是删除节点的前⼀个 tmp.next = tmp.next.next;return true;}tmp = tmp.next;}return false;}//设置某个位置的值为newElementpublic void set(int pos, E newElement){if(pos <= 0 || pos > getLength()){return;}//找pos位置的节点Node<E> tmp = head.next;for(int i=1; i < pos; i++){tmp = tmp.next;}tmp.data = newElement;}//得到某个元素的值public E get(E element){Node<E> tmp = head.next;//从有效节点开始遍历while(tmp != null){if(tmp.data == element){return tmp.data; //找到的话,返回该节点}tmp = tmp.next;}return null;} //合并两个有序的单链表public void merge(SingleLinekdListTakeHead<E> list2){// LinkedExercise<E> list3=new LinkedExercise<>();Node<E> p=this.head;//最后合并成功的的链表Node<E> p1=this.head.next;//第⼀的链表Node<E> p2=list2.head.next;//第⼆个链表while (p1!=null && p2!=null){if(pareTo(p2.data)>=0){p.next=p2;//list3.add(p2.data);p2=p2.next;}else {p.next=p1;// list3.add(p1.data);p1=p1.next;}p=p.next;}if(p1!=null){ //链表1还有剩余节点p.next=p1;}p.next=p2;}// return p.data;}//返回长度public int getLength() {Node<E> tmp = head.next;int length = 0;while (tmp != null) {length++;tmp = tmp.next;}return length;}//打印栈public String toString() {StringBuilder strs = new StringBuilder();Node<E> tmp = head.next;while (tmp != null) {strs.append(tmp.data + " ");tmp = tmp.next;}return strs.toString(); //strs是StringBuilder类型,应该添加toString⽅法,才能返回String类型的 }//逆置带有头结点的单链表public void reverse(){if(head.next==null||head.next.next==null){return;}else {Node<E> cur=this.head.next.next;//指向第⼆个有效的节点this.head.next.next=null;Node<E> pos=null;while (cur!=null){pos=cur.next;//先将cur.next指向poscur.next=head.next;head.next=cur;//头插法,将节点插在head后cur=pos;}}}}public class Linked {public static void main(String[] args) {SingleLinekdListTakeHead<Integer> list=new SingleLinekdListTakeHead();list.addHead(3);list.addHead(5);list.addHead(8);System.out.println(list.toString());//8 5 3list.addTail(1);list.addTail(2);list.addTail(4);System.out.println(list.toString());//8 5 3 1 2 4list.reverse();System.out.println(list.toString());// list.addPos(2, 100); //在2 号位置加⼊元素100// System.out.println(list.toString());// list.addPos(0, 1000);// System.out.println(list.toString());//// list.remove(4);// System.out.println("删除值为4的元素:"+list.toString());//// list.set(2,2);//true,把2号元素的值改为2// System.out.println("把2号元素的值改为2:"+list.toString());// System.out.println(list.get(3));SingleLinekdListTakeHead list1=new SingleLinekdListTakeHead();list1.addTail(2);list1.addTail(6);list1.addTail(7);SingleLinekdListTakeHead list2=new SingleLinekdListTakeHead();list2.addTail(3);list2.addTail(4);list2.addTail(5);list2.addTail(9);list2.addTail(10);list1.merge(list2);System.out.println(list1.toString());}}练习5:链式队列package Exercise;public class LinkedQueue<T> {private Entry<T> front;private Entry<T> rear;private int count;public LinkedQueue(){this.front=this.rear=new Entry<>(null,null);}class Entry<T>{T data;Entry<T> next;public Entry(T data,Entry<T> next){this.data=data;this.next=next;}}public void offer(T data){Entry<T> node=new Entry<>(data,null);this.rear.next=node;this.rear=node;this.count++;}/***出队列需要判断队列空的情况,头节点⽆效;如果队列为空,需要将front和rear都指向空*/public void poll(){if(this.front.next!=null){this.front.next=this.front.next.next;if(this.front.next == null){this.rear = this.front;}this.count--;}}public int size(){return this.count;}public T peek(){return this.front.next.data;}public void show(){Entry<T> cur=this.front.next;while (cur!=null){System.out.print(cur.data+" ");cur=cur.next;}System.out.println();}public static void main(String[] args) {LinkedQueue l=new LinkedQueue();for (int i = 0; i < 4; i++) {l.offer(i);}l.show();System.out.println("队头元素为:"+l.peek());System.out.println("队列长度为:"+l.size());l.poll();l.show();}}难点:内部类和外部类的构造函数都需要对相应属性做初始化。
python链表试题
python链表试题含解答共5道1. 试题:反转链表编写一个函数,反转一个单链表。
```pythonclass ListNode:def __init__(self, value=0, next=None):self.value = valueself.next = nextdef reverse_linked_list(head):prev = Nonecurrent = headwhile current is not None:next_node = current.nextcurrent.next = prevprev = currentcurrent = next_nodereturn prev```2. 试题:检测环编写一个函数,检测一个链表是否有环。
```pythondef has_cycle(head):slow = headfast = headwhile fast is not None and fast.next is not None:slow = slow.nextfast = fast.next.nextif slow == fast:return Truereturn False```3. 试题:合并两个有序链表编写一个函数,合并两个有序链表为一个新的有序链表。
```pythondef merge_two_lists(l1, l2):dummy = ListNode()current = dummywhile l1 is not None and l2 is not None:if l1.value < l2.value:current.next = l1l1 = l1.nextelse:current.next = l2l2 = l2.nextcurrent = current.nextif l1 is not None:current.next = l1else:current.next = l2return dummy.next```4. 试题:移除链表元素编写一个函数,移除链表中所有值为给定值的节点。
链表c语言经典例题
链表c语言经典例题
链表是计算机科学中的经典数据结构之一,常用于存储和操作动态数据。
以下是一些常见的链表例题,可以帮助理解链表的基本操作和应用。
1. 链表的创建:
- 创建一个空链表。
- 创建一个包含指定节点值的链表。
2. 链表的插入操作:
- 在链表的头部插入一个节点。
- 在链表的尾部插入一个节点。
- 在指定位置插入一个节点。
3. 链表的删除操作:
- 删除链表的头节点。
- 删除链表的尾节点。
- 删除指定数值的节点。
4. 链表的查找操作:
- 查找链表中指定数值的节点。
- 查找链表的中间节点。
5. 链表的逆序操作:
- 反转整个链表。
- 反转链表的前 N 个节点。
- 反转链表的一部分区间内的节点。
6. 链表的合并操作:
- 合并两个有序链表,使其有序。
- 合并 K 个有序链表,使其有序。
7. 链表的环检测:
- 判断链表中是否存在环,若存在,则返回环的起始节点。
8. 链表的拆分操作:
- 将一个链表按照奇偶位置拆分成两个链表。
以上是一些链表的经典例题,通过解答这些例题,可以加深对链表结构和基本操作的理解。
在编写对应的 C 语言代码时,需要注意链表节点的定义、指针的使用以及内存的动态分配和释放等问题。
链表练习题及答案
1、已知L是带表头的单链表,其P结点既不是首元结点,也不是尾元结点,a.删除p结点的直接后继的语句是11,3,14b.删除p结点的直接前驱的语句是10,12,8,11,3,14c.删除p结点的语句序列是10,7,3,14d.删除首元结点的语句序列是12,10,13,14e.删除尾元结点的语句序列是9,11,3,14(1)p=p->next;(2) p->next=p;(3)p->next=p->next->next;(4)p=p->next->next;(5)while(p)p=p->next;(6)whlie(Q->next){p=Q;Q=Q->next;}(7)while(p->next!=Q)p=p->next;(8)while(p->next->next!=Q)p=p->next;(9)while(p->next->next)p=p->next;(10)Q=p;(11)Q=p->next;(12)p=L;(13)L=L->next;(14)free(Q);2、已知L是带表头的单链表,其P结点既不是首元结点,也不是尾元结点,a.在p结点后插入s结点的语句序列是4,1b.在p结点前插入s结点的语句序列是7,11,8,4,1c.在表首插入s结点的语句序列是5,12d.在表尾插入s结点的语句序列是7,9,4,1或11,9,1,61.p-> next =s;2.p-> next=p-> next-> next;3.p->next=s->next;4.s->next=p-> next;5.s-> next=L;6.s->next=NULL;7.q=p ;8.while(p->next!=q) p=p->next;9.while(p->next!=NULL) p=p->next;10.p =q;11.p=L;12.L=s;13.L=P;3、已知P结点是某双向链表的中间结点,从下列提供的答案中选择合适的语句序列a.在P结点后插入S结点的语句序列是12,7,3,6b.在P结点前插入S结点的语句序列是13,8,5,4c.删除p结点的直接后继结点的语句序列是15,1,11,18d.删除p结点的直接前驱结点的语句序列是16,2,10,18e.删除p结点的语句序列是9,14,171.P->next=P->next->next;2.P->priou=P->priou->priou;3.P->next=S;4.P->priou=S;5.S->next=P;6.S->priou=P;7.S->next=P->next;8.S->priou=P->priou;9.P->priou->next=P->next;10.P->priou->next=P;11.P->next->priou=P;12.P->next->priou=S;13.P->priou->next=S;14.P->next->priou=P->priou;15.Q=p->next;16.Q=P->priou;17.free(P);18.free(Q);。
数据结构链表习题
练习题:1)在一个单链表head中,若要在指针p所指结点后插入一个q指针所指结点,则执行_____。
A. p->next=q->next; q->next=p;B. q->next=p->next; p=q;C. p->next=q->next; p->next=q;D. q->next=p->next; p->next=q;2)在一个单链表head中,若要删除指针p所指结点的后继结点,则执行_____。
A. p=p->next;free(p);B. p->next=p->next->next; free(p);C. q= p->next ;q->next=p->next; free(q);D. q=p->next; p->next=q->next ;free(q);3)若长度为n的线性表(a1, a2,…, a n)采用顺序存储,在第i个位置上插入一个新元素,需要依次向后移动个数据元素。
A n-iB n-i-1C n-i+1D n+i3)完成下列打印带头单链表的各元素的算法.typedef struct List{ int data;struct List *next;} Node,*Link;void printlk(Link head){Link p=head->next;{ printf(“%d\n”,p->data);}4)已知无头单链表A和B表示两个集合,本算法实现A=A-B (集合的补运算)。
typedef struct node {int data;struct node *next;}lnode;void setminus(lnode *&A,lnode *B)while (B!=NULL){p=A;}A=A->next;}5)下列算法创建n个元素的带头单链表.typedef struct lnode { int data;struct lnode *next;}lnode,*linklist ;void create(linklist &head, int n){linklist p; int i;head=(linklist)malloc(sizeof(lnode));A head->next=nullfor(i=n;i>0;i--){p =(linklist)malloc(sizeof(lnode));scanf(“%d”,&p->data);B p->next=head->nextC head->next=p}}。
链表算法例题及练习
单链表算法练习(一)上节课思考问题:1、链表的特点是什么?2、结点、数据域、指针域?3、单链表、双链表、多链表、循环链表?4、头指针、头结点?5、在链表中设置头结点的好处?算法1:创建单链表(头插法,课本算法2.11)void CreateList(参数列表) Linklist &L, int n {第一步:开辟头结点,使其成为一个空单链表L=Malloc(sizeof(Lnode));L->next=NULL;第二步:依次创建新结点For(i=n;i>0;i--)开辟新结点P=Malloc(sizeof(Lnode));赋值Scanf(&P->data);使其成为后一结点P->next=L->next;插入到表头L->next=p;}算法2:查找(返回第i个元素的值,课本算法2.8)status GetElem_L(参数列表) LinkList L, int i, ElemType &e{第一步:初始化,从第一个结点开始P=L->next;J=1;第二步:顺序向后查找,直到表尾或找到第i个元素While(!p && j>i ){P=p->next;J++}第三步:判断是否找到该元素(没有,返回ERROR;有,将其存放于指定元素)If(!p || j>i) return ERROR;E=p->data;第四步:返回OKreturn OK;}单链表思考练习题一:1、用单链表结构来存放26个英文字母组成的线性表(a,b,c,…,z),请写出C语言程序。
难点分析:每个数据元素在内存中是“零散”存放的,其首地址怎么找?又怎么一一链接?实现思路:先开辟头指针,然后陆续为每个数据元素开辟存储空间并赋值,并及时将地址送给前面的指针。
2、思考尾插法创建单链表的算法。
3、分析课本算法2.9和2.10。
课堂练习题---链表
1、设单链表中指针P指着结点A ,若要删除A之后结点(若存在),则需要修改指针的操作为()。
A. p->next=p->next->nextB. p=p->nextC. p=p->next->nextD. P->next=p8.从一个具有n个节点的单链表中查找其值等于x结点时,在查找成功的情况下,需平均比较个结点。
A. nB. n/2C. (n-1)/2D. (n+1)/22.在一个单链表中,已知*q结点是*p结点的前驱结点,若在*q和*p之间插入*s 结点,则执行。
A. s->next=p->next; p->next=s;B. p->next=s->next; s->next=p;C. q->next=s; s->next=p;D. p->next=s; s->next=q;3.线性表采用链式存储时,其地址。
A. 必须是连续的B.部分地址必须是连续的C. 一定是不连续的D. 连续与否均可以4.设单链表中指针p指着结点(数据域为m),指针f指着将要插入的新结点(数据域为x),当x插在结点m之后时,只要先修改后修改p->link=f即可。
A. f->link=p;B. f->link=p->link;C. p->link=f->link;D. f=nil;5.在双向链表存储结构中,删除p所指的结点时需修改指针。
A. ((p->rlink) ->rlink) ->link=p; p->rlink=(p->rlink) ->rlink;B. (p->llink) ->rlink=p->rlink; (p->rlink) ->llink=p->llink;C. p->llink=(p->llink) ->llink; ((p->llink) ->llink) ->rlink=p;D. ((p->llink) ->llink) ->rlink=p; p->llink=(p->llink) ->llink;6.在双向链表存储结构中,删除p所指的结点的前趋结点(若存在)时需修改指针。
数据结构应用题练习
数据结构应用题练习一、简介数据结构是计算机科学中的重要概念,是指数据组织、管理和存储的方式。
它是计算机处理和分析数据的基础,在各个领域都有广泛的应用。
本文将通过几个数据结构应用题的练习,展示数据结构在实际问题中的应用。
二、链表应用题链表是一种常见的数据结构,在许多场景中都有广泛的应用。
假设有一组学生的信息,包括学生姓名、年龄和成绩,请使用链表来存储并实现以下操作:1. 添加学生信息2. 删除学生信息3. 查找学生信息4. 修改学生信息三、栈应用题栈是一种后进先出(LIFO)的数据结构,在很多应用中都有不可或缺的地位。
以网页浏览器的前进和后退功能为例,使用栈可以很方便地实现该功能。
请描述如何使用栈来实现浏览器的前进和后退功能,并分析算法的时间复杂度。
四、队列应用题队列是一种先进先出(FIFO)的数据结构,常用于处理排队等场景。
现假设有一个任务队列,多个任务需要按照顺序执行。
请使用队列来存储任务,并实现以下操作:1. 添加任务到队列2. 从队列中取出并执行任务3. 判断队列是否为空4. 清空队列中的所有任务五、树应用题树是一种重要的非线性数据结构,在很多领域都有广泛应用。
假设有一组学生的信息,包括学生姓名、年龄和成绩,请使用树来存储这些信息,并实现以下操作:1. 添加学生信息到树中2. 从树中查找指定学生的信息3. 删除指定学生的信息4. 获取树中所有学生的平均成绩六、图应用题图是一种用于描述事物之间关系的数据结构,在网络分析、路径规划等领域有广泛应用。
假设有一张地图,其中包含若干城市和连接它们的道路,请使用图来存储地图信息,并实现以下操作:1. 添加城市和道路到图中2. 查找两个城市之间的最短路径3. 删除某个城市及其相关的道路4. 统计图中有多少个孤立的城市七、哈希表应用题哈希表是一种通过散列函数实现高效存储和查找的数据结构,在很多场景中都有广泛应用。
假设有一组学生的信息,包括学生姓名、年龄和成绩,请使用哈希表来存储这些信息,并实现以下操作:1. 添加学生信息到哈希表中2. 从哈希表中查找指定学生的信息3. 删除指定学生的信息4. 统计哈希表中学生信息的个数八、总结以上是几个常见的数据结构应用题的练习,通过这些练习可以更深入地理解数据结构的应用和算法的设计。
C语言链表题目及答案
下面哪种选项描述了链表的特点?A) 可以随机访问元素B) 拥有固定大小的内存空间C) 元素之间通过指针连接D) 可以自动调整大小答案: C在链表中,头节点的作用是什么?A) 存储链表的长度B) 存储链表的最后一个节点C) 存储链表的第一个节点D) 存储链表的中间节点答案: C下面哪种选项描述了双向链表的特点?A) 每个节点只有一个指针指向下一个节点B) 每个节点只有一个指针指向上一个节点C) 每个节点同时拥有指向前一个节点和后一个节点的指针D) 只能从链表的一端进行操作答案: C在链表中,删除一个节点的操作涉及修改哪些指针?A) 只需要修改被删除节点的前一个节点的指针B) 只需要修改被删除节点的后一个节点的指针C) 需要修改被删除节点的前一个节点和后一个节点的指针D) 不需要修改任何指针答案: C在链表的尾部添加一个新节点的操作复杂度是多少?A) O(1)B) O(n)C) O(log n)D) O(n^2)答案: A如何遍历链表的所有节点?A) 使用for循环B) 使用while循环C) 使用递归函数D) 使用if语句答案: B在链表中,如何找到特定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 二叉树D) 堆栈答案: A在链表中,如何在指定位置插入一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的头指针指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A链表中节点的个数称为什么?A) 链表的长度B) 链表的高度C) 链表的宽度D) 链表的容量答案: A在链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单链表的最后一个节点指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) NULLD) 链表的中间节点答案: C双向链表相比于单向链表的优势是什么?A) 占用更少的内存空间B) 遍历速度更快C) 可以从任意方向遍历D) 插入和删除操作更快答案: C在链表中,如何找到倒数第n个节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用双指针技巧答案: D链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A在链表中,如何判断链表是否为空?A) 检查头指针是否为NULLB) 检查尾指针是否为NULLC) 检查链表的长度是否为0D) 检查链表的第一个节点是否为NULL答案: A链表的逆序操作是指什么?A) 删除链表中的节点B) 反转链表中节点的顺序C) 插入节点到链表的尾部D) 在链表中查找指定值的节点答案: B在链表中,如何查找指定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A在双向链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的插入操作和数组的插入操作的时间复杂度分别是什么?A) 链表的插入操作为O(1),数组的插入操作为O(n)B) 链表的插入操作为O(n),数组的插入操作为O(1)C) 链表的插入操作为O(n),数组的插入操作为O(n)D) 链表的插入操作为O(1),数组的插入操作为O(1)答案: A如何删除单向链表中的重复节点?A) 使用递归算法B) 使用双指针技巧C) 使用栈数据结构D) 不需要额外操作,链表会自动去重答案: B链表的优势之一是什么?A) 随机访问速度快B) 占用内存空间少C) 插入和删除操作高效D) 支持高级操作如排序和搜索答案: C在链表中,如何找到中间节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用快慢指针技巧答案: D在链表中,如何在尾部添加一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 创建一个新节点并更新尾指针答案: D链表的查找操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: C在双向链表中,如何找到倒数第n个节点?A) 从头节点开始遍历B) 从尾节点开始遍历C) 使用递归函数D) 使用双指针技巧答案: B链表的删除操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 哈希表D) 栈答案: A如何判断链表是否有环?A) 使用线性搜索B) 使用递归算法C) 使用快慢指针技巧D) 使用栈数据结构答案: C在链表中,如何反转链表的顺序?A) 使用递归算法B) 使用栈数据结构C) 使用双指针技巧D) 使用循环迭代答案: D在链表中,如何删除所有节点?A) 依次删除每个节点B) 修改头指针为NULLC) 修改尾指针为NULLD) 不需要额外操作,链表会自动清空答案: A链表的头节点是什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A在链表中,如何插入一个新节点到指定位置之前?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A在链表中,如何删除指定位置的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单向链表和双向链表的区别是什么?A) 单向链表只有一个指针指向下一个节点,双向链表有两个指针分别指向前一个节点和后一个节点B) 单向链表只能从头到尾遍历,双向链表可以从头到尾或者从尾到头遍历C) 单向链表只能在尾部添加节点,双向链表可以在头部和尾部都添加节点D) 单向链表只能包含整型数据,双向链表可以包含任意类型的数据答案: A链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A如何判断两个链表是否相交?A) 比较链表的长度是否相等B) 比较链表的头节点是否相等C) 比较链表的尾节点是否相等D) 比较链表中的所有节点是否相等答案: B链表和数组的主要区别是什么?A) 链表是一种线性数据结构,数组是一种非线性数据结构B) 链表的长度可变,数组的长度固定C) 链表支持随机访问,数组只能顺序访问D) 链表的插入和删除操作效率高,数组的访问效率高答案: B在链表中,如何找到倒数第k个节点?A) 从头节点开始遍历,直到倒数第k个节点B) 从尾节点开始遍历,直到倒数第k个节点C) 使用递归函数查找倒数第k个节点D) 使用双指针技巧,一个指针先移动k步,然后两个指针同时移动直到第一个指针到达链表末尾答案: D在链表中,如何判断是否存在环?A) 使用线性搜索,检查是否有重复的节点B) 使用递归算法,判断节点是否已经访问过C) 使用栈数据结构,检查节点是否已经入栈D) 使用快慢指针技巧,如果两个指针相遇,则存在环答案: D如何将两个有序链表合并成一个有序链表?A) 创建一个新链表,依次比较两个链表的节点并插入新链表中B) 将第一个链表的尾节点指向第二个链表的头节点C) 将第二个链表的尾节点指向第一个链表的头节点D) 使用递归算法,依次比较两个链表的节点并合并答案: A在链表中,如何删除重复的节点?A) 使用递归算法,遍历链表并删除重复的节点B) 使用双指针技巧,依次比较相邻节点并删除重复的节点C) 使用栈数据结构,检查节点是否已经入栈并删除重复的节点D) 不需要额外操作,链表会自动去重答案: B链表的优点是什么?A) 占用内存空间少B) 插入和删除操作高效C) 支持高级操作如排序和搜索D) 可以随机访问任意位置的元素答案: B。
历年链表考题与答案
历年链表考题及答案[2005秋II.14]设已建立了两条单向链表,这两链表中的数据已按从小到大的次序排好,指针h1和h2分别指向这两条链表的首结点。
链表上结点的数据结构如下:structnode{intdata;node*next;};以下函数node*Merge(node*h1,node*h2)的功能是将h1和h2指向的两条链表上的结点合并为一条链表,使得合并后的新链表上的数据仍然按升序排列,并返回新链表的首结点指针。
算法提示:首先,使newHead和q都指向首结点数据较小链表的首结点,p指向另一链表首结点。
其次,合并p和q所指向的两条链表。
在q不是指向链尾结点的情况下,如果q 的下一个结点数据小于p指向的结点数据,则q指向下一个结点;否则使p1指向q的下一个结点,将p指向的链表接到q所指向的结点之后,使q指向p所指向的结点,使p指向p1所指向的链表。
直到p和q所指向的两条链表合并结束为止。
注意,在合并链表的过程中,始终只有两条链表。
[函数](4分)node*Merge(node*h1,node*h2){node*newHead,*p,*p1;//使newHead和q指向首结点数据较小链表的首结点,p指向另一链表首结点if((27)){newHead=h1;p=h2;}//h1->data<h2->dataelse{newHead=h2;p=h1;}node*q=newHead;//合并两条链表while(q->next){if(q->next->data<p->data)(28);//q=q->nextelse{(29);//p1=q->nextq->next=p;q=p;p=p1;}}q->next=p;(30);//returnnewNead}[2005春II.11]设已建立一条单向链表,指针head指向该链表的首结点。
算法例题
算法例题1.假设有两个按元素值递增次序排列的线性表,均以单链表形式存储。
请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表,并要求利用原来两个单链表的结点存放归并后的单链表。
答: [题目分析]因为两链表已按元素值递增次序排列,将其合并时,均从第一个结点起进行比较,将小的链入链表中,同时后移链表工作指针。
该问题要求结果链表按元素值递减次序排列。
故在合并的同时,将链表结点逆置。
LinkedList Union(LinkedList la,lb)∥la,lb分别是带头结点的两个单链表的头指针,链表中的元素值按递增序排列,本算法将两链表合并成一个按元素值递减次序排列的单链表。
{ pa=la->next; pb=lb->next;∥pa,pb分别是链表la和lb的工作指针la->next=null; ∥la作结果链表的头指针,先将结果链表初始化为空。
while(pa!=null && pb!=null) ∥当两链表均不为空时作if(pa->data<=pb->data){ r=pa->next; ∥将pa 的后继结点暂存于r。
pa->next=la->next; ∥将pa结点链于结果表中,同时逆置。
la->next=pa;pa=r; ∥恢复pa为当前待比较结点。
}else{r=pb->next; ∥ 将pb 的后继结点暂存于r。
pb->next=la->next; ∥将pb结点链于结果表中,同时逆置。
la->next=pb;pb=r; ∥恢复pb为当前待比较结点。
}while(pa!=null) ∥将la表的剩余部分链入结果表,并逆置。
{r=pa->next; pa->next=la->next; la->next=pa; pa=r; }while(pb!=null){r=pb->next; pb->next=la->next; la->next=pb; pb=r; }}∥算法Union结束。
链表 应用题
链表应用题
链表是一种常用的数据结构,可以用来解决很多实际问题。
下面是一些链表的应用题:
1. 约瑟夫环问题:约瑟夫环问题是一个经典的链表问题,通常使用单向循环链表来解决。
在这个问题中,n个人围坐在一张圆桌周围,从编号为k的人开始报数,数到m的那个人出列,然后下一个人继续从1开始报数,直到所有人出列。
解决问题的关键是建立一个单向循环链表,然后从链表第一个结点起循环计数寻找第m个结点,并输出该结点的id值。
接着根据m值不断从链表中删除结点,直到链表为空。
2. 反转链表:反转链表也是一个经典的链表问题。
给定一个链表的头节点,将链表中的节点反转。
可以使用迭代或递归的方法来解决这个问题。
具体实现方法是将链表的头节点存储在一个指针变量中,然后从头节点开始遍历链表,每次将当前节点的next指针指向前一个节点,直到遍历完整个链表。
最后返回头节点即可。
3. 合并两个有序链表:给定两个升序链表,合并它们为一个新的升序链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
可以使用双指针法来解决这个问题。
具体实现方法是分别从头节点开始遍历两个链表,每次比较两个节点的值,将较小的节点加入到新链表中,直到遍历完其中一个
链表。
然后继续遍历另一个链表,将剩余的节点加入到新链表中。
最后返回新链表的头节点即可。
以上是几个常见的链表应用题,使用不同的方法可以解决不同的问题。
解决这些问题的关键是理解链表的基本操作和性质,并能够根据具体问题选择合适的数据结构和算法。
单向链表练习题
单向链表练习题单向链表练习题链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在计算机科学中,链表常用于实现其他数据结构,如栈和队列。
掌握链表的基本操作对于编程人员来说是至关重要的。
在本篇文章中,我们将通过一些练习题来加深对单向链表的理解。
1. 反转链表题目:给定一个单向链表,将其反转。
示例:输入:1 -> 2 -> 3 -> 4 -> 5输出:5 -> 4 -> 3 -> 2 -> 1解析:反转链表是一个常见的链表操作。
我们可以使用三个指针prev、curr和next来完成反转。
初始时,prev指向null,curr指向头节点。
我们需要将curr的next指针指向prev,然后移动prev、curr和next指针,直到遍历完整个链表。
2. 链表中倒数第k个节点题目:给定一个单向链表,找到链表中倒数第k个节点。
示例:输入:1 -> 2 -> 3 -> 4 -> 5,k = 2输出:4解析:要找到链表中倒数第k个节点,我们可以使用双指针法。
首先,我们让一个指针p1指向链表的头节点,然后让另一个指针p2指向链表的第k个节点。
接下来,同时移动p1和p2指针,直到p2指向链表的末尾。
此时,p1指向的节点就是倒数第k个节点。
3. 合并两个有序链表题目:给定两个有序链表,将它们合并为一个有序链表。
示例:输入:1 -> 2 -> 4, 1 -> 3 -> 4输出:1 -> 1 -> 2 -> 3 -> 4 -> 4解析:合并两个有序链表是一个常见的链表操作。
我们可以使用递归或迭代的方式来实现。
递归的思路是比较两个链表的头节点,将较小的节点作为合并后的链表的头节点,并递归地合并剩余的节点。
迭代的思路是使用一个额外的指针来指向合并后的链表的末尾,然后比较两个链表的头节点,将较小的节点接在末尾,并更新指针和链表头。
习题3(链表)
习题3(链表)一、选择题(1)链接存储的存储结构所占存储空间( A )。
A)分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针B)只有一部分,存放结点值C)只有一部分,存储表示结点间关系的指针D)分两部分,一部分存放结点值,另一部分存放结点所占单元数(2)线性表若采用链式存储结构时,要求内存中可用存储单元的地址( D )。
A)必须是连续的B)部分地址必须是连续的C)一定是不连续的D)连续或不连续都可以(3)线性表L在( B )情况下适用于使用链式结构实现。
A)需经常修改结点值B)需不断删除插入C)含有大量的结点D)结点结构复杂(4)单链表的存储密度( C )。
A)大于1 B)等于1 C)小于1 D)不能确定(5)若指定有n个元素的向量,则建立一个有序单链表的时间复杂性的量级是( C )。
A)O(1) B)O(n) C)O(n2) D)O(nlog2n)(6)在单链表中,要将s所指结点插入到p所指结点之后,其语句应为( D )。
A)s->next=p+1; p->next=s; B)(*p).next=s; (*s).next=(*p).next;C)s->next=p->next; p->next=s->next; D)s->next=p->next; p->next=s;(7)在双向链表存储结构中,删除p所指的结点时须修改指针( A )。
A)p->next->prior=p->prior; p->prior->next=p->next;B)p->next=p->next->next; p->next->prior=p;C)p->prior->next=p; p->prior=p->prior->prior;D)p->prior=p->next->next; p->next=p->prior->prior;(8)在双向循环链表中,在p指针所指的结点后插入q所指向的新结点,其修改指针的操作是( C )。
链表应用于文件操作,列出几个题目,用于数据结构课程
链表应用于文件操作,列出几个题目,用于数据结构课程
下面是一些关于链表在文件操作中应用的题目,适合数据结构课程的练习:
1、实现一个简单的文本编辑器,支持插入、删除和替换操作,并且能够保存和读取到文件中。
2、编写一个程序,读取一个文本文件,统计每个单词出现的次数,并将结果按照频率从高到低输出到另一个文件中。
3、设计一个程序,实现一个简单的文件压缩工具。
将一个文本文件中连续重复的字符替换为字符和重复次数的表示形式,并将结果保存到另一个文件中。
4、实现一个文件系统模拟程序,可以创建、删除和重命名文件和目录。
使用链表来管理文件和目录的层级结构。
5、编写一个程序,读取一个包含学生信息的文件,每一行表示一个学生的姓名、年龄和成绩。
使用链表存储学生信息,并实现按照姓名或成绩排序的功能。
这些题目涵盖了链表在文件操作中的常见应用场景,可以帮助学生加深对链表数据结构的理解,并提高编程能力。
链表习题——精选推荐
一选择题1.下述哪一条是顺序存储结构的优点?(a )A.存储密度大B.插入运算方便C.删除运算方便D.可方便地用于各种逻辑结构的存储表示2.下面关于线性表的叙述中,错误的是哪一个?(b )A.线性表采用顺序存储,必须占用一片连续的存储单元。
B.线性表采用顺序存储,便于进行插入和删除操作。
C.线性表采用链接存储,不必占用一片连续的存储单元。
D.线性表采用链接存储,便于插入和删除操作。
3.线性表是具有n个(c)的有限序列(n>0)。
A.表元素B.字符C.数据元素D.数据项E.信息项4.若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用(a )存储方式最节省时间。
A.顺序表B.双链表C.带头结点的双循环链表D.单循环链表5.某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用(d )存储方式最节省运算时间。
A.单链表B.仅有头指针的单循环链表C.双链表D.仅有尾指针的单循环链表6.设一个链表最常用的操作是在末尾插入结点和删除尾结点,则选用( d )最节省时间。
A. 单链表B.单循环链表C. 带尾指针的单循环链表D.带头结点的双循环链表//双循环链表处理所有问题要比其他链表更方便7. 静态链表中指针表示的是(c ). A.内存地址B.数组下标C.下一元素地址D.左、右孩子地址8. 链表不具有的特点是(b )A.插入、删除不需要移动元素B.可随机访问任一元素C.不必事先估计存储空间D.所需空间与线性长度成正比9. 下面的叙述不正确的是(b,c )A.线性表在链式存储时,查找第i个元素的时间同i的值成正比B. 线性表在链式存储时,查找第i个元素的时间同i的值无关C. 线性表在顺序存储时,查找第i个元素的时间同i 的值成正比D. 线性表在顺序存储时,查找第i个元素的时间同i的值无关10.非空的循环单链表head的尾结点p↑满足(a )。
A.p↑.link=head B.p↑.link=NIL C.p=NIL D.p= head 11.循环链表H的尾结点P的特点是(a )。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
printf("%6.1f\n",p->ave);
p=p->next;
}while(p!=NULL);
}//输出模块
struct Student*insert()
{
struct Student*pt;
printf("%6d\n",pmax->bian);
}
if(x==4)
{
do
{
if(pmax->english<p1->english)
pmax=p1;
p1=p1->next;
}while(p1!=NULL);
printf("%6d\n",pmax->bian);
t=t+p1->english;
n=n+p1->math;
p1=p1->next;
}while(p1!=NULL);
printf("%24.1f%6.1f%6.1f\n",s/num,t/num,n/num);
}
//求最大值
void ma(struct Student*head,int x)//第二个参数表示要求最大值的数据所在的列编号
head=s;
return head;
}
p=head;
while(p->next!=NULL)
{
if(s->english<p->english&&s->english>p->next->english)
{
s->next=p->next;
}
if(x==5)
{
do
{
if(pmax->math<p1->math)
pmax=p1;
head=s;
return head;
}
p=head;
while(p->next!=NULL)
{
if(s->computer<p->computer&&s->computer>p->next->computer)
{
s->next=p->next;
}
p2->next=NULL;
return(head);
}
void print(struct Student*head)
{
struct Student*p;
p=head;
if(head!=NULL)
do
{
printf("%6s%6d%6ld%6.1f%6.1f%6.1f",p->name,p->bian,p->xue,p->computer,p->english,p->math);
float english;
float math;
float ave;
struct Student*next;
};
struct Student*creat()//创建数据
{
struct Student*head;
struct Student*p1,*p2;
num=0;
{
num=num+1;
if(num==1)
head=p1;
else
p2->next=p1;
p2=p1;
p1=(struct Student*)malloc(N);
scanf("%s%d%ld%f%f%f",&p1->name,&p1->bian,&p1->xue,&p1->computer,&p1->english,&p1->math);
while(p->next!=NULL)
{
if(s->ave<p->ave&&s->ave>p->next->ave)
{
s->next=p->next;
p->next=s;
return head;
}
else
p=p->next;
{
struct Student*p1,*pmax;
pmax=head;
p1=head->next;
if(x==3)
{
do
{
if(pmax->computer<p1->computer)
pmax=p1;
p1=p1->next;
}while(p1!=NULL);
{
struct Student*p=NULL;
if(head==NULL)
{
head=s;
head->next=NULL;
return head;
}
if(head->english<s->english)
{
s->next=head;
p1=p1->next;
p1->next=p2->next;
}
return head;
num--;
//在模块中,若存在该学生,必须改变num的值
}
struct Student*get_front(struct Student **head)
{
struct Student *p=0;
p->next=s;
return head;
}
else
p=p->next;
}
p->next=s;
s->next=NULL;
return head;
}
struct Student*english(struct Student*head)
p=sortaverage(p,q);
}
return p;
}
//求平均值,并在其中输出
void average(struct Student*head)
{
float s=0,t=0,n=0;
struct Student*p1;
p1=head;
do{
s=s+p1->computer;
return head;
}
p=head;
while(p->next!=NULL)
{
if(s->math<p->math&&s->math>p->next->math)
{
s->next=p->next;
p->next=s;
return head;
{
struct Student*p=NULL;
if(head==NULL)
{
head=s;
head->next=NULL;
return head;
}
if(head->computer<s->computer)
{
s->next=head;
pt=creat();
return(pt);
}
struct Student*find(struct Student*head, long x)
{
struct Student*p1;
p1=head;
do
{
if(p1->xue==x)
break;
p1=p1->next;
}
else
p=p->next;
}
p->next=s;
s->next=NULL;
return head;
}
struct Student*math(struct Student*head)
{
struct Student*p=0,*q=0;
while(head!=NULL)
if(*head==NULL) return NULL;
else
{
p=*head;
*head=(*head)->next;
return p;
} ห้องสมุดไป่ตู้
}
//排序函数:按英语,并在其中输出
struct Student*sortenglish(struct Student*head,struct Student*s)
#include<stdio.h>
#include<stdlib.h>
#define N sizeof(struct Student)
int num;
struct Student
{
char name[10];
int bian;
long xue;
float computer;
{
struct Student*p=0,*q=0;
while(head!=NULL)
{