La pregunta sobre la estructura de datos de la lista enlazada individualmente. Espero que alguien con experiencia pueda ayudar a responderla.

Para mejorar la eficiencia, finalmente se adoptó el siguiente algoritmo.

La idea es la siguiente:

1. Primero ajuste la lista enlazada individualmente a una secuencia donde la primera mitad sean números impares y la segunda mitad sean números pares

2. Escanee la lista enlazada, encuentre el límite y divídala en dos listas subenlazadas;

3. Ordene las listas subenlazadas pares e impares;

El. primer paso del algoritmo: escanear desde el principio, p se refiere al nodo actual y q apunta al sucesor

1. Si p->los datos son un número impar, continúe retrocediendo; p>

2. Si p->data es un número par, (1) Cuando q->data es un número par, el puntero q se mueve hacia atrás y P permanece sin cambios hasta que se encuentra un número impar. esta vez, el nodo Q encuentra el nodo impar; en este momento, los campos de datos de los nodos P y Q se pueden intercambiar, y tanto p como Q retroceden un paso

(2) Cuando q; -> los datos son un número impar, el puntero q se mueve hacia atrás y P permanece sin cambios hasta que se encuentra un número par. En este momento, el nodo Q es el nodo predecesor que encuentra el número par, y P se puede intercambiar; el campo Datos del nodo Q (el nodo predecesor par), p apunta a Q y Q retrocede;

El siguiente es el código del programa: (usando una lista enlazada de nodos sin cabeza)

void?AdjustList (LinkList?&L){? //Función de ajuste para ajustar la lista enlazada individualmente en una lista enlazada individualmente con números impares en la primera mitad y números pares en la segunda mitad.

Lista de enlaces?p,q; int?temp; p=L->siguiente; q=p->siguiente; mientras(q){

if(p->datos%2==1)

{ p=q; q=q->siguiente;

}

else{ temp=q->datos%2; cambiar(temp) { caso? 0:

mientras(q&&q->datos%2==0) q=q->siguiente;

si(q){ Intercambiar(p->datos,q-> datos);

p=p->siguiente;

q=q->siguiente;

}

caso roto? 1:

mientras(q&&(q->datos%2==1)&&(q->siguiente) &&((q->siguiente)->datos)%2!=0)

q=q->siguiente;

if(q){

Intercambiar(p->datos,q->datos);

p=q;

q=q->siguiente;

}

interrumpir; predeterminado:?;

}?

} } printf("\n?Fuera?Ajustar?Lista completa:"); Print_L(L); SpiltList(LinkList?&L,LinkList?&L1,LinkList?&L2){ // Encuentra el límite entre la secuencia impar y la secuencia par y divídelo directamente LinkList?p,q; mientras (q&&q->datos%2!=0){ p=q; q=q->siguiente } L2=p->siguiente; p->siguiente=NULL;?