数据结构8581线性链表逆置

ｃ语言链表逆序的问题

ｃ语⾔链表逆序的问题去⾯试被问到⼀个问题，怎么把⼀个链表反转(⽤原链表)，⾃⼰在⽹上找了到了⼀篇⽂章，/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 语言链表逆序，以方便大家参考。将一个链表逆序并输出。我用了两种方法来实现，第一种是借助了一个新的空链表；第二种是在原来链表的基础上直接实现逆序。简洁的做法是遍历链表，元素进栈，遍历的同时销毁原来的链表。元素出栈，建立新链表。高效的是，用指向链表结点指针的指针操作直接首尾交换指针值（两两进行）一般的是前插法实际上根本就不用插入，一次遍历就可以完成了。链表的逆序，必将涉及到两个以上指针，一般用三个指针，下面是一个人的程序： 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语言编程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。

编写算法：实现带头结点单链表的逆置算法

编写算法：实现带头结点单链表的逆置算法标题：探讨带头结点单链表的逆置算法实现及其应用在计算机科学和算法领域，链表是一种非常重要的数据结构，它能够以一种灵活的方式存储和组织数据。

在链表的操作中，逆置算法是一种常见且有用的操作，它能够将链表的顺序颠倒，为问题的解决提供便利。

本文将从简到繁，由浅入深地探讨带头结点单链表的逆置算法的实现及其应用。

1. 带头结点单链表的定义和特点带头结点单链表是一种特殊的链表结构，它在链表的头部增加了一个额外的结点，这个结点并不存储实际的数据，而是作为头结点来方便链表的操作。

带头结点单链表的特点是可以方便地插入和删除操作，同时也更容易处理空链表的情况。

2. 逆置算法的基本思路在带头结点单链表中，逆置算法的基本思路是从链表的第一个结点开始，依次改变每个结点的指针指向，将整个链表的方向颠倒过来。

在实现逆置算法时，需要注意处理好结点指针的指向关系，以免出现指针丢失或者内存泄露的情况。

3. 逆置算法的具体实现（1）需要判断链表是否为空或只有一个结点，如果是的话，则无需进行逆置操作。

（2）使用三个指针分别表示当前结点、前驱结点和后继结点，通过改变指针的指向来逆置链表。

（3）循环迭代链表，直到当前结点为空，完成链表的逆置操作。

4. 逆置算法的应用带头结点单链表的逆置算法在实际应用中有着广泛的使用场景，例如在字符串操作、图论算法、树算法等方面都能够发挥重要作用。

通过逆置算法，可以方便地实现字符串逆置、图的拓扑排序、二叉树镜像等复杂的数据操作。

带头结点单链表的逆置算法是一种非常重要的链表操作，它能够为问题的解决提供便利。

通过对逆置算法的深入理解和应用，可以为算法的设计和问题的解决提供更多的灵感和思路。

希望本文的内容能够帮助读者更深入地理解带头结点单链表的逆置算法，并在实际应用中发挥重要作用。

个人观点：带头结点单链表的逆置算法是一种非常有趣且实用的算法操作，它能够为链表操作和数据处理提供更多的灵活性和便利性。

数据结构课后习题答案详解(C语言版_严蔚敏) 2

数据结构习题集答案(C语言版严蔚敏)第2章线性表2.1 描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。

解：头指针是指向链表中第一个结点的指针。

首元结点是指链表中存储第一个数据元素的结点。

头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。

它可以对空表、非空表以及首元结点的操作进行统一处理。

2.2 填空题。

解：(1) 在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。

(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。

单链表中逻辑上相邻的元素的物理位置不一定紧邻。

(3) 在单链表中，除了首元结点外，任一结点的存储位置由其前驱结点的链域的值指示。

(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。

2.3 在什么情况下用顺序表比链表好？解：当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。

2.4 对以下单链表分别执行下列各程序段，并画出结果示意图。

解：2.5 画出执行下列各行语句后各指针及链表的示意图。

L=(LinkList)malloc(sizeof(LNode)); P=L;for(i=1;i<=4;i++){P->next=(LinkList)malloc(sizeof(LNode));P=P->next; P->data=i*2-1;}P->next=NULL;for(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2);for(i=1;i<=3;i++) Del_LinkList(L,i);解：2.6 已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。

a. 在P结点后插入S结点的语句序列是__________________。

线性表逆置(顺序表)实验报告

vi()的形参加'&'，表明可通过调用vi()改变元素的值*/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(p++);
printf("\n");
return OK;
}
/*逆置链表的程序*/
void change(SqList *L) /*逆置算法*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/
{
scanf("%d",&e);
i=ListInsert(&L,j,e);
}
}prLeabharlann ntf("逆置前的表：L= "); /*输出表L的内容*/
ListTraverse(L,print);
change(&L);
printf("逆置后的表：L= "); /*输出新表L的内容*/
ListTraverse(L,print);
{
ElemType e;
int L_len;
int i;
L_len=ListLength(*L); /*求线性表的长度*/
for(i=0;i<=L_len/2;i++)

数据结构单链表、双链表的逆置算法

数据结构与算法的课程设计课程设计题目：数据结构的逆置算法院系名称：信息技术学院专业（班级）：计算机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.详细设计：定义的所有数据类型，对每个操作写出伪码算法；对主程序和其他模块也都写出伪码算法。

链表逆置算法

链表逆置算法链表是一种常用的数据结构，它由一系列的节点组成，每个节点包含一个数据元素和一个指针，用于指向下一个节点。

在实际应用中，经常需要将链表进行逆置操作，即将链表中的元素反序排列。

本文将介绍链表逆置算法的实现原理和具体步骤。

链表逆置算法的实现原理是通过改变节点之间的指针指向关系，将原来的链表转换为一个逆序的链表。

具体步骤如下：1. 定义三个指针：prev、cur和next。

其中prev用于指向当前节点的前一个节点，cur用于指向当前节点，next用于保存当前节点的下一个节点。

2. 将cur指针指向链表的头节点。

3. 在循环中，依次对cur指针指向的节点进行操作，直到cur指向链表的最后一个节点。

循环条件可设为cur不为空。

4. 在循环中，将next指针指向cur的下一个节点。

5. 将cur的指针指向prev，实现节点指针的反向。

6. 将prev指针指向cur，cur指针指向next。

7. 遍历完所有节点后，将链表的头节点指向prev，即可得到逆序的链表。

下面通过一个具体例子来说明链表逆置算法的实现过程：假设有一个链表，包含5个节点，数据分别为1、2、3、4、5。

初始状态下，链表的指针指向关系如下：1 ->2 ->3 ->4 -> 5按照上述步骤进行逆置操作：1. 初始化prev、cur和next指针。

2. cur指向链表的头节点，即1。

3. 在循环中，将next指向cur的下一个节点，即2。

4. 将cur的指针指向prev，实现节点指针的反向，此时第一个节点指向null。

5. 将prev指向cur，cur指向next。

6. 继续循环，next指向cur的下一个节点，即3。

7. 将cur的指针指向prev，实现节点指针的反向，此时第二个节点指向第一个节点。

8. 将prev指向cur，cur指向next。

9. 继续循环，重复上述步骤，直到遍历完所有节点。

最终得到的逆序链表的指针指向关系如下：5 -> 4 -> 3 -> 2 -> 1通过链表逆置算法，我们可以将链表中的元素反序排列，实现了链表的逆置操作。

数据结构链表的头插法逆置

数据结构链表的头插法逆置链表的逆置之头插法：头插法的核⼼思想就是先把当前的链表切分为两个部分，第⼀个部分为只有⼀个头节点的单链表，第⼆个部分是除头节点外的剩余所有的链表，挨个把第⼆部分的节点插⼊到第⼀个部分中，插⼊的⽅法是运⽤建⽴单链表的头插法，其刚好可以起到逆置的作⽤。

此⽅法的空间复杂度为O(1)代码如下：void reverse(LinkList *L){LinkList *p=L->next,*q;//p指向的是L的⾸节点L->next=NULL;//重新设定L是⼀个带头节点的空表while(p!=NULL){q=p->next;//设定q为p的后继节点q->next=L->next;//头插法将q插⼊到L的后⾯L->next=q;//头插法p=q;//q后移，继续头插法直到p为空}}完整的测试代码：#include<stdio.h>#include<stdlib.h>typedef struct node{int data;struct node *next;}Node;void creat_linkList(Node *L){//尾插法Node *rear=L;for(int i=0;i<10;i++){Node *node=(Node *)malloc(sizeof(Node));node->data=i;node->next=NULL;rear->next=node;rear=node;}}void reverse(Node *L){Node *p=L->next;L->next=NULL;Node *q=NULL;while(p!=NULL){q=p->next;//定义⼀个在p后⾯的节点为qp->next=L->next;//L的next指的是p原先的位置，现在需要p回头指向⾃⼰原先指定的位置L->next=p;//再让L的next记录当前p的位置，⽅便p往后移后，新的p可以回头指⾃⼰先前的位置达到逆转的作⽤p=q;//p再转到下⼀个位置}}int main(){Node L;L.data=1000;L.next=NULL;creat_linkList(&L);reverse(&L);Node *p=L.next;while(p!=NULL){printf("%d\n",p->data);p=p->next;}}。

C语言数据结构实现链表逆序并输出

C语言数据结构实现链表逆序并输出c语言数据结构实现链表逆序并输出实例代码：头文件：#include<stdio. h>ftinclude<stdlib. h> #include<malloc・ h> typedefintElemType; typedefstructNode{//结点结构ElemTypevalue; //值域structNode*next; //指针域}Node, *ptr_Node;typedefstructLinkList{//链表结构ptr_Nodehead;//链表头结点指针ptr_Nodetail;//链表尾结点指针intlength;//链表长度}LinkList, *ptr_LinkList; ptr_LinkLi stCreateList(void) {//创建一个空琏表ptr_LinkListlinklist;linklist=(LinkList*)malloc(sizeof(LinkList));if (!linklist){printf("allocationfailed. \n");linklist-〉head二NULL;linklist->tail=XULL;linklist->length=O;returnlinklist;}boolIsListEmpty(ptr_LinkListlinklist){//判断链表是否为空if(linklist->length==0){returntrue;}returnfalse;}voidlnsertListHead(ptr_LinkListlinklist, ElemTypeelement) {//在表头插入值为element的结点作为新的表头ptr_Nodeptr_node;ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if (!p t:r_node) printf(^allocationfailed. \n");}elseptr_node~>value=element;if (linklist->length==0){linklist-〉head二ptr_node;linklist->tail=linklist~>head;1inklisl->next=NULL;}else{ptr_node~>next=linklist~>head;1 inklist->head=p tr_node; / / 链表头}linklist->length++;//^ 表长度加 1}} voidlnsertListTail(ptr_LinkListlinklist, ElemTypeelement) ptr_Nodeptr_node;ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if(!ptr_node){printf("allocationfailed. \n");}else{ptr_node->value=element;if (linklis t - >length=0){linklist一>head二ptr_node;linklist->tail=linklist一>head;1 inklist->tail->next=NULL;}else{1 inklist->tail~>next=ptr_node;linklist->ta 订二ptr_node; // 链表尾}linklist->length++;// 链表长度加 1}}voidlnsertListPosition(pt:r_LinkListlinklist, intpos, ElemT ypeelement){inti;ptr_Nodeptr_node;ptr_Nodetemp_ptr_node;if(pos<l :pos>linklist->length){printf ("Theinsertpositionisinvalidate・ \n〃)；}else{ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if(!ptr_node){printf(^allocationfailed. \n");}ptr_node->value=element;if (pos==l)InsertListHead(linklist, element);}elseif(pos==linklist->length)InsertListTail(linklist,element);}else{temp_ptr_node=linklist->head;for (i=l;i<pos-l;i++){//找到第posT个结点temp_ptr_node二temp_pt:r_node->next;}ptr_node->next二temp_ptr_node->next; temp_ptr_node->next二ptr_node; linklist->length++；}}}voidDestroy(ptr_LinkListlinklist) {//销毁链表ptr_Nodep=linklist->head; ptr_Nodeq;while(p){//释放每个结点空间q=p->next;free (p)；p二NULL;P 二q;}}voidTraverse(ptr_LinkListlinklist){//输出整个链表ptr_Nodep;p二linklist-〉head;while(p){printf("%4d", p->value);p=p->next;}}头文件中实现了链表的几个基本的操作，有的是必须的，有些是非必须的。

(数据结构C语言版)顺序表和单链表的逆置,DOC

实验1-1顺序表的逆置操作程序原码#include<stdlib.h>//创建顺序表，确定元素个数，插入各个元素，逆置列表。

voidcreat();//建表部分voiddisplay();//显示部分//*************主函数******************intmain(){init();creat();printf("\n您输入的顺序表的结点数:\n"); display();inversion();}//*************以下为建表部分****************** voidcreat(){inta,b,i;printf("请输入顺序表的结点数:");scanf("%d",&a);if(a<=0){printf("顺序表个数要为正整数!请重新输入:");scanf("%d",&a);}}//****************以下为倒置部分********************** voidinversion(){inta,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;实验1-2单链表的逆置操作程序原码//创建一个单链表，确定元素个数，插入各个元素，进行逆置操作，并输出。

#include<stdio.h>#include<malloc.h>#include<stdlib.h>//单链表的链式存储结构typedefstructNode{Reaverse_Link(Head); //逆置链表printf("逆置后的的单链表为:\n");Treaver_Link(Head); //输出链表}//************以下为单链表的创建部分**************PLNodeCreat_Link(){inti,t,y;PLNodeHead=(PLNode)malloc(sizeof(LNode));PLNodetail;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;p->next=Head->next;Head->next=p;p=q;}return;}//************以下为单链表的显示部分************** voidTreaver_Link(PLNodeHead){PLNodep;实验1-2测试结果输入一个正数、输入一个负数、。

数据结构学习-带头结点的单链表就地逆置

数据结构学习-带头结点的单链表就地逆置所谓“就地是指辅助空间复杂度为O(1)。

解法⼀：将头结点摘下，然后从第⼀结点开始，依次前插⼊到头结点的后⾯（头插法），直到最后⼀个结点为⽌。

代码如下解法⼆：通过若⼲操作将指针反转达到逆置的⽬的。

假设pre、p和r指向3个相邻的结点，如上图。

*pre之前的结点的指针都已经调整完毕，它们的next指针都指向其原前驱结点。

现在令*p结点的next域指向*pre结点，注意到⼀旦调整指针的指向后，*p的后继结点的链就断开了，为此⽤r来指向原*p结点的后继结点。

处理第⼀个结点时，将其next域置为NULL,。

处理最后⼀个结点后，将头结点的指针指向它。

代码：LinkList Reverse (LinkList L){ LNode *p,*r;//p 为⼯作指针，r 为p 的后继以防断链 p=L->next;//从第⼀个元素结点开始 L->next=NULL;//先将头结点L 的next 域置为NULL while (p!=NULL)//依次将元素结点摘下 { r =p->next;//暂存p 的后继 p->next=L->next;//将p 结点插⼊到头结点之后 L->next=p; p =r; } return L;}Linklist reserve(LinkList L){ LNode *pre,*p=L->next,*r=p->next; p ->next=NULL;//处理第⼀个结点 while (r!=NULL)//r 为空，则说明p 为最后⼀个结点 { pre =p;//依次遍历 p=r; r =r->next; p ->next=pre;//指针反转 } L->next=p;//处理最后⼀个结点 return L;}。

数据结构C语言版顺序表和单链表的逆置精编WORD版

数据结构C语言版顺序表和单链表的逆置精编W O R D版IBM system office room 【A0816H-A0912AAAHH-GX8Q8-GNTHHJ8】实验1-1 顺序表的逆置操作程序原码#include<stdlib.h> // 创建顺序表，确定元素个数，插入各个元素，逆置列表。

#include<stdio.h>#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;}//*************以下为建表部分******************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 测试结果输入一个正数、输入一个负数、实验1-2 单链表的逆置操作程序原码//创建一个单链表，确定元素个数，插入各个元素，进行逆置操作，并输出。

数据结构链表倒置

{
InsElement(pstLinkList);
}
else if (szCommond[0] == 'd')
{
DelElement(pstLinkList);
}
else if (szCommond[0] == 'n')
{
InvElement(pstLinkList);
}
else if (szCommond[0] == 'e')
return OK;
}
STATUSInversionList_L(PLINKNODE_SpstHeadNode)
{
PLINKNODE_S p =pstHeadNode->pNext, q =pstHeadNode->pNext;
/*while(p)
{
q = p->pNext;
p->pNext=pstHeadNode->pNext;
STATUSDeleteList_L(PLINKNODE_SpstHeadNode,intnPosition,int*nElem)
{
PLINKNODE_S p, q;
intnTemp= 0;
p =pstHeadNode;
while (p->pNext&&nTemp<nPosition- 1) //寻找第i个节点，并令p指向其前趋节点
}
printf("NULL\n");
return OK;
}
STATUSDestoryList_L(PLINKNODE_SpstHeadNode)
{
PLINKNODE_SpScanNode,pTempNode;

线性表逆置(顺序表)实验报告

实验一：线性表逆置(顺序表)实验报告(一)问题的描述：实现顺序表的逆置算法(二)数据结构的设计：顺序表是线性表的顺序存储形式，因此设计如下数据类型表示线性表：typedef struct{ElemType *elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType) 为单位) */}SqList;(三)函数功能、参数说明及概要设计：1.函数Status InitList(SqList *L) 功能说明：实现顺序表L 的初始化算法设计：为顺序表分配一块大小为LIST_INIT_SIZE 的储存空间2.函数int ListLength(SqList L) 功能说明：返回顺序表L 长度算法设计：返回顺序表中的length 变量3.函数Status ListInsert(SqList *L,int i,ElemType e)功能说明：将元素e插入到顺序表L中的第i个节点算法设计：判断顺序表是否已满，已满则加空间，未满则继续，将元素e插入到第i个元素之前，并将后面的元素依次往后移4.函数Status ListTraverse(SqList L,void(*vi)(ElemType*))功能说明：依次对L 的每个数据元素调用函数vi()算法设计：依次对L 的每个数据元素调用函数vi()5.函数void Exchange(SqList *L)功能说明：实现顺序表L 的逆置算法设计：用for 循环将顺序表L 中的第i 个元素依次与第( i+length )个元素交换6.函数void print(ElemType *c)功能说明：打印元素 c算法设计：打印元素 c2.(四)具体程序的实现/* 程序名 */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc() 等 */#include<limits.h> /* INT_MAX 等 */#include<stdio.h> /* EOF(=A Z 或 F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在 math.h 中已定义 OVERFLOW 的值为3,故去掉此行 */typedef int Status; /* Status 是函数的类型 ,其值是函数结果状态代码，如 OK 等 */ typedef int Boolean; /* Boolean 是布尔类型 ,其值是 TRUE 或 FALSE */typedef int ElemType;/* 线性表的动态分配顺序存储结构 */#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2typedef struct{ElemType *elem;int length;int listsize; // }SqList; /* 顺序表示的线性表的基本操作 */Status InitList(SqList *L) /* 算法 2.3 */{ /* 操作结果：构造一个空的顺序线性表 */(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败 */(*L).length=0; /* 空表长度为 0 */ (*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */ return OK;}// 线性表存储空间的初始分配量// 线性表存储空间的分配增量 // 存储空间基址 // 当前长度当前分配的存储容量 (以 sizeof(ElemType) 为单位 )Status DestroyList(SqList *L){ /* 初始条件：顺序线性表L 已存在。

线性表——逆转链表结点链接方向（原地逆转）

线性表——逆转链表结点链接⽅向（原地逆转）//"LinkList.h"#include<iostream>using namespace std;#define ElemType inttypedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;string InitList(LinkList &L){L = new LNode;L->next = NULL;return"OK";}string ListInsert(LinkList &L,int i,ElemType e){LinkList P = L;int j=0;while (P && (j<i-1)){P = P->next;++j;}LinkList S = new LNode;S->data = e;S->next=P->next;P->next=S;return"OK";}LNode* GetElement(LinkList L,int i){LinkList p = L->next;int j = 1;while(p && j<i){p=p->next;j++;}// if(!p||j>i){// return -1;// }return p;}string DeleteList(LinkList &L,int i){LinkList p = L;int j = 0;while ((p->next)&&(j<i-1)){p=p->next;j++;}if(!(p->next)||(j>i-1))return"ERROR";LinkList q = p->next;p->next=q->next;delete q;return"OK";}string ShowList(LinkList L){LinkList p= L;while(p->next){p=p->next;cout<<p->data;}return"OK";}string FillList(LinkList &L){int p =1;char a = '1';while (a != '!'){ElemType b ;cin >> b;ElemType e = (ElemType)b - 48;a = b;if(a != '!')cout << ListInsert(L,p,b)<<endl; p++;}return"OK";}string FillListWithNum(LinkList &L,int i){ int e;for(int j =1;j<=i;j++){cin >> e;ListInsert(L,j,e);}return"OK";}// ShowList(L);// DeleteList(L,2);// ShowList(L);// return 0;// }#include<iostream>#include"LinkList.h"using namespace std;/*逆转链表结点链接⽅向*/int main(){LinkList LA;LinkList LB;InitList(LA);InitList(LB);FillListWithNum(LA,4);LNode *pa = LA->next;LNode *pb;int n=1;while(pa->next){++n;pa=pa->next;}LB->next=pa;pb = pa;for(n;n>=1;n--){pb->next=GetElement(LA,n);pb=pb->next;}pb->next=NULL;//delete LA;//cout<<endl;ShowList(LB);system("pause");return0;}。

链表的逆置——精选推荐

链表的逆置链表是⼀个特殊的数据结构，其中每个节点包含⾃⼰的数据以及下⼀个值的引⽤（指针），链表的逆置就是指将链表下⼀个值的引⽤（指针）调换，如下图所⽰：链表的节点的结构如下：data为⾃定义的数据，next为下⼀个节点的地址⼀构造链表class Node(object):def __init__(self, value, next):self.value = valueself.next = nexthead = Node('头', None)last = headl = ['涉哥', '刚哥', '雷哥', '强哥']for i in l:node = Node('%s' % i, None)last.next = nodelast = node# ######### 查看链表关系 ##########print('原始链表信息为%s'%head.value)print(head.next.value)print(head.next.next.value)print(head.next.next.next.value)print(head.next.next.next.next.value)第⼆步链表逆置　def reverse_linked_list(head):"""链表逆置:param head::return:"""if not head or not head.next:return headprev_node = Nonecurrent_node = headnext_node = head.nextwhile True:current_node.next = prev_node # 变箭头if not next_node:breakprev_node = current_nodecurrent_node = next_nodenext_node = current_node.nextreturn current_nodenew_head = reverse_linked_list(head)print('逆置之后的链表')print(new_head.value)print(new_head.next.value)print(new_head.next.next.value)print(new_head.next.next.next.value) print(new_head.next.next.next.next.value) 。

链表的逆置

#include <stdio.h> #include <stdlib.h>
typedef struct node { int data; struct node *next; }Node;
//创建链表 Node *CreatList(void) { int val, i, n; Node *phead, *p, *q;
//链表的逆置 Node *ReverseList(Node *phead) { Node *p, *q, *r;
p = phead; q=r=NULL;
while50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. } } } } }
return 0;
85.
使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的)，而不在源文件目录去查找；使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45.
printf("\n");
int main(void) { Node *phead;
phead = CreatList(); printf("链表逆置前的数据:\n"); ShowList(phead);