連結串列C++ | 從尾部列印頭部（使用棧、遞迴實現）_3

阿新 • • 發佈：2019-01-10

從尾部列印頭部

棧 - 實現：

void printListReversingly_Iteratively(ListNode** pHead)
{
    std::stack<ListNode*> nodes;

    ListNode* pNode = *pHead;
    while(pNode!=nullptr){
            nodes.push(pNode);
            pNode = pNode->m_pNext;}
            
    while(!nodes.empty()){
            pNode = nodes.top();
            printf("%d ",pNode->m_nValue);
            nodes.pop();}
}

測試程式碼：

#include<iostream>
#include<stack>

struct ListNode{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* AddToTail(ListNode** pHead, int Value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = Value;
    pNew->m_pNext = nullptr;

    if(*pHead == NULL){
        *pHead = pNew;}
    else{
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != nullptr)
            pNode = pNode->m_pNext;
        pNode->m_pNext = pNew;}
    return *pHead;
}

void Delete(ListNode** pHead, int value)
{
    if(pHead == nullptr || *pHead == nullptr)
        return;

    ListNode* pToBeDelete = *pHead;
    if(value == 1)
        *pHead = pToBeDelete->m_pNext;
    else{
        ListNode* pNode = *pHead;
        for(int i=0;i<value-2;i++)
            pNode = pNode->m_pNext;

        pToBeDelete = pNode->m_pNext;
        pNode->m_pNext = pToBeDelete->m_pNext;
        }

    if(pToBeDelete!=nullptr){
        delete pToBeDelete;
        pToBeDelete = nullptr;
    }
}

void print(ListNode* pHead){
    printf("LinkedList is:\n");
    while(pHead!=nullptr)
    {
        printf("%d ", pHead->m_nValue);
        pHead = pHead->m_pNext;
    }
    printf("\n");
}

void printListReversingly_Iteratively(ListNode** pHead)
{
    std::stack<ListNode*> nodes;

    ListNode* pNode = *pHead;
    while(pNode!=nullptr){
            nodes.push(pNode);
            pNode = pNode->m_pNext;}
            
    while(!nodes.empty()){
            pNode = nodes.top();
            printf("%d ",pNode->m_nValue);
            nodes.pop();}
}

int main(){
    ListNode* pHead = nullptr;
    pHead = AddToTail(&pHead, 1);
    pHead = AddToTail(&pHead, 2);
    pHead = AddToTail(&pHead, 3);
    pHead = AddToTail(&pHead, 4);
    Delete(&pHead, 1);
    print(pHead);
    printListReversingly_Iteratively(&pHead);
}

執行結果：

遞迴 - 實現：

void printListReversingly_Recurrsively(ListNode* pHead)
{
    if(pHead!=nullptr){
        if(pHead->m_pNext!=nullptr){
            PrintListReversingly_Recurrsively(pHead->m_pNext);
        }
        printf("%d\t", pHead->m_nValue);
    }
}

測試程式碼：

#include<iostream>
#include<stack>

struct ListNode{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* AddToTail(ListNode** pHead, int Value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = Value;
    pNew->m_pNext = nullptr;

    if(*pHead == NULL){
        *pHead = pNew;}
    else{
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != nullptr)
            pNode = pNode->m_pNext;
        pNode->m_pNext = pNew;}
    return *pHead;
}

void Delete(ListNode** pHead, int value)
{
    if(pHead == nullptr || *pHead == nullptr)
        return;

    ListNode* pToBeDelete = *pHead;
    if(value == 1)
        *pHead = pToBeDelete->m_pNext;
    else{
        ListNode* pNode = *pHead;
        for(int i=0;i<value-2;i++)
            pNode = pNode->m_pNext;

        pToBeDelete = pNode->m_pNext;
        pNode->m_pNext = pToBeDelete->m_pNext;
        }

    if(pToBeDelete!=nullptr){
        delete pToBeDelete;
        pToBeDelete = nullptr;
    }
}

void print(ListNode* pHead){
    printf("LinkedList is:\n");
    while(pHead!=nullptr)
    {
        printf("%d ", pHead->m_nValue);
        pHead = pHead->m_pNext;
    }
    printf("\n");
}

//void printListReversingly_Iteratively(ListNode** pHead)
//{
//    std::stack<ListNode*> nodes;
//
//    ListNode* pNode = *pHead;
//    while(pNode!=nullptr){
//            nodes.push(pNode);
//            pNode = pNode->m_pNext;}
//
//    printf("Revers LinkedList is:\n");
//    while(!nodes.empty()){
//            pNode = nodes.top();
//            printf("%d ",pNode->m_nValue);
//            nodes.pop();}
//}

void printListReversingly_Recurrsiverly(ListNode* pHead)
{
    if(pHead!=nullptr){
        if(pHead->m_pNext!=nullptr){
            printListReversingly_Recurrsiverly(pHead->m_pNext);
        }
        printf("%d ",pHead->m_nValue);
    }
}

int main(){
    ListNode* pHead = nullptr;
    pHead = AddToTail(&pHead, 1);
    pHead = AddToTail(&pHead, 2);
    pHead = AddToTail(&pHead, 3);
    pHead = AddToTail(&pHead, 4);
    Delete(&pHead, 1);
    print(pHead);
//    printListReversingly_Iteratively(&pHead);
    printListReversingly_Recurrsiverly(pHead);
}

執行結果：

對程式碼不滿足，是任何真正有天才的程式設計師的根本特徵。

連結串列C++ | 從尾部列印頭部（使用棧、遞迴實現）_3

從尾部列印頭部棧 - 實現： void printListReversingly_Iteratively(ListNode** pHead) { std::stack<ListNode*> nodes; ListNode* pNode = *pHead;

leetcode筆記_連結串列的遍歷與刪除（虛擬頭結點的使用）

203. 移除連結串列元素刪除連結串列中等於給定值 val 的所有節點。示例: 輸入: 1->2->6->3->4->5->6, val = 6 輸出: 1->2->3->4->

LeetCode-109.有序連結串列轉換二叉搜尋樹（相關話題：深度優先）

給定一個單鏈表，其中的元素按升序排序，將其轉換為高度平衡的二叉搜尋樹。本題中，一個高度平衡二叉樹是指一個二叉樹每個節點的左右兩個子樹的高度差的絕對值不超過 1。示例: 給定的有序連結串列： [-10, -3, 0, 5, 9], 一個可能的答案是：[0, -3,

編寫一個函式 reverse_string(char * string)（遞迴實現）實現：將引數字串中的字元反向排列。要求：不能使用C函式庫中的字串操作函式。

給定字串，程式碼如下： #include <stdio.h> #include <stdlib.h> #include <assert.h> char* reverse_string(char *str) { assert(str !

編寫一個函式 reverse_string(char * string)（遞迴實現），將引數字串中的字元反向排列。要求不能使用C函式庫中的字串操作函式

#include<stdio.h> #include<stdlib.h> int str(char *string) { int n = 0; while (*string) { n++; string++; } return n; } void rever

C 標準庫—— stdlib.h（包括 rand srand 的實現）

0. atoi(const char *) vs itoa(int, char*, int radix) 首先明確一點，atoi 是標頭檔案 stdlib.h 中的函式，itoa 雖應用廣泛，卻並非標準的 C 語言函式。考慮到跨平臺的需要，常用 spr

判斷兩個二叉樹是否相同（c++遞迴實現）

判斷兩棵二叉樹是否為同一棵樹，需要比較兩個方面：一：結構是否相同；二：每個節點上的元素是否相同；當二者都滿足的時候才可判定二者為同一棵二叉樹。結構相同包括節點的個數以及每個節點上的子樹相同。下面是程式碼實現。 #include<i

河內之塔（C語言遞迴實現）

#include <stdio.h> #include <stdlib.h> //河內之塔遞迴實現 void hanoi(int n,char A,char B,char C); int main(int argc, char *argv[])

C語言中常用的字串操作（子串分割、替換、去前後空格、遞迴實現字串反轉）

在C語言中，並沒有像java中對字串操作的封裝好的函式，在C語言中，都需要自己根據C語言函式庫來實現常用的字串操作一、字串的分割，根據子串進行分割 #include<stdio.h>

資料結構練習之用棧來遞迴實現5的階乘#C語言實現

剛學資料結構，給大家分享一下今天學習資料結構的棧中的一個練習也算是順便記錄一下學習過程 #include <stdio.h> typedef struct StackNode { int vn; //儲存n的值 int vf; //儲存fun(n)的值 int t

漢諾塔問題（棧和遞迴的實現）

前邊寫的數值轉換是利用棧的先進後出的性質儲存數字的各位數，行編輯是利用棧的只允許在一端進行操作的特性，迷宮問題中棧儲存走過的通道塊，棧還可以輔助遞迴的實現，漢諾塔就是一個典型的例子漢諾塔問題描述：塔X上的圓盤全部移動到塔Z，且移動過程中，小盤始終位於大盤上方。解決思路就是欲將n個圓盤從X移動到

springboot原始碼之（bean的遞迴註冊）

在prepareContext中，用loader呼叫load方法，loader是 BeanDefinitionLoader，在BeanDefinitionLoader的構造方法中，會例項化一個AnnotatedBeanDefinitionReader，在reader的構造方法中，有一個靜態方法register

集合的全排列問題（遞迴實現）

設R={r1,r2,r3,.....rn}要進行全排列的n個元素，集合X中元素的全排列記為perm(X)，則(ri)perm(X)表示在全排列perm(X)的每一個排列前加上字首ri得到的排列。R的全排列定義可歸納定義如下：當n=1時，perm(R) = (r)，其中r為集合R中唯一元素當n>1

劍指offer 28：對稱的二叉樹（遞迴實現）

題目實現一個函式，用來判斷一棵二叉樹是不是對稱的。如果一顆二叉樹和它的映象一樣那麼它對稱。分析存在三種遍歷演算法，前序遍歷，中序遍歷，後序遍歷。我們可以針對前序遍歷定義一種對稱的遍歷演算法。即先遍歷父節點，再遍歷右結點，最後遍歷左結點。以

樹的遍歷--樹的廣度遍歷（層次遍歷），深度遍歷（前序遍歷，中序遍歷，後序遍歷的遞迴和非遞迴實現）

一由於本人的碼雲太多太亂了，於是決定一個一個的整合到一個springboot專案裡面。附上自己的github專案地址 https://github.com/247292980/spring-boot 附上彙總博文地址 https://www.cnblogs.com/ydymz/p/9391653.h

貪婪+回溯演算法------迷宮問題（遞迴實現）

前提很明顯，初始迷宮的路和牆需要定義和儲存，（這裡用的迷宮用陣列儲存，用1表示牆，用0表示未走過的路。）需要明確判斷下一步朝哪個方向走？（這裡的方向是：下->右->上->左，這裡將方向用一個二維陣列來儲存）如何判斷下一步是否在迷宮外？這

3.1 表示式求值（遞迴實現）

#include<iostream> #include<cstring> using namespace std; int term(); int expr(); int factor(); int expr() { i

陣列中的逆序對（分治、遞迴與合併）

在陣列中的兩個數字，如果前面一個數字大於後面的數字，則這兩個數字組成一個逆序對。輸入一個數組,求出這個陣列中的逆序對的總數P。將P對1000000007取模的結果輸出。即輸出P%1000000007 輸入描述: 題目保證輸入的陣列中沒有的相同的數字資料範圍：對

用java寫以下小程式碼1. 使用for迴圈列印乘法口訣表 2. 遞迴實現20! 3. 使用陣列靜態初始化方式初始化一個大小為10的整型陣列並輸出。

1.九九乘法表 public class Test { public static void main(String[] args) { int i; int j; for(i=1;i<10;i++) { for(j=1;j<=i;j++)

用DFS輸出n個數的全排列（遞迴實現）

最近在研究DFS，可能腦子不太夠吧，很多題都不知道怎麼實現，全排列應該是最簡單的題了。執行成功的程式碼如下所示：#include<stdio.h> #include<iostream> #include<string.h> using na

連結串列C++ | 從尾部列印頭部（使用棧、遞迴實現）_3

從尾部列印頭部

棧 - 實現：

遞迴 - 實現：

相關推薦