c语言链表大例题

合集下载

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现：```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满，无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

C程序设计(链表)习题与答案

一、单选题1、链表不具有的特点是（）。

A.不必事先估计存储空间B.插入、删除不需要移动元素C.可随机访问任一元素D.所需空间与线性表长度成正比正确答案：C2、链接存储的存储结构所占存储空间（）。

A.分两部分，一部分存放结点值，另一部分存放结点所占单元数B.只有一部分，存放结点值C.分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针D.只有一部分，存储表示结点间关系的指针正确答案：C3、链表是一种采用（）存储结构存储的线性表。

A.网状B.星式C.链式D.顺序正确答案：C4、有以下结构体说明和变量的定义，且指针p指向变量a，指针q指向变量b，则不能把结点b连接到结点a之后的语句是（）。

struct node {char data;struct node *next;} a,b,*p=&a,*q=&b;A.(*p).next=q;B.p.next=&b;C.a.next=q;D.p->next=&b;正确答案：B5、下面程序执行后的输出结果是（）。

#include <stdio.h>#include <stdlib.h>struct NODE {int num; struct NODE *next;};int main(){ struct NODE *p,*q,*r;p=(struct NODE*)malloc(sizeof(struct NODE));q=(struct NODE*)malloc(sizeof(struct NODE));r=(struct NODE*)malloc(sizeof(struct NODE));p->num=10; q->num=20; r->num=30;p->next=q;q->next=r;printf("%d",p->num+q->next->num);return 0;}A.30B.40C.10D.20正确答案：B6、下面程序执行后的输出结果是（）。

c语言链表笔试题

关于链表常考的笔试面试题1、单链表逆序，在原列表的基础上进行调整struct ListNode* ReverseList(struct ListNode* pHead ){// write code here//判断第一个元素是否为空，如果为空，则返回NULL;并判断第二个元素是否为空，如果为空，则不需要逆序，直接返回if(pHead == NULL || pHead->next == NULL) return pHead;//定义三个节点指针，分别存放前一个操作节点，当前操作节点，下一个操作节点struct ListNode *temp1 = NULL,*temp2 = pHead,*temp3 = pHead->next;//当下一个操作节点存在时，执行循环，将当前节点的next指向前一个节点，并移动三个指针位置while(NULL != temp3){temp2->next = temp1;temp1 = temp2;temp2 = temp3;temp3 = temp2->next;}//当temp3为空时，说明temp2指向最后一个节点，只需将它的next指向前一个节点temp2->next = temp1;return temp2;}2、找出链表的倒数第n个节点int query_reverse(List* list,size_t index){Node* f = list->head;Node* s = list->head;for(int i=0;i<index;i++){f = f->next;if(f == NULL) return false;}while(f){f = f->next;s = s->next;}return s->data;3、判断链表中是否有环bool is_ring(List* list){Node* fast = list->head;//快指针Node* slow = list->head;//慢指针while(fast && fast->next){fast = fast->next->next;//快指针每次走两步slow = slow->next;//慢指针每次走一步if(slow == fast) return true;//如果相同，则该链表有环}return false;}4、找到环形链表的入口int ring_in(List* list){if(is_ring){Node* fast = list->head;Node* slow = list->head;Node* meet = list->head;while(fast && fast->next){fast = fast->next->next;slow = slow->next;meet = meet->next;if(slow == fast){slow = list->head;fast = meet;fast = fast->next;slow = slow->next;if(slow == fast)return fast->data;}}}return -1;}5、合并两个有序链表，合并后依然有序List* merge_list(List* list1,List* list2){Node* m = list1->head->next;Node* n = list2->head->next;Node* new = create_node();if(list1 == NULL) return list2;if(list2 == NULL) return list1;if(list1== NULL && list2== NULL) return NULL;while(list1&&list2){if(m->data < n->data){new->next = m;m = m->next;}else{new->next = n;n = n->next;}new = new->next;}new->next = m?m:n;return new;}6、判断两个链表是否是Y型链表bool is_y(List* l1,List* l2){int cnt1 = 0,cnt2 = 0;Node* m = l1->head->next;Node* n = l2->head->next;while(m){cnt1++;m = m->next;}while(n){cnt2++;n = n->next;}if(cnt1>cnt2){for(int i=0;i<cnt1-cnt2;i++){m = m->next;}}else{for(int i=0;i<cnt2-cnt1;i++){n = n->next;}}while(m == NULL || n = NULL){m = m->next;n = n->next;if(m = n) return true;}return false;}。

链表的经典习题

链表的经典习题练习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&&current.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();}}难点：内部类和外部类的构造函数都需要对相应属性做初始化。

C、C++程序设计：链表单元测试与答案

一、单选题1、在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入结点s，则执行（）。

A.s->next=p->next;p->next=s;B.p->next=s->next; s->next=p;C.p->next=s;s->next=q;D.q->next=s;s->next=p;正确答案：D2、在一个表头指针为HL单链表中，若要向表头插入一个由指针p 指向的结点，则执行( )。

A.p一>next＝HL;HL＝p;B.HL＝p; p一>next＝HL;C.p一>next＝Hl; p＝HL;D.p一>next＝HL一>next; HL＝p;正确答案：A3、在单链表指针为p的结点之后插入指针为s的结点，正确的操作是：（）。

A.p->next=s->next;p->next=s;B.p->next=s;s->next=p->next;C.p->next=s;p->next=s->next;D.s->next=p->next;p->next=s;正确答案：D4、在表尾指针为rs的链表的后面插入指针为p的结点的正确语句为（）。

A.p->next=NULL; rs=p;B.rs->next=p; p->next=NULL;C.rs->next=p; rs->next=NULL;D.p->next=rs; rs->next=NULL;正确答案：B5、假设p为表尾指针rs的前驱指针，则删除表尾结点的正确语句为（）。

A.p->next=NULL; delete p;B.p->next=NULL; delete rs;C.p=NULL; delete rs;D.rs=NULL; delete rs;正确答案：B二、判断题1、链表存储时，各结点的存储空间可以是不连续的。

链表c语言经典例题

链表c语言经典例题
链表是计算机科学中的经典数据结构之一，常用于存储和操作动态数据。

以下是一些常见的链表例题，可以帮助理解链表的基本操作和应用。

1. 链表的创建：
- 创建一个空链表。

- 创建一个包含指定节点值的链表。

2. 链表的插入操作：
- 在链表的头部插入一个节点。

- 在链表的尾部插入一个节点。

- 在指定位置插入一个节点。

3. 链表的删除操作：
- 删除链表的头节点。

- 删除链表的尾节点。

- 删除指定数值的节点。

4. 链表的查找操作：
- 查找链表中指定数值的节点。

- 查找链表的中间节点。

5. 链表的逆序操作：
- 反转整个链表。

- 反转链表的前 N 个节点。

- 反转链表的一部分区间内的节点。

6. 链表的合并操作：
- 合并两个有序链表，使其有序。

- 合并 K 个有序链表，使其有序。

7. 链表的环检测：
- 判断链表中是否存在环，若存在，则返回环的起始节点。

8. 链表的拆分操作：
- 将一个链表按照奇偶位置拆分成两个链表。

以上是一些链表的经典例题，通过解答这些例题，可以加深对链表结构和基本操作的理解。

在编写对应的 C 语言代码时，需要注意链表节点的定义、指针的使用以及内存的动态分配和释放等问题。

C语言程序设计专项训练题之单链表

计算机等级考试二级C语言程序设计专项训练题——单链表一．程序填空题1．给定程序的主函数中，已给出由结构体构成的链表结点a、b、c，各结点的数据域中均存入字符，函数fun的功能是：将a、b、c 三个结点链接成一个单向链表，并输出链表结点中的数据。

请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。

注意：不得增行或删行，也不得更改程序的结构！#include <stdio.h>typedef struct list{char data;struct list *next;}Q;void fun(Q *pa, Q *pb, Q *pc){Q *p;/**********found**********/pa->next=___1___;pb->next=pc;p=pa;while( p ){/**********found**********/printf(" %c",____2_____);/**********found**********/p=____3____;}printf("\n");}int main(){Q a, b, c;a.data='E';b.data='F';c.data='G'; c.next=NULL;fun( &a, &b, &c );return 0;}2．给定程序中，函数fun的功能是：统计出带有头结点的单向链表中结点的个数，存放在形参n所指的存储单元中。

请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。

注意：不得增行或删行，也不得更改程序的结构！#include <stdio.h>#include <stdlib.h>#define N 8typedef struct list{int data;struct list *next;} SLIST;SLIST *creatlist(int *a);void outlist(SLIST *);void fun( SLIST *h, int *n){SLIST *p;/**********found**********/___1___=0;p=h->next;while(p){(*n)++;/**********found**********/p=p->___2___;}}int main(){SLIST *head;int a[N]={12,87,45,32,91,16,20,48}, num;head=creatlist(a);outlist(head);/**********found**********/fun(___3___, &num);printf("\nnumber=%d\n",num);return 0;}SLIST *creatlist(int a[]){SLIST *h,*p,*q;int i;h=p=(SLIST *)malloc(sizeof(SLIST));for(i=0; i<N; i++){q=(SLIST *)malloc(sizeof(SLIST));q->data=a[i]; p->next=q; p=q;}p->next=0;return h;}void outlist(SLIST *h){SLIST *p;p=h->next;if (p==NULL) printf("The list is NULL!\n");else{printf("\nHead ");do{printf("->%d",p->data);p=p->next;} while(p!=NULL);printf("->End\n");}}3．给定程序中，函数fun的功能是：计算出带头结点的单向链表中各结点数据域之和作为函数值返回。

链表练习题及答案

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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

}
printf("插入后：");
showPointLink(*h);
}
POINT *revangePointLink(POINT *h)
{
POINT *p, *q;
printf("逆序前：");
showPointLink(h);
if(h)
{
p = h;
h = h->next;
p->next = NULL;
choose = 0;
else
choose -= '0';
if(choose == 0)
{
printf("\n输入错误！");
printf("\n请重新选择(1-7)");
getch();
}
}
return choose;
}
void showMenu(void)
{
system("cls");
printf("\n\n屏幕上的点点的管理信息系统\n");
printf("请输入一个点的两个坐标");
printf("任意坐标值为0，则表示输入结束\n");
scanf("%d%d", &x, &y); //先从键盘输入一对坐标
while(x && y) //只要有一个为0loc(sizeof(POINT));
void showPointLink(POINT *head);
void showOnePoint(POINT);
void destroyLink(POINT *head);
POINT *searchPrePoint(POINT *head, int x, int y);
int removePoint(POINT **head);
//是POINT，而当前函数相关内容是h，而其类型是POINT *，需要将POINT *
//转换成POINT类型，因此需要对h进行指向运算，以取得其所指向的实例。
printf("\n");
}
POINT *InputPoints(void)
{
int x, y;
POINT *head = NULL, *p, *q;
while(h)
{
q = h;
h = h->next;
q->next = p;
p = q;
}
}
printf("逆序后：");
showPointLink(p);
return p;
}
void sortPointByX(POINT *h)
{
POINT *p, *q, t, *r;
printf("\n排序前的结果是：");
getch();
break;
case REMOVE:
if(removePoint(&Head) == FALSE)
printf("删除的点不存在！");
printf("删除完毕！\nPress any key to continue...");
printf("\n 1)录入信息");
printf("\n 2)显示信息");
printf("\n 3)删除信息");
printf("\n 4)插入信息");
printf("\n 5)排序");
printf("\n 6)逆序");
printf("\n 7)退出");
printf("\n请选择：");
showPointLink(h);
printf("\n");
for(p = h; p; p = p->next)
for(q = p->next; q; q = q->next)
if(p->x > q->x)
{
t = *p;
*p = *q;
*q = t;
r = p->next;
p->next = q->next;
}
void insertPoint(POINT **h)
{
int Newx, Newy, Oldx, Oldy;
POINT *p, *q;
printf("插入前：");
showPointLink(*h);
// 1、确定新点坐标；
printf("请输入新点坐标：");
scanf("%d%d", &Newx, &Newy);
执行1号。*/
scanf("%d%d", &x, &y); //从键盘输入一对坐标
}
return head;//从前面的描述中可知，若head指向第一个节点，则
//返回该节点的首地址，就等于返回链表首地址；若一开始输入的
//数据中包含0，则head的初始值为NULL，此时返回值为NULL。
}
void main(void)
3、上述条件都不满足：成功的返回了要找节点的前驱节点。
*/
}
void destroyLink(POINT *h)
{
POINT *p;
while(h)
{
p = h; //让p指向h所指向的节点；
h = h->next; //让h向后移动；
free(p); //释放p所指向的节点；
}
}
void showOnePoint(POINT node)
printf("祝您身体健康！\n按任意键继续...\n");
getch();
printf("谢谢使用！\n按任意键继续...\n");
getch();
printf("不送了！\n按任意键继续...\n");
getch();
printf("请您走好！\n按任意键继续...\n");
getch();
printf("不要忘了我哦！！！\n按任意键继续...\n");
p = (POINT *)malloc(sizeof(POINT));
p->x = Newx;
p->y = Newy;
p->next = NULL;
// 2、确定插入点坐标；
printf("再输入插入点坐标：");
scanf("%d%d", &Oldx, &Oldy);
//3、查找插入点的前驱节点；
2、查找该点的前驱节点；
3、删除该点。*/
int x, y, Ok = TRUE;
POINT *p, *q;
//1、输入要删除的点的坐标；
printf("\n\n\n这是删除功能\n原有点坐标如下：\n");
showPointLink(*h);
printf("\n请输入要删除的点的坐标：");
scanf("%d%d", &x, &y);
{
POINT *Head = NULL;
int choice = 0;
while(choice != 7)
{
choice = selectedAction();
system("cls");
switch(choice)
{
case INPUT:
if(Head) //表示该链表非空，应该先清空！
destroyLink(Head);
Head = InputPoints();
printf("录入完成！\nPress any key to continue...");
getch();
break;
case SHOW:
showPointLink(Head);
printf("显示完毕！\nPress any key to continue...");
/*由于下面的话，说明q现在正好指向最后一个节点，只要将刚刚申请的，p
所指向的节点链接到最后一个节点的后面，即可完成任务。*/
q = p;//2号
/*q每次都在本轮循环结束之前指向刚刚申请且刚刚链到链表的末尾的那个
新节点（简单地说，q总指向链表的最后一个节点。
上述的1号语句和2号语句的书写顺序与执行顺序不同，总是先执行2号，再
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<conio.h>
#define TRUE 1
#define FALSE 0
#define INPUT 1
#define SHOW 2
#define REMOVE 3
#define INSERT 4
{
printf("<%d, %d> ", node.x, node.y);
}
//showPointLink(Head);
void showPointLink(POINT *h)
{
printf("\n链表的内容如下：\n");
for(; h; h = h->next)
showOnePoint(*h);//此处，函数showOnePoint()需要的参数类型

c语言链表大例题

数据结构经典题目及c语言代码

C程序设计(链表)习题与答案

c语言 链表笔试题

链表的经典习题

C、C++程序设计：链表单元测试与答案

链表c语言经典例题

C语言程序设计专项训练题之 单链表

链表练习题及答案

c语言链表笔试题

C语言程序设计专项训练题之单链表