剑指 Offer 06 题目解析 &C++stack & C++ vector

题目

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2] 输出：[2,3,1]

限制：

0 <= 链表长度 <= 10000

作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5dt66m/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

思路

思路一： 栈，先进后出的结构特点实现过程
流程：

1. 元素从列表中取出入栈
2. 从栈中取出放入vector

思路二：递归法 流程：

1. 先递推至链表末端
2. 回溯时，依次将节点值加入列表，即可实现链表值的倒序输出

拓展

C++ vector

• 什么是vector？

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence
Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

• 容器特性

1 .顺序序列
顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

2.动态数组
支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。

3.能够感知内存分配器的（Allocator-aware）
容器使用一个内存分配器对象来动态地处理它的存储需求。

• 基本函数实现

1.构造函数

vector():创建一个空vector
vector(int nSize):创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中
 

2.增加函数

void push_back(const T& x):向量尾部增加一个元素X
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.删除函数

iterator erase(iterator it):删除向量中迭代器指向元素 
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素 
void pop_back():删除向量中最后一个元素 
void clear():清空向量中所有元素

4.遍历函数

reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

5.判断函数

bool empty() const:判断向量是否为空，若为空，则向量中无元素

6.大小函数

int size() const:返回向量中元素的个数
int capacity() const:返回当前向量所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值

7.其他函数

void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中前n个元素的值为x
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

8.看着清楚

1.push_back 在数组的最后添加一个数据

2.pop_back 去掉数组的最后一个数据

3.at 得到编号位置的数据

4.begin 得到数组头的指针

5.end 得到数组的最后一个单元+1的指针

6．front 得到数组头的引用

7.back 得到数组的最后一个单元的引用

8.max_size 得到vector最大可以是多大

9.capacity 当前vector分配的大小

10.size 当前使用数据的大小

11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值

12.reserve 改变当前vecotr所分配空间的大小

13.erase 删除指针指向的数据项

14.clear 清空当前的vector

15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty 判断vector是否为空

18.swap 与另一个vector交换数据

• 简单介绍

#include < vector> 
using namespace std;
 Vector<类型>标识符
Vector<类型>标识符(最大容量)
Vector<类型>标识符(最大容量,初始所有值)
Int i[5]={1,2,3,4,5}
Vector<类型>vi(I,i+2);//得到i索引值为3以后的值
Vector< vector< int> >v; 二维向量//这里最外的<>要有空格。否则在比较旧的编译器下无法通过

参考：
参考一

C++ stack

• 简介

这种数据结构使用LIFO技术，其中LIFO表示后进先出。首先插入的元素将在末尾提取，以此类推。有一个名为“top”的元素，它是位于最上面位置的元素。所有插入和删除操作都是在堆栈的顶部元素本身进行的。

应用区域中的堆栈暗示为容器适配器。

容器应支持以下操作列表：

empty

size

back

push_back

pop_back

• 语法

  template<class T, class Container = deque<T> > class stack;

T：参数指定容器适配器将保留的元素的类型。

Container：参数指定容器的内部对象，用于容纳堆栈的元素

• 函数

 (constructor)	该函数用于构造堆栈容器。
empty()	该函数用于测试堆栈是否为空。如果堆栈为空，则该函数返回true，否则返回false。
size()	该函数返回堆栈容器的大小，该大小是堆栈中存储的元素数量的度量。
top()	该函数用于访问堆栈的顶部元素。该元素起着非常重要的作用，因为所有插入和删除操作都是在顶部元素上执行的。
push()	该函数用于在堆栈顶部插入新元素。
pop()	该函数用于删除元素，堆栈中的元素从顶部删除。
emplace()	该函数用于在当前顶部元素上方的堆栈中插入新元素。
swap()	该函数用于交换引用的两个容器的内容。
relational operators	非成员函数指定堆栈所需的关系运算符。
uses allocator<stack>	顾名思义，非成员函数将分配器用于堆栈。

参考：
参考一

源码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 //F1： 利用栈，先进后出的结构特点实现过程 ； 时间复杂度0(N) 空间复杂度O(N)
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {

        vector<int> res;
        stack<int> sta;


        //遍历链表，将元素入栈
        ListNode* work = head;
        while (work) {
            sta.push(work->val);
            work = work->next;
        }
        //从栈中取出元素，返回结果
        while (!sta.empty()) {
            //从栈顶取出元素，插入vector当中
            res.push_back(sta.top());
            sta.pop();
        }
        return res;
    }
};
//F2:递归法:利用递归，先递推至链表末端；回溯时，依次将节点值加入列表，即可实现链表值的倒序输出。
//时间复杂度 O(N)： 遍历链表，递归 N 次
//空间复杂度 O(N)： 系统递归需要使用 O(N)的栈空间。
class Solution {
private:
    vector<int>res;
public: 
    vector<int> reversePrint(ListNode* head) {
        recurent(head);
        return res;
    }
    void recurent(ListNode* head) {
        if (head == nullptr) {
            return;
        }
        recurent(head->next);
        res.push_back(head->val);
    }
    
};