« Prouvez offre de sécurité » le problème vingt-deuxième: l'avant-dernière liste k noeuds

// questions face 22: liste chaînée de noeuds avant - dernier k
 // Titre: entrée une liste chaînée, la k-ième réciproque sortie de liste chaînée noeuds. Afin de répondre aux habitudes de la plupart des gens,
 // cette question comptée à partir de 1, qui est le noeud final de la liste est l'avant - dernier nœud. Par exemple, une liste chaînée a six nœuds,
 // nœuds de gratter commencer leurs valeurs sont séquentiellement 1,2,3,4,5,6. 3 nœud avant - dernier de cette liste est
 // valeur du nœud 4. 

#include <cstdio> 
#include " list.h " 

ListNode * FindKthToTail (ListNode * pListHead, non signé int K) 
{ 
    // Robustesse test 1. 0 2.k liste vide (sens) 
    IF (== nullptr une pListHead K == || 0 )
         retour nullptr a; 

    ListNode * pListAhead = pListHead; 
    ListNode * = pListAfterpListHead;
     // étape précédente pointeur k-1 aller 
    pour ( int I = 0 ; <K - I . 1 ; ++ I) 
    { 
        IF (pListAhead->! m_pNext = nullptr a) 
            pListAhead = pListAhead-> m_pNext,
         l'autre 
            retour nullptr a; 
    } 
    // le pointeur arrière pour garder 
    le tout (pListAhead-> m_pNext =! nullptr a) 
    { 
        pListAhead = pListAhead-> m_pNext; 
        pListAfter = pListAfter-> m_pNext; 
    } 
    retour pListAfter; 
}

// ==================== ==================== code de test
 // test're recherche la liste des noeuds intermédiaires 
vide Test1 () 
{ 
    le printf ( " ================ Soho commence Test1: ================ \ n- " ); 
    ListNode * pNode1 CreateListNode = ( . 1 ); 
    ListNode * pNode2 = CreateListNode ( 2 ); 
    ListNode CreateListNode pNode3 = * ( 3. ); 
    ListNode * pNode4 CreateListNode = ( 4. ); 
    ListNode * pNode5 CreateListNode = ( 5. ); 

    ConnectListNodes (pNode1, pNode2);  
    ConnectListNodes (pNode2, pNode3);
    ConnectListNodes (pNode3, pNode4);
    ConnectListNodes (pNode4, pNode5), 

    printf ( " Résultat attendu: 4. \ n " ); 
    ListNode * • pNode = FindKthToTail (pNode1, 2 ); 
    PrintListNode (• pNode); 

    DestroyList (pNode1); 
} 

// test de noeud recherche la fin de la liste de noeuds est 
vide Test2 () 
{ 
    printf ( " ================ Soho commence Test2: ================ \ n- " ); 
    ListNode (* pNode1 CreateListNode = . 1 ); 
    ListNode * pNode2 = CreateListNode ( 2 ); 
    ListNode * pNode3 CreateListNode = ( 
    ListNode. 3 ); * pNode4 = CreateListNode ( 4. ); 
    ListNode * pNode5 = CreateListNode ( 5. ,) 

    ConnectListNodes (pNode1, pNode2); 
    ConnectListNodes (pNode2, pNode3); 
    ConnectListNodes (pNode3, pNode4); 
    ConnectListNodes (pNode4, pNode5), 

    le printf ( " Résultat attendu: 5. le \ n " ); 
    ListNode * • pNode = FindKthToTail (pNode1, 1. ); 
    PrintListNode (• pNode); 

    DestroyList (pNode1); 
} 

// test de recherche du nœud est le premier noeud dans la liste 
annuler la Test3 ( ) 
{ 
    printf ( "===== Test3 commence: ===== \ n " );); 
    ListNode * pNode1 = CreateListNode ( 1 ); 
    ListNode * pNode2 = CreateListNode ( 2 ); 
    ListNode * pNode3 = CreateListNode ( 3 ); 
    ListNode * pNode4 = CreateListNode ( 4 ); 
    ListNode * pNode5 = CreateListNode ( 5 ); 

    ConnectListNodes (pNode1, pNode2); 
    ConnectListNodes (pNode2, pNode3); 
    ConnectListNodes (pNode3, pNode4); 
    ConnectListNodes (pNode4, pNode5); 

    printf ( " résultat attendu: 1. \ n " 
    ListNode * pNode = FindKthToTail (pNode1,. 5 ); 
    PrintListNode (• pNode); 

    DestroyList (pNode1); 
} 

// Test liste vide 
vide Test4 () 
{ 
    printf ( " ================ Test4 Soho commence: ================ \ n " ); 
    printf ( " Résultat attendu .: nullptr une \ n- " ); 
    ListNode * • pNode = FindKthToTail (nullptr a, 100 ); 
    PrintListNode (• pNode); 
} 

// nombre total de noeuds du deuxième paramètre est supérieur à la liste d'entrée de test 
vide Test5 doit être effectuée () 
{ 
    printf ( " == test5 devrait être menée Soho commence ===: ================ \ n " ); 
    ListNode* PNode1 = CreateListNode ( );1 ); 
    ListNode * pNode2 = CreateListNode ( 2 ); 
    ListNode * pNode3 = CreateListNode ( 3 ); 
    ListNode * pNode4 = CreateListNode ( 4 ); 
    ListNode * pNode5 = CreateListNode ( 5 ); 

    ConnectListNodes (pNode1, pNode2); 
    ConnectListNodes (pNode2, pNode3); 
    ConnectListNodes (pNode3, pNode4); 
    ConnectListNodes (pNode4, pNode5); 

    printf ( " résultat escompté: nullptr \ n. " ); 
    ListNode * pNode = FindKthToTail (pNode1, 6 
    PrintListNode (pNode);

    DestroyList (pNode1); 
} 

// 测试输入的第二个参数为0 
vide Test6 () 
{ 
    printf ( " ===== Test6 commence: ===== \ n " ); 
    ListNode * pNode1 = CreateListNode ( 1 ); 
    ListNode * pNode2 = CreateListNode ( 2 ); 
    ListNode * pNode3 = CreateListNode ( 3 ); 
    ListNode * pNode4 = CreateListNode ( 4 ); 
    ListNode * pNode5 = CreateListNode ( 5 ); 

    ConnectListNodes (pNode1, pNode2);
    ConnectListNodes (pNode2, pNode3); 
    ConnectListNodes (pNode3, pNode4);
    ConnectListNodes (pNode4, pNode5); 

    printf ( " résultat escompté: nullptr \ n. " ); 
    ListNode * pNode = FindKthToTail (pNode1, 0 ); 
    PrintListNode (pNode); 

    DestroyList (pNode1); 
} 

Int main ( int argc, ombles * argv []) 
{ 
    Test1 (); 
    Test2 (); 
    Test3 (); 
    Test4 (); 
    Test5 (); 
    Test6 (); 

    retourner  0 ; 
}

Code d'essai

Analyse: deux pointeurs passera par la réduction du nombre une fois.

/ * 
ListNode struct { 
    int val; 
    struct ListNode * suivant; 
    ListNode (int x): 
            val (x), à côté (NULL) { 
    } 
}; * / 
Class Solution {
 publique : 
    ListNode * FindKthToTail (ListNode * pListHead, non signé int k) { 
    
        si (pListHead == nullptr || k == 0 )
             retour nullptr; 
        
        ListNode * pListAhead = pListHead; 
        ListNode * pListAfter = pListHead; 
        
        pour ( int i = 0 ; i <k- 1; ++ i) 
        { 
            si (pListAhead-> next =! Nullptr) 
                pListAhead = pListAhead-> suivant;
            autre 
                retour nullptr; 
        } 
        
        Tandis que (pListAhead-> next =! Nullptr) 
        { 
            pListAhead = pListAhead-> suivante; 
            pListAfter = pListAfter-> suivante; 
        } 
        Retour pListAfter; 
    } 
};

Cattle net hors soumettre du code