设计鲁棒性的方法：输入一个链表的头结点，逆序遍历打印该链表出来

之前有过整理链表等的概念和基本算法。比较重要的是插入，删除，遍历，建表（尾插法，头插法）

回忆链表尾部插入结点：

#include <iostream>
using namespace std;

typedef struct Node{
    int data;//数据域
    Node *next;//指针域
} Node, *List;

//在单链表的末位添加一个结点
void addNode(List *head, int value)
{
    //先动态的创建结点
    Node *newNode = new Node();
    newNode->data = value;
    newNode->next = NULL;
    //判断表是否为空,head为头指针
    if (*head == NULL) {
        *head = newNode;
        cout << (*head)->data << endl;
    }
    else{
        //不为空表，尾插，先遍历找到尾结点
        Node *p = *head;
        //从头到尾遍历单链表
        while (p->next != NULL) {
            //p 作为标记，顺次后移
            p = p->next;
        }
        //找到了尾结点，插入新结点
        p->next = newNode;
        cout << p->next->data << endl;
    }
}

int main(void)
{
    List node = NULL;
    addNode(&node, 10);
    addNode(&node, 100);
    
    return 0;
}

要区分链表和顺序表（数组）之间的区别，顺序表（比如数组）可以随机存储，时间复杂度是 o（1），链表是离散的，动态的分配的，只能从头到尾遍历，不能随机存储，时间复杂的是 o（n），且注意空表的情况，还有二级指针的使用问题，注意到了这几点，一般没有问题了。

删除链表中第一个寻找到的目标结点

//查找到结点的 data 为val的第一个结点，然后删除之
void deleteNode(List *head, int value)
{
    //指示指针
    Node *p = *head;
    //指向待删除结点的指针
    Node *del = NULL;
    //先判断是否空表
    if (*head == NULL || head == NULL) {
        cout << "空表" << endl;
        exit(0);
    }
    //然后判断头结点
    if ((*head)->data == value) {
        del = *head;
        *head = (*head)->next;
    }
    //遍历寻找,注意遍历结束的标志有两个，没找到，找到
    while (p->next !=NULL && p->next->data != value) {
        p = p->next;
    }
    //循环遍历结束，判断找到的情况
    if (p->next != NULL && p->next->data == value) {
        del = p->next;
        //删除
        p->next = p->next->next;
    }
    //销毁内存
    delete del;
    //消除野指针
    del = NULL;
}

void traversal(List head)
{
    Node *p = head;
    if (p == NULL) {
        cout << "空表" << endl;
        exit(0);
    }
    
    while (p != NULL) {
        cout << p->data << endl;
        p = p->next;
    }
}

int main(void)
{
    List node = NULL;
    //traversal(node);
    addNode(&node, 10);
    addNode(&node, 100);
    traversal(node);
    deleteNode(&node, 10);
    traversal(node);
    
    return 0;
}

10

100

10

100

100

Program ended with exit code: 0

输入一个链表的头结点，逆序遍历打印该链表

链表的结点结构

typedef struct Node{
    int data;//数据域
    Node *next;//指针域
} Node, *List;

直接的思路：改变链表的方向，从头到尾输出，也就是把链表的结点的指针反转，但是，这样会改变原单链表的结构，如果不可以改变链表的结构，那么这个方法就不可行。

但是不论怎样，肯定是要遍历链表，只不过这里要求是逆序的遍历，也就是第一个找到的结点，让它最后一个输出。联系到了栈这个数据结构，先进后出。在遍历的时候，每查找到一个结点，就把这个结点压栈，遍历结束，出栈，就是逆序了。

依靠c++ STL stack 实现逆序打印单链表

stack不能遍历，所以没有迭代器，必须添加头文件 #include <stack>

//依靠栈来实现逆序打印单链表
//输入单链表的头结点，实现单链表的逆序打印
void traversalReverse(List head)
{
    //使用 c++ STL stack
    stack<List> nodes;
    //指示指针
    Node *p = head;
    //遍历
    while (p != NULL) {
        //入栈
        nodes.push(p);
        //指针后移
        p = p->next;
    }
    //遍历完毕，从栈中输出结点
    //empty（）方法：堆栈为空则返回真
    while (!nodes.empty()) {
        //stack 没有迭代器，取出栈顶元素
        p = nodes.top();
        cout << p->data << " ";
        //出栈
        nodes.pop();
    }
}

int main(void)
{
    List node = NULL;
    addNode(&node, 10);
    addNode(&node, 100);
    addNode(&node, 101);
    addNode(&node, 102);
    addNode(&node, 103);
    traversalReverse(node);
    
    return 0;
}

10

100

101

102

103

103 102 101 100 10 Program ended with exit code: 0

联系递归，递归在本质上就是一栈结构，还可以使用递归来直接实现逆序打印单链表

在一次递归中，每次访问到一个结点，先打印该结点的后续一个结点，然后打印该结点本身，这样效果就是把链表逆序打印输出。

void traversalRecursive(List head)
{
    //先判断链表是否为空
    if (head != NULL) {
        //递归结束的条件
        if (head->next != NULL) {
            //先打印该结点的后续结点
            traversalRecursive(head->next);
        }
        //然后打印该结点
        cout << head->data << "\t";
    }
}

int main(void)
{
    List node = NULL;
    addNode(&node, 10);
    addNode(&node, 100);
    addNode(&node, 101);
    addNode(&node, 102);
    addNode(&node, 103);
    traversalRecursive(node);
    
    return 0;
}

递归的优点：代码简单明了

递归的缺点：如果链表很长，导致递归调用层次很深，有可能导致函数的调用栈溢出，故一般第一个方法，显式的使用栈来实现逆序打印单链表的鲁棒性要好一些。

何为代码的鲁棒性？

鲁棒是Robust的音译，也就是健壮和强壮的意思。它是在异常和危险情况下系统生存的关键。比如说，计算机软件在输入错误、磁盘故障、网络过载或有意攻击情况下，能否不死机、不崩溃，就是该软件的鲁棒性。所谓“鲁棒性”，是指控制系统在一定（结构，大小）的参数影响下，维持其它某些性能的特性。

 

欢迎关注

dashuai的博客是终身学习践行者，大厂程序员，且专注于工作经验、学习笔记的分享和日常吐槽，包括但不限于互联网行业，附带分享一些PDF电子书，资料，帮忙内推，欢迎拍砖！