(数据结构C语言版)顺序表和单链表的逆置
}
实验 1-1 顺序表的逆置操作
程序原码
// 创建顺序表，确定元素个数，插入各个元素，逆置列表。
#include<malloc.h> #define max_list_size 100 //定义给顺序表分配空间大小 typedef struct{
int *elem;
int length;
}list_node; //指向顺序表首地址的结构体单元
list_node L; // 这里使用了全局变量，在所有的函数里可以随意修改其值 int list[max_list_size]; void init();
void inversion();
void creat();
void display(); //*************
主函数 ****************** int main()
{
init();
creat();
printf("\n 您输入的顺序表的结点数 : \n"); display();
inversion();
printf("\n 倒置顺序表的结点数 : \n"); display();
void init() {
L.elem = (int *) malloc (max_list_size * sizeof(int) ); if (! L.elem) {
printf(" 顺序表已满 ");
exit(-1);
}
L.length = 0;
#include<stdlib.h>
#include<stdio.h> // 初始化操作 // 倒置部分 // 建表部分 // 显示部分 //* ************ 初始化操作分配空间 ******************
}
//*************
void creat(){
int a, b, i; printf(" 请输入顺序表的结点数 : "); scanf("%d", &a);
if(a<=0){
printf(" 顺序表个数要为正整数 ! 请重新输入 : "); scanf("%d",&a); }
if( a > max_list_size - 1 || a < 0 )
{
printf(" 分配失败 ,退出程序 ! \n");
exit(1);
}
for( i = 0; i != a; ++i)
{
printf(" 请输入第 %d 结点的值 : ", i+1); scanf("%d", &b);
L.elem[i] = b; ++L.length;
}
}以下为建表部分 ******************
//* ***************
以下为倒置部分 **********************
void
inversion(){
int a, b, i;
a = L.length; for( i = 1; i <= a/2; i++)
{
b = L.elem[i-1];
L.elem[i-1] = L.elem[a-i];
L.elem[a-i] = b;
}
} //****************
以下为显示部分 ********************** void display(){
int i; for( i = 1; i <= L.length; ++i)
printf("%d\t", L.elem[i-1]);
printf("\n");
实验1-1 测试结果
输入一个正数、
您输入的顺序表的結点数：
20
21 22 23 24 25 26 石宣®序耒的结点熬 26 25 24 23 22 21 20 Press any kev to continue 输入一个负数、
实验1-2
单链表的逆置操作
程序原码
//创建一个单链表，确定元素个数，插入各个元素，进行逆置操作，并输出。
#in elude <stdio.h>
#in elude <malloc.h>
#in elude <stdlib.h>
II 单链表的链式存储结构
typedef struct Node
{
int date;
7 :0 1 2 3 4 5 6 颉 2 2 2 2 2 2 2 弓■■二 值值值值值 的 翱点占苦^一^点
r
上口±口吉吉士口士口士口 一 h J 幺十言” .r 叮舍叮兰一^土幺亠 顺髦鬱鄴鬱 入入入入入入入人 ■■J —_HI;.,,.-r^n J Tr J IT J Tr 亠 Tr 丄.-rr 丄才-4-.才-l-.rr 主月主-R 主月圭启主冃主冃主冃主口 駐新输入: 一ttj^mffit 的的的点点点点 1 士 R 士 R 士
口
您输入的顺序表的结点数：
6
7 8 I 置顺序表的结点熱
7 t 5
'ress anu key ta cent inue
入吏
入入入
实验1-1 测试结果输入一个正数、
struct Node *n ext;
}LNode,*PLNode;
PLNode Creat_Link(); // 创建链表
void Treaver_Link(PLNode Head); //输出链表
void Reaverse_Link(PLNode Head); // 逆置链表
void main() {
PLNode Head;
Head=Creat_Link(); //创建链表
printf(" 您输入的单链表为: \n");
Treaver_Link(Head); //输出链表
Reaverse_Link(Head); //逆置链表printf(" 逆置后的的单链表为: \n");
Treaver_Link(Head); //输出链表
}
//* *********** 以下为单链表的创建部分**************
PLNode Creat_Link()
{
int i,t,y;
PLNode Head=(PLNode )malloc(sizeof(LNode));
PLNode tail;
PLNode New;
if(!Head){
exit(-1);
}
tail=Head;
Head->next=NULL;
printf(" 请输入链表的个数: "); scanf("%d",&t);
if(t<=0){
printf(" 链表个数要为正整数! 请重新输入: "); scanf("%d",&t);
}
for(i=0;i<t;i++){
printf(" 请输入第%d 个结点数据: ",i+1); scanf("%d",&y);
New=(PLNode )malloc(sizeof(LNode)); if(!New){ exit(-1);
}
New->date=y;
New->next=tail->next; tail->next=New; tail=New;
}
return Head; }
//************ 以下为单链表的逆置部分**************
void Reaverse_Link(PLNode Head) {
PLNode p,q; p=Head->next; Head->next=NULL;
while(p){
q=p->next; p->next=Head->next; Head->next=p;
p } return;
}
//************ 以下为单链表的显示部分**************
void Treaver_Link(PLNode Head) {
PLNode p;
if(!Head->next){
printf(" 链表为空退出程序!"); exit(-1);
}
p=Head->next;
while(p){
printf("%d\t",p->date); p=p->next;
}
printf("\n");
return;
实验1-2 测试结果 输入一个正数、 输入一个负数、。
ｃ语言链表逆序的问题
ｃ语⾔链表逆序的问题去⾯试被问到⼀个问题，怎么把⼀个链表反转(⽤原链表)，⾃⼰在⽹上找了到了⼀篇⽂章，/sicofield/article/details/8850269，原作者给出了三种⽅法，⽅法⼀：将链表数据全部读到数组中，然后在倒序输出。
⽅法⼆：就是我下⾯要讲的。
⽅法三：从第⼆个结点开始，把之后的每个结点都插⼊到第⼀个结点之后，最后在把第⼀个结点挪到表尾。
第⼆种⽅法的思路是：从第⼆个结点开始，记录它的下个结点，把它挪到第⼀个结点之前，成为新表头，然后下个结点继续这个过程。
1struct stu *reserve(struct stu *head)2 {3struct stu *p1,*p2,*p3; 4 p1=head;5 p2=p1->next; // 这个结点为要移动的结点6while(p2)7 {8 p3=p2->next; //记录的为要移动的结点的下⼀个结点9 p2->next=p1; //移动结点到最前10 p1=p2; //移动的结点变为新表头11 p2=p3; //下个结点变为要移动的结点12 }13 head->next=NULL; //移动完毕后head变为表尾，让它指向为空14 head=p1; 15return head;16 }⽅法三的贴下原作者的代码加上⾃⼰的思路：1struct stu *reserve(struct stu *head)2 {3struct stu *p,*q;4 p=head->next; //记录第⼆个结点5while(p->next!=NULL)6 {7 q=p->next; //记录要移动的结点8 p->next=q->next; //把该结点从原链表中移除9 q->next=head->next; //把该结点连接到head之后10 head->next=q;11 }12 p->next=head; //把head移动到新表尾，此时链表成环13 head=p->next->next; //找到移动完之后的新head14 p->next->next=NULL; //断开环15return head;1617 }。
c语言单链表头插法实现链表逆置
c语言单链表头插法实现链表逆置链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在C语言中，我们可以使用单链表来实现各种操作，如插入、删除和查找等。
本文将介绍如何使用头插法实现链表的逆置。
首先，我们需要定义一个链表节点的结构体，包含数据和指向下一个节点的指针。
代码如下：```ctypedef struct Node {int data;struct Node* next;} Node;```接下来，我们需要实现链表的创建和逆置函数。
首先，创建一个空链表，并将头节点指针指向NULL。
代码如下：```cNode* createList() {Node* head = NULL;return head;}```然后，我们可以实现链表的插入函数，使用头插法将新节点插入到链表的头部。
代码如下：```cNode* insertNode(Node* head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = head;head = newNode;return head;}```接下来，我们可以实现链表的逆置函数，通过遍历链表，将每个节点插入到头部，从而实现链表的逆置。
代码如下：```cNode* reverseList(Node* head) {Node* newHead = NULL;Node* temp = NULL;while (head != NULL) {temp = head->next;head->next = newHead;newHead = head;head = temp;}return newHead;}```最后，我们可以编写主函数，测试链表的逆置功能。
代码如下：```cint main() {Node* head = createList();head = insertNode(head, 1);head = insertNode(head, 2);head = insertNode(head, 3);head = insertNode(head, 4);head = insertNode(head, 5);printf("原链表：");Node* temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");head = reverseList(head);printf("逆置后的链表：");temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");return 0;}```运行以上代码，输出结果如下：```原链表：5 4 3 2 1逆置后的链表：1 2 3 4 5```通过以上代码，我们成功地使用C语言的单链表头插法实现了链表的逆置。
C语言单链表逆置的代码实现（简单易懂版）
C语⾔单链表逆置的代码实现（简单易懂版） 嗯，，这是⾃⼰写的第⼀篇博客哈，写的不好⼤家不要见怪，主要是想把⾃⼰的⼀些思想分享给⼤家。
也欢迎⼤家指出错误，⼀同进步。
话不多说，直接先说想法。
要把⼀个单链表逆置，可以⼤致分为下列⼏步。
先创建⼀个链表。
然后要考虑到链表的逆置实现。
最后是链表的输出。
有了这样过⼏步⼤概的想法之后，我们便要来⼀步步的实现啦。
嗯，，创建链表就不说了，⼤家都会。
然后呢就是链表的逆置，这⾥我是采⽤的就地逆置法，，嗯，反正我是这么叫的，⼤家可以参考⼀下。
当然啦，你得考虑到函数的形参和返回值以及指针的交接，这⾥如果出了问题，编译器是不会报错的，所以⼤家务必多加注意。
其余的⼩问题还是看代码吧。
额，，之前画的草图不见了，，现在也没有办法给⼤家画个草图演⽰⼀下，很抱歉啊。
如果⼤家看不懂链表逆置可以画个草图⾃⼰看看，应该就差不多了1 #include <stdio.h>2 #include <stdlib.h>34struct student5 {6int data;7struct student *next;8 };910int iCount; //定义全局变量保存代码长度1112struct student *Create()13 {14struct student *pHead = NULL;15struct student *pNew,*pEnd;16 iCount = 0;17 pEnd = pNew = (struct student*)malloc(sizeof(struct student));18 printf("请输⼊数据:");19 scanf("%d",&pNew->data);20while(pNew->data!=0)21 {22 iCount++;23if(iCount == 1) //从本条if语句开始就要多注意指针的交接了哦，⽐较容易错24 {25 pNew->next = NULL;26 pEnd = pNew;27 pHead = pNew;28 }29else30 {31 pNew->next = NULL;32 pEnd->next = pNew;33 pEnd = pNew;34 }35 pNew = (struct student*)malloc(sizeof(struct student));36 printf("请输⼊数据:");37 scanf("%d",&pNew->data);38 }39free(pNew);40return pHead;41 }4243struct student *reverse(struct student *pHead) //链表逆置函数44 {45struct student *p,*q,*t; //p为前置指针，q为后置指针，t为交换指针46 q = pHead;47 p = (q->next);48 q->next = NULL;49while(t!=NULL)50 {51 t = p->next;52 p->next = q;53 q = p;54if(t!=NULL) p = t;55else;56 }57return (p);58 }5960void showlist(struct student *pHead) //指针输出函数61 {62struct student *temp;63 temp = pHead;6465while(temp)66 {67 printf(" %d ",temp->data);68 temp = temp->next;69 }70 printf("\n");71 }7273int main()74 {75struct student *first;7677 first = Create();78 printf("链表逆置前的数据:");79 showlist(first);8081 first = reverse(first);8283 printf("链表逆置后的数据:");84 showlist(first);8586return0;87 }。
数据结构(c语言版)课后习题答案完整版
数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念，用来组织和存储数据，使之可以高效地访问和操作。
在C语言中，我们可以使用不同的数据结构来解决各种问题。
本文将提供完整版本的C语言数据结构的课后习题答案。
二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表，其中的元素在物理内存中连续地存储。
在C 语言中，我们可以通过定义结构体和使用指针来实现顺序表。
以下是顺序表的一些基本操作的答案：（1）初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```（2）插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```（3）删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```（4）查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素，返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答（1）逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```（2）顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。
顺序表和单链表的就地逆置（源代码）
数据结构之顺序表和链表的就地逆置源代码//顺序表和链表的就地逆置#include<stdio.h>#include<mlloc.h>#deine mxsize 100struct dt //为链表的处理做结构体定义{int m;dt *next;}; //子函数，每种数据结构两个函数，前者是顺序表，后者是链表void disply1(int [],int num);void inverse1(int [],int num);void disply2(dt *b,int num);void inverse2(dt *b,int num);void min(){int i,num1,num2;int [mxsize];dt *b,*p,*q;//顺序表的就地逆置print("请输入需要创建的顺序表的长度:\n");scn("%d",&num1);print("请输入顺序表的关键字:\n");or(i=0;i<num1;i++){lush(stdin); //清除输入缓存scn("%d",&[i]);}print("创建的顺序表为:\n");disply1(,num1);inverse1(,num1); //地址传递print("\n就地逆置后的顺序表:\n");disply1(,num1);//链表的就地逆置print(" \n请输入需要创建的链表的长度:\n");scn("%d",&num2);print("请输入链表的关键字:\n");b=(dt*)mlloc(sizeo(dt)); //申请内存空间b->next=NULL; //链表含有头结点q=b;or(i=0;i<num2;i++){p=(dt*)mlloc(sizeo(dt));lush(stdin);scn("%d",&p->m);p->next=q->next;q->next=p;q=q->next;}print("创建的链表为:\n");disply2(b,num2);inverse2(b,num2); //地址传递print("\n就地逆置后的链表:\n");disply2(b,num2);}void disply1(int [],int num){int i;or(i=0;i<num;i++){print("-%d-",[i]);}}void inverse1(int [],int num){int *p,*q,t;p=&[0]; //指向第一个数q=&[num-1]; //指向最后一个数while(p<q) //算法是：前后指针所指的数值交换，然后向中间靠拢，直到p<q停止{t=*p;*p=*q;*q=t;p++;q--;}}void disply2(dt *b,int num){dt *t;t=b->next;while(t!=NULL){print("-%d-",t->m);t=t->next;}}void inverse2(dt *b,int num){dt *p,*q;int i,j,t;or(i=1;i<=num-1;i++) //算法类似于冒泡排序{p=b->next;q=p->next;or(j=num-i;j>0;j--){t=p->m;p->m=q->m;q->m=t;p=p->next;q=q->next;}}}。
c语言编程acm链表的逆置
标题：C语言编程ACM：链表的逆置一、概述ACM（Advanced Computing Machinery）竞赛是计算机科学领域最负盛名的竞赛之一，要在ACM竞赛中获得优异的成绩，熟练掌握C 语言编程技术是必不可少的。
本文将讨论C语言编程中常见的ACM题目之一：链表的逆置。
二、链表的基本概念1.链表的定义链表是一种线性表的物理存储单位，由一个个节点组成，每个节点包含数据元素和下一个节点的指针。
链表中的数据元素可以是任意类型。
2.链表的基本操作在C语言中，链表的基本操作包括插入节点、删除节点、查找节点等。
而链表的逆置就是将链表中的节点顺序颠倒。
三、链表的逆置方法在C语言中，链表的逆置可以采用多种方法实现。
1.迭代法迭代法是最直接的方法，具体步骤如下：（1）初始化三个指针，分别指向当前节点、前一节点、后一节点。
（2）遍历链表，将当前节点的指针指向前一节点。
（3）更新前一节点和当前节点的位置。
（4）遍历结束后，前一节点指向NULL，表示逆置完成。
2.递归法递归法是一种更为巧妙的方法，具体步骤如下：（1）递归遍历链表，直至到达链表尾部。
（2）从链表尾部开始，逐一修改每个节点的指针指向。
（3）递归结束后，链表即被逆置。
四、链表逆置的C语言实现以下是链表逆置的C语言实现代码，以迭代法为例：```ctypedef struct Node {int data;struct Node* next;} Node;Node* reverseList(Node* head) {Node *prev = NULL, *curr = head, *next = NULL; while (curr) {next = curr->next;curr->next = prev;prev = curr;curr = next;}return prev;}```五、实例分析假设有一个链表的头指针为head，包含数据元素1、2、3、4、5。
C语言链表逆序方法技巧
C语言链表逆序方法技巧C语言链表逆序方法技巧C语言有丰富的数据结构和运算符。
包含了各种数据结构，如整型、数组类型、指针类型和联合类型等，用来实现各种数据结构的运算。
下面是店铺为大家搜索整理的`C语言链表逆序方法技巧，希望大家能有所收获，简洁的做法是遍历链表，元素进栈，遍历的同时销毁原来的链表。
元素出栈，建立新链表。
高效的是，用指向链表结点指针的指针操作直接首尾交换指针值(两两进行)一般的是前插法实际上根本就不用插入，一次遍历就可以完成了。
链表的逆序，必将涉及到两个以上指针，一般用三个指针，下面是一个人的程序：struct List1 *reverse(List1 *h) //h为链表的头指针{struct List1 *p,*v1,*v2;v2=h;v1=NULL;while( v2!=NULL ){p=v2->pNext;v2->pNext=v1;v1=v2;v2=p;}return v1;}另一个人的：struct IntNode* res(struct IntNode* h){struct IntNode *s, *s1;s = h;h = NULL;while (s){s1 = s;s = s->next;s1->next = h;h = s1;}return h;}算法都是一致，但顺序不一样，这直接点明了链表操作的核心——顺序，链表的算法主要难在顺序上。
逆序操作中，要将一个指针指向前一个节点，中间必然断开，这就需要两个指针指向断开处的一前一后。
上面两个程序都是这样，不同在于指针移动的位置。
下载全文。
c语言链表递归逆序输出
c语言链表递归逆序输出链表是数据结构中常用的一种，在C语言中经常会用链表进行数据的存储和操作。
链表是由节点组成，每个节点都有一个指向下一个节点的指针。
在这篇文章中，我们将讨论如何使用递归来逆序输出一个链表。
步骤一：定义链表节点结构体在C语言中定义链表是一种非常常见的操作。
首先我们需要定义节点的结构体。
节点结构体通常包括一个数据域和一个指向下一个节点的指针域。
数据域用来存储节点的数据，指针域则用来表示指向下一个节点的指针。
结构体定义如下：```struct node {int data; // 数据域struct node *next; // 指针域};```步骤二：定义逆序输出函数接下来我们需要定义一个函数来逆序输出链表。
使用递归方法实现链表的逆序输出。
```void reversePrint(struct node *head){if(head == NULL) {return;}if(head->next != NULL){reversePrint(head->next);}printf("%d ", head->data);}```这个递归函数非常简单。
首先我们检查链表头指针是否为空。
如果为空，则返回（因为该链表中没有节点）。
然后我们检查是否有下一个节点。
如果有，则执行函数自身将下一个节点作为参数传递给它。
这样就可以将链表倒序遍历，最后输出节点的数据。
步骤三：测试函数我们可以使用以下代码来测试reversePrint函数：```int main() {struct node *head, *second, *third, *fourth;// 分配空间head = (struct node*)malloc(sizeof(struct node));second = (struct node*)malloc(sizeof(struct node));third = (struct node*)malloc(sizeof(struct node));fourth = (struct node*)malloc(sizeof(struct node));// 赋值head->data = 10;head->next = second;second->data = 20;second->next = third;third->data = 30;third->next = fourth;fourth->data = 40;fourth->next = NULL;// 逆序输出链表printf("链表逆序输出:\n");reversePrint(head);// 释放空间free(head);free(second);free(third);free(fourth);return 0;}```这里我们创建一个包含四个节点的链表，然后将该链表传递给我们刚刚定义的reversePrint函数。
C语言实现单链表逆序与逆序输出实例
C语⾔实现单链表逆序与逆序输出实例单链表的逆序输出分为两种情况，⼀种是只逆序输出，实际上不逆序；另⼀种是把链表逆序。
本⽂就分别实例讲述⼀下两种⽅法。
具体如下：1.逆序输出实例代码如下：#include<iostream>#include<stack>#include<assert.h>using namespace std;typedef struct node{int data;node * next;}node;//尾部添加node * add(int n, node * head){node * t = new node;t->data = n;t->next = NULL;if (head == NULL){head = t;}else if (head->next == NULL){head->next = t;}else{node * p = head->next;while (p->next != NULL){p = p->next;}p->next = t;}return head;}//顺序输出void print(node * head){node * p = head;while (p != NULL){cout << p->data << " ";p = p->next;}cout << endl;}//递归void reversePrint(node * p){if (p != NULL){reversePrint(p->next);cout << p->data << " ";}}//栈void reversePrint2(node * head){stack<int> s;while (head != NULL){s.push(head->data);head = head->next;}while (!s.empty()){cout << s.top() << " ";s.pop();}}int main(){node * head = NULL;for (int i = 1; i <= 5; i++){head = add(i, head);}print(head);reversePrint(head);reversePrint2(head);system("pause");return 0;}逆序输出可以⽤三种⽅法: 递归，栈，逆序后输出。
数据结构单链表、双链表的逆置算法
数据结构与算法的课程设计课程设计题目：数据结构的逆置算法院系名称：信息技术学院专业（班级）：计算机2班姓名：学号：指导教师：实验内容：分别用一维数组，单链表，双链表实现逆置（一）使用一维数组实现逆置1.需求分析：定义一个一维数组（整型），用for语句实现循环，给数组元素赋值，并将数组元素逆序输出。
2.详细设计：main(){ int a[3],i; /*定义元素个数为3的一维数组*/for(i=0;i<3;i++)scanf("%d",&a[i]);for(i=2;i>=0;i--)printf("%d ",a[i]);getch();}3.运行及调试：4.附录：#include<stdio.h>void main(){ int a[3],i; /*定义一维数组*/for(i=0;i<3;i++)scanf("%d",&a[i]);for(i=2;i>=0;i--)printf("%d ",a[i]);getch();}（二）单链表实现逆置1.需求分析：创建一个单链表并实现逆序输出2.详细设计：定义的所有数据类型，对每个操作写出伪码算法；对主程序和其他模块也都写出伪码算法。
（1）单链表的定义typedef struct node{ int data;/*数据域为整型*/struct node* next; /*定义结点的指针域*/}LinkList;/*数据结点*/（2）头插法建立单链表Tnode *CreatList(){ Tnode *head; /*头指针*/LinkList *p;/*工作指针/int ip;head=(Tnode *)malloc(sizeof(Tnode));head->next=NULL;/*链表开始为空*/printf("please input the number:\n");scanf("%d",&ip); /*向链表中添加元素*/while(ip!=000){ p=(LinkList *)malloc(sizeof(LinkList));/*生成新结点*/ p->data=ip; /*将值赋给新生结点*/p->next=head->next;head->next=p;scanf("%d",&ip);}if(ip==000) /*当输入的数值为000时结束*/printf("\nthe ip is end!\n\n");return head;}（3）读取链表中的数据void ReadList(Tnode *head){ LinkList *p;p=head->next;while(p){ printf("%d ",p->data);p=p->next;}printf("\n");}（4）链表的倒置void ExchangeList(Tnode *head){ LinkList *r,*s;r=head->next;head->next=NULL;while(r){ s=r->next;r->next=head->next;head->next=r;r=s;}3.运行及调试5.附录：/*带头结点的链表建立*/#include<stdio.h>#include<malloc.h>#include<conio.h>typedef struct node /*结点类型定义*/{ int data; /*结点的数据域*/struct node* next; /*结点的指针域*/}LinkList;/*数据结点*/typedef struct{ int length; /**链表的长度/struct node*next; /*结点的指针域*/}Tnode; /*头结点*/Tnode *CreatList()/*头插法建立单链表*/{ Tnode *head;LinkList *p;/*工作指针*/int ip;head=(Tnode *)malloc(sizeof(Tnode));head->next=NULL; /*链表开始为空*/printf("please ip the number:\n");scanf("%d",&ip);while(ip!=000){ p=(LinkList *)malloc(sizeof(LinkList)); /*生成新结点*/ p->data=ip; /*将元素值赋给新生结点p*/p->next=head->next;head->next=p; /*head指向p结点*/scanf("%d",&ip);if(ip==000)printf("\nthe ip is end!\n\n");return head;}void ReadList(Tnode *head) /*读取链表中的数据*/{ LinkList *p;p=head->next;while(p){printf("%d ",p->data);p=p->next;}printf("\n");}void ExchangeList(Tnode *head) /*链表的倒置*/{ LinkList *r,*s;r=head->next;head->next=NULL;while(r){ s=r->next;r->next=head->next;head->next=r;r=s;}}void Readme(){ printf("press 1 to set libiao\n");printf("press 0 to exit\n");printf("-------------------------------------------------------------------------------\n"); }void main(){ Tnode *head;int choice;while(choice){ Readme();scanf("%d",&choice);switch(choice){ case 1:head=CreatList(); /*创建单链表*/printf("the number are:\n\n");ReadList(head);printf("\n");ExchangeList(head); /**逆置后的单链表/printf("the exchange number are:\n\n"); /*打印逆置后的单链表*/ReadList(head); /*读取单链表中的数据*/getch();break;}}}（三）双链表实现逆置1.需求分析：创建一个双链表并实现逆序输出2.详细设计：定义的所有数据类型，对每个操作写出伪码算法；对主程序和其他模块也都写出伪码算法。