Il y a un pointeur de tête ListNode* pHead d'une liste chaînée, étant donné une certaine valeur x, écrivez un morceau de code pour organiser tous les nœuds inférieurs à x avant le reste des nœuds, et l'ordre des données d'origine ne peut pas être modifié, et retournez le pointeur d'en-tête de liste chaînée réorganisé.
S'il n'est pas nécessaire de garder l'ordre relatif inchangé, alors les nœuds plus petits que x sont dirigés et les nœuds plus grands que x sont suivis. Mais il est nécessaire de garder l'ordre relatif inchangé, cette méthode n'est pas applicable.
Créez deux nouvelles listes liées, une pour les nœuds inférieurs à x et une pour les nœuds supérieurs à x, puis liez les deux listes liées.
Créer deux nœuds principaux avec des bits sentinelles
Il convient de noter ici que dans la liste chaînée d'origine, le nœud suivant du nœud 7 est 3, donc le nœud suivant du nœud 7 doit être défini sur NULL, sinon le nœud suivant du nœud 7 est le nœud 3, ce qui provoquera une infinité boucle.
struct ListNode {
int val;
struct ListNode* next;
};
struct ListNode* partition(struct ListNode* pHead, int x)
{
struct ListNode* lessHead = NULL;
struct ListNode* lessTail = NULL;
struct ListNode* greatHead = NULL;
struct ListNode* greatTail = NULL;
//带哨兵位头结点,方便尾插
lessHead = lessTail = (struct ListNode*)malloc(sizeof(struct ListNode));
greatHead = greatTail = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* cur = pHead;
while (cur != NULL)
{
if (cur->val >= x)
{
//尾插到great中
greatTail->next = cur;
greatTail = cur;
}
else
{
//尾插到less中
lessTail->next = cur;
lessTail = cur;
}
cur = cur->next;
}
//两个链表链接起来
lessTail->next = greatHead->next;
greatTail->next = NULL;
//记住新链表的表头
struct ListNode* head = lessHead->next;
//释放空间
free(lessHead);
free(greatHead);
return head;
}
Erreur OJ : la mémoire dépasse la limite et le programme peut avoir des problèmes tels qu'une boucle infinie. Notez ici que si vous ne définissez pas greatTail->next = NULL, il signalera que la mémoire dépasse la limite.