剑指offer：反向输出链表

剑指offer：反向输出链表

思路：使用stack先进后出，恰好与题目要求反向输出相契合。

实现：

牛客网编程通过。

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> values;
        stack<ListNode*> nodes;
        ListNode* pNode;
        pNode = head;
        while(pNode != nullptr) //当前节点非空
        {
            nodes.push(pNode);
            pNode = pNode->next;
        }
        ListNode* ptemp;
        while(nodes.empty() == false)
        {
            ptemp = nodes.top();
            nodes.pop();
            values.push_back(ptemp->val);
        }
        return values;
    }
};

需要稍加注意的是它的节点的定义。

相关知识：

/*链表的结构很简单，他由指针把若干个节点连接成链状结构，需要掌握
  链表的创建、插入节点，删除节点。
  链表是一种动态的数据结构，因为在创建链表时，无需知道链表的长度。
  当插入一个节点时， 我们只需要为新节点分配内存，然后调整指针的指向
  来确保新节点被链接到链表中。内存的分配不是在创建链表时一次性完成的
  而是每添加一个节点分配一次内存，由于没有闲置的内存，链表的空间效率
  比数组高。 */

#include<cstdio>
using namespace std;

/*单向链表的定义*/
struct ListNode
{
    int value;
    ListNode* pNext;
};
/*动态分配内存 
  程序的内存的需求只能在运行时确定，在这种情况下，程序需要动态分配内存
  property:
  1.c++中通过new关键字进行动态内存申请
  2.c++中动态内存的分配是基于类型进行的
  3.delete关键字用于内存释放
  语法：
  1.变量申请
  Type* pointer = new Type;
  delete pointer
  2.数组申请
  Type* pointer = new Type[N];
  delete[] pointer

  Example:
  int* foo = new int[5];
  在这种情况下，系统为int类型的五个元素动态分配空间，并返回指向序列的
  第一个元素的指针，该指针被分配给foo。因此，foo现在指向一个有效的内存
  块，其中包含5个int类型元素的空间。
  在这里，foo是一个指针，因此，foo指向的第一个元素可以用表达式 foo[0]或
  *foo来访问。可以用foo[1]或 *(foo+1)访问第二个元素。

  Note:程序请求动态内存由系统从内存堆中分配。但，计算机的内存是一种有限
  的资源，因此无法保证所有使用 operator new 分配内存的请求都将由系统授予。
  
  
  new关键字和malloc函数的区别
  1.new关键字是c++的一部分，malloc是由c库提供的函数
  2.new以具体类型为单位进行内存分配，malloc以字节为单位进行内存分配。
  3.new在申请单个类型变量时可以进行初始化，malloc不具备内存初始化的特性。
  
  new关键字的初始化：
  int* pi = new int(1);
  float* pf = new float(2.0f);
  char* pc = new char('c');

  c++动态分配内存异常机制：
  c++提供了两种标准机制检查内存分配是否成功。
  1.异常处理
    默认方法：if allocation fails, an exception fails
  2.nothrow
    当内存分配失效时，new返回的指针是空指针，程序继续正常运行
  */


/*向该链表的末尾添加一个节点*/
/*pHead 是一个指向指针的指针，当我们往一个空链表中插入一个节点时，新插入的节点就是链表的
  头指针。由于此时会改动头指针，因此必须把pHead的参数设为指向指针的指针，否则出了这个函数
  pHead依然是空指针。 */
void add_to_tail(ListNode** pHead, int value)
{
    ListNode* pNew = new ListNode();    //实例化并将新建的ListNode的地址赋给 pNew
    pNew->value = value;                //等价于 (*pNew).value = value;
    pNew->pNext = nullptr;

    if (*pHead == nullptr)
    {
        (*pHead)->pNext = pNew;
    }
    else
    {
        ListNode* pNode = new ListNode(); //建立临时用于循环的节点
        pNode = *pHead;
        while(pNode->pNext != nullptr)
        {
            pNode = pNode->pNext;
        }
        pNode->pNext = pNew;
    }
}

/*链表的内存不是连续的，所以若想在链表中找到它的第i个节点，我们只能从头节点开始，沿着指向下一个
  节点的指针遍历链表，他的时间效率为O(n) */
/*在链表中找到第一个含有某值的节点并删除该节点 */
void Remove_Node(ListNode** pHead, int value)
{
  if (pHead == nullptr || *pHead == nullptr) return;
  ListNode* pDelete = new ListNode();
  pDelete = nullptr;
  if ((*pHead)->value == value)            /*当头节点的值就为要删掉的值,则用pDelete记录，头结点现在变成了原来头结点的下一个节点*/
  {
    pDelete = *pHead;
    *pHead = (*pHead)->pNext;
  }
  else
  {
    ListNode* pNode = new ListNode();     /*pNode作为循环使用的节点 */
    pNode = *pHead;                       /*先将其初始化为头指针 */
    while (pNode->pNext != nullptr && pNode->pNext->value != value)       /*当前节点的下一个节点不是要删除的节点 */
    {
      pNode = pNode->pNext;
    }
    
    if (pNode->pNext != nullptr && pNode->pNext->value == value)          /*当前节点的下一个节点是要删除的节点 */
    {
      pDelete = pNode->pNext;             /*用pDelete记录要删去的节点 */
      pNode->pNext = pNode->pNext->pNext; /*当前节点的下一个节点要被删掉，所以要指向当前节点的下下一个 */
    }
  }
  if (pDelete != nullptr)                 /*可能原来的链表里面并没有所求的value */
  {
    delete pDelete;
    pDelete = nullptr;
  }
}
/*打印链表里面的所有节点 */
void Print_all_node(ListNode** pHead)
{
  if (pHead == nullptr || *pHead == nullptr) return;
  ListNode* pNode = new ListNode();
  pNode = *pHead;
  while (pNode != nullptr)
  {
    printf("%d\n", pNode->value);
    pNode = pNode->pNext;
  }
  return;
}
int main()
{
  ListNode* pHead = new ListNode();                   //pHead 是ListNode*类型
  pHead->value = 2;
  pHead->pNext = nullptr;
  add_to_tail(&pHead, 9);
  Print_all_node(&pHead);
  add_to_tail(&pHead, 3);
  Print_all_node(&pHead);
  Remove_Node(&pHead, 9);
  Print_all_node(&pHead);
  return 0;
}