题目更要:有一个【1,100000】长度的链表,判断其是否回文
法一:使用笨方法:栈(因为其有先入后出|后入先出的特性)
class Solution {
public:
public:
stack<int> stack1;
//法一:用堆进行匹配
//遍历存入
bool isPalindrome(ListNode* head){
ListNode* p = head;
while (p)
{
stack1.push(p->val);
p = p->next;
}
p = head;//归位
while (!stack1.empty())
{
if (stack1.top() != p->val)
return false;
stack1.pop();//弹出
p = p->next;//p下移
}
return true;
}
};
上述代码比较简单,就不再赘述,仅仅是简单使用了stack的性质
法二:使用数组存储后,双指针遍历
思想:因为链表的反向遍历比较麻烦,且时间效率不佳
因此将链表的数据copy到数组中,利用其容易反向遍历的特点进行实现
vector(向量空间|动态数组)(使用方式)(可以当作由0开始,size-1的数组使用)
相关函数使用示例(vector):
#include<vector> vector<int> a,b; //b为向量,将b的0-2个元素赋值给向量a a.assign(b.begin(),b.begin()+3); //a含有4个值为2的元素 a.assign(4,2); //返回a的最后一个元素 a.back(); //返回a的第一个元素 a.front(); //返回a的第i元素,当且仅当a存在 a[i]; //清空a中的元素 a.clear(); //判断a是否为空,空则返回true,非空则返回false a.empty(); //删除a向量的最后一个元素 a.pop_back(); //删除a中第一个(从第0个算起)到第二个元素,也就是说删除的元素从a.begin()+1算起(包括它)一直到a.begin()+3(不包括它)结束 a.erase(a.begin()+1,a.begin()+3); //在a的最后一个向量后插入一个元素,其值为5 a.push_back(5); //在a的第一个元素(从第0个算起)位置插入数值5, a.insert(a.begin()+1,5); //在a的第一个元素(从第0个算起)位置插入3个数,其值都为5 a.insert(a.begin()+1,3,5); //b为数组,在a的第一个元素(从第0个元素算起)的位置插入b的第三个元素到第5个元素(不包括b+6) a.insert(a.begin()+1,b+3,b+6); //返回a中元素的个数 a.size(); //返回a在内存中总共可以容纳的元素个数 a.capacity(); //将a的现有元素个数调整至10个,多则删,少则补,其值随机 a.resize(10); //将a的现有元素个数调整至10个,多则删,少则补,其值为2 a.resize(10,2); //将a的容量扩充至100, a.reserve(100); //b为向量,将a中的元素和b中的元素整体交换 a.swap(b); //b为向量,向量的比较操作还有 != >= > <= < a==b;
以上代码引用自:
原文链接:https://blog.csdn.net/weixin_41743247/article/details/90635931
class Solution {
public:
vector<int> arr1;
//法二:使用动态数组进行存储,再双向遍历
bool isPalindrome(ListNode* head) {
ListNode* p = head;
while (p)
{
arr1.emplace_back(p->val);
p = p->next;
}
int rear = arr1.size() - 1;//得到尾部
int front = 0;
while (rear > front)
{
if (arr1[rear] != arr1[front])
return false;
rear--;
front++;
}
return true;
}
};
思考误区及启发:
vector下标:由0开始,到size-1结束
复制成数组后,直接调用
当发现数组越界的时候,注意检查(有关下标变化的循环)
如代码中的while()
陷阱:如果不是奇数的数组,可能rear和front会直接错开,并不经历相等
因此最好使用front<rear的硬条件
法三:使用递归(此时锻炼对递归的理解)
递归的思想(整理):
使用递归把point指针送到最后一个rear,返回的时候
每一层的返回时,都会自动把point往左送
所以每一次判断结束后,都把左指针,left往右送
当遇到一个不匹配的时候,便返回false,则会一直返回false直到完成递归的归。
手写笔记:
class Solution {
private:
ListNode* pre;
public:
bool recursion(ListNode* cur)
{
if (cur == NULL)//结束条件和特例
{
return true;//有效返回标志
}
else
{
if (!recursion(cur->next))
//该条语句是递归的入口,同时具有一个性质
//锁false,当存在了一次false则一直回都是false
{
return false;
}
if (cur->val == pre->val)
{
pre = pre->next;
return true;
}
else
return false;
}
}
bool isPalindrome(ListNode* head) {
pre = head;//先存
return recursion(head);
}
};
分析及思考:
一、利用递归性质,弥补链表的不可溯性
利用的是递归送cur到队尾,其会自动回来(弥补了链表的不可溯性)
由于(每次递归都存当前)才实现以上
二、利用递归锁false
当某个递归的过程中,发现不合适了,可以立刻使用递归锁false/锁true,直到给出答案
if (!recursion(cur->next)) //该条语句是递归的入口,同时具有一个性质 //锁false,当存在了一次false则一直回都是false { return false; }