いくつかの演習のリスト

構造体RandomListNode 
{ 
    int型のラベル、
     構造体 RandomListNode *次に、* ランダム; 
    RandomListNode（INT X）：ラベル（X）、次に（NULL）、ランダム（NULL）{} 
}; 
クラスソリューション
{ 
パブリック：
    RandomListNode *クローン（RandomListNode * PHEAD ）
    { 
        IF（！PHEAD）
             戻りPHEADと、

        RandomListNode * P = PHEAD、TEMP * = NULL、*新しい= NULL;
         //は、現在のノードとその背後にあるノード間の現在のノードをコピー
        しながら（P）
        { 
            TEMP =（ *P）.next; 
            新 = 新 RandomListNode（（* P）.LABEL）。
            （ *新規）.next =（* P）.next; 
            （ * P）.next = 新しいです。
            P = 一時; 
        } 

        P = PHEAD、新=（* P）.next。
        一方、（P）
        { 
            もし、（（* P）.random） 
                （ *新）.random =（*（* P）.random）.next。
            P =（* 新規）.next;
            もし（P）
                新 =（* P）.next; 
        }

        P = PHEAD、新=（* P）.next; 
        RandomListNode * NHead = 新しいです。
        一方、（（* 新）.next）
        { 
            TEMP =（* 新）.next。
            （ * P）.next =（* 新規）.next; 
            （ *新規）.next =（* TEMP）.next; 
            P = 一時; 
            新 =（* P）.next; 
        } 
        （ * P）.next = NULL;
        返すNHeadを。
    } 
}。

書式#include <iostreamの> 
の#include < 文字列 > 
の#include <スタック> // ポップ、トップ、プッシュ 
する#include <ベクトル>を使用して名前空間はstdを、
構造体ListNode {
     int型のval;
    構造体 ListNode * 次の; 
    ListNode（int型X）：ヴァル（x）は、次の（NULL）{} 
}。クラスKInverse {
 パブリック：
    ListNode *逆（ListNode *ヘッド、int型のk）
    { 場合（！ヘッド|| K < 2 ）
             リターンヘッド。
        ListNode
 

        
* P =頭部、* Q =頭部、* LastTail = NULL;
        int型 I = 1、=カウント0を。
        一方、（Q）
        { 
            場合（I == K）
            { 
                場合（！カウント）
                    ヘッド = Q。
                他の
                    （ * LastTail）.next = Q; 

                ListNode * TEMP1 =（* Q）.next、* TEMP2 = NULL;
                一方、（！Q = P）
                { 
                    TEMP2 =（* P）.next。
                    もし（（* Q）.next ==TEMP1）
                        LastTail = P。
                    （ * P）.next =（* Q）.next。
                    （ * Q）.next = P。
                    P = TEMP2。
                } 
                P = Q = TEMP1。
                I = 1 ; 
                カウント ++ ; 
            } 
            もし（Q）
                Q =（* Q）.next。
            I ++ ; 
        } 
        戻りヘッド。
    } 
}。
クラスCreatListNode 
{ 
パブリック：
    ListNode *クリート（ベクトル< INT > A）
    { 
        場合（A.empty（））
             戻りNULL。
        ListNode *ヘッド= 新しい ListNode（[ 0 ]）* P = ヘッド。
        以下のための（ベクトル< int型 > ::イテレータITER = A.begin（）+ 1 ; ITER = A.end（）;！ITER ++ ）
        { 
            （ * P）.next = 新しい ListNode（* ITER）。
            P =（* P）.next。
        } 
        リターンヘッド。
    }
    ボイドプリント（ListNode * ヘッド）
    { 
        ListNode * P = ヘッド。
        一方、（P）
        { 
            COUT <<（* P）.val << "  " 。
            P =（* P）.next。
        } 
    } 
}。
INT メイン（）
{ 
    INT [ 8 ] = { 1、2、3、4、5、6、7、8 }。
    ベクトル < int型> ARR（A + 8 ）。
    CreatListNode C; 
    ListNode * HeadA = C.Creat（ARR）。
    KInverse D。
    ListNode *ヘッド= D.inverse（HeadA、3 ）。
    C.Print（ヘッド）
    リターン 0 ; 
}