2.设计一个算法，将单链表中结点以逆序排列。逆序的单链表中的结点均为原表中的结点

Posted 2023-05-10

typedef struct ListNode
ListNode *next;
Element data;
ListNode, *pList;
这是我做的单链表逆序三个不同的算法，2个递归的以及一个非递归的

pList ReverseList( pList head )
if( !head || !(head->next) )
return head;
pList ph = ReverseList( head->next );
head->next->next = head;
head->next = NULL;
return ph;

pList ReverseList( pList head , pList &tail )
if( !head || !(head->next) )
tail = head;
return head;

pList pt;
pList ph = ReverseList( head->next , pt );
pt->next = head;
head->next = NULL;
tail = head;
return ph;

pList ReverseListNonRec( pList head )
if( !head || !(head->next) )
return head;
pList h = NULL,h1 = head;
while( head )
h1 = head->next;
head->next = h;
h = head;
head = h1;

return h;
参考技术A 遍历链表，分别按顺序将节点插入新的链表的表头与原先表头后一节点之间

void Inverse(LinkList head)//逆置

LinkList p = head->next;
LinkList tmp = NULL;
head->next = NULL;
while (NULL != p)

tmp = p->next;
p->next = head->next;
head->next = p;
p = tmp;

参考技术B Status DeSort(Listlink *L , Elemtype e)
LNode *pa, *pb, *pc;

for(pa=L->next;!pa&&!pa->next;pa=pa->next)

pc=pa; e=pa->data;
for(pb=pa;!pb&&!pb->next;pa=pa->next)

if(pb->next->data > pb->data)

pc=pb->next;
e=pb->data;


pc->data=pa->data;
pa->data=e;

数据结构——20 单链表逆序

单链表——逆序

单链表逆序以及将后半部分结点逆序

#include <iostream>
#define SIZE 100
using namespace std;
struct node

	int x;
	node* next;
;

node* create(int n)    //建立链表

	node *head=new(node);
	node *p=head;
	for(int i=0;i<n;i++)
	
		node *temp=new node;
		temp->x=i;
		p->next=temp;
		p=temp;
	
	p->next=NULL;
	
	return head;



void display(node *head)    //打印链表


	node *p=head->next;
	while(p)
	
		cout<<p->x<<" ";
		p=p->next;
	

	cout<<endl;



node* invert(node* head)     //链表逆序

	//node *tail=head->next;   //第一个节点变为最后一个节点后，它没有下一个结点，指向NULL
	node* p=head->next;        //p指向第一个结点
	node* temp=p->next;        //temp指向第二个结点
	node*s;

	while(temp)
	
		s=temp->next;
		temp->next=p;
		p=temp;
		temp=s;
	

	head->next->next=NULL;     //此时head还是指向第一个结点的，所以逆序后，让第一个结点指向为NULL
	head->next=p;              //重新让head指向逆序后的第一个结点
	return head;


void invertN(node* head,int n)     //链表前n个顺序不变，后面的结点逆序

	node* p=head->next;       
	for(int i=0;i<n-1;i++)       //p指向需要逆序的开始结点之前那个结点
		p=p->next;

	node* q=p;                 //保存第一个逆序结点之前的那个结点，逆序后，它的下一个结点为NULL

	node* temp=p->next;        //开始逆序
	node*s;
	while(temp)
	
		s=temp->next;
		temp->next=p;
		p=temp;
		temp=s;
	

	q->next->next=NULL;        //逆序部分的最后一个结点指向为NULL，即刚才保存的那个q结点之后的结点

	q->next=p;                 //逆序后，将链表链接起来


int main()

	int n=10;
	node *head=create(10);
	display(head);

	node *head1=invert(head);      //逆序链表
	display(head1);

 
	invertN(head,4);               //逆序后面部分结点
	display(head);

	return 0;