Lista invertida de pila

A través de la pregunta, sabemos que esta pregunta requiere el conocimiento de las listas vinculadas En primer lugar, los amigos que no están familiarizados con las listas vinculadas pueden revisar las listas vinculadas primero y aprender sobre las diversas operaciones básicas de las listas vinculadas individualmente. Para realizar la inversión de la lista enlazada, lo primero que pienso es la pila, porque la característica de la pila es primero en entrar, primero en salir.

typedef struct lnode{
    
    
	int data;		//定义单链表 
	lnode *next;
}lnode,*list;

La palabra clave typedef significa asignar un alias al tipo de datos. El siguiente puntero de lista es para que sea más conveniente de usar más adelante, y no es necesario definir el puntero cada vez.

void lt(list &l){
    
    	//通过引用对头节点导出 
	int x;
	l=(list)malloc(sizeof(lnode));
	lnode *s,*r=l;
	cin>>x;
	while(x!=-1){
    
    			//输入数据，输入-1时退出循环 
		s=(list)malloc(sizeof(lnode));
		s->data=x;
		r->next=s;				
		r=s;
		cin>>x;
	}
	r->next=NULL;	//将尾节点的next值赋空值 
}

Esto es para construir una lista enlazada individualmente a través de la entrada del usuario, usando -1 como condición de terminación, ¡y no olvide asignar un valor nulo al campo de puntero del nodo de cola al final! (No olvide incluir el archivo de encabezado cuando use malloc para asignar espacio) El #include<malloc.h>
método de construcción específico no es muy claro en el texto. Si no lo entiende, puede ir a Bilibili para ver la estructura de datos de Wangdao Postgraduate. Hay una explicación detallada. .

int main(){
    
    
	list l;
	lt(l);	//调用方法传入头结点 
	lnode *s;
	s=(list)malloc(sizeof(lnode));
	lnode *p;
	p=(list)malloc(sizeof(lnode));
	s->next=p;
	p->data=l->next->data;
	l=l->next;
	p->next=NULL;		//到这一步是将头结点与尾节点赋值链接 
	while(l->next!=NULL){
    
    
		lnode *r;
		r=(list)malloc(sizeof(lnode));
		r->next=p;
		r->data=l->next->data;		//利用了栈的先进后出的特点，限制数据只允许在头结点后面进行插入，构成新的链表 
		p=s->next=r;
		l=l->next;
	}
	while(s->next!=NULL){
    
    
		cout<<s->next->data<<" ";
		s=s->next;					//遍历新链表 
	}
	
}

Aquí se utilizan las características de la pila, lo que restringe la inserción de una lista vinculada individualmente después del nodo principal cada vez que se inserta, formando una nueva lista vinculada, atravesando la nueva lista vinculada y completando la operación de inversión de la lista vinculada.

Esta vez la plataforma me dejó pasar, jeje, ¡genial!