1.cin.get()还没写过
HJ51 输出单向链表中倒数第k个结点## 标题
已经打印出输出结果了，怎么又进去whie(cin)了？ 再按F10就退出了
按Ctrl Z还进去了
按F10 F5没到什么断点， 控制台黑窗口也没变化，再按回车，变成这样了：
别人while(cin >> n) 通过了网页测试。我这是while(cin){ cin >> n;
虽然我这第一次cin >> n是正确的，但一轮之后我就看不懂了，只是现在认为while(cin)是判断cin这个对象有没有，不是判断cin输入的内容是不是想要的，或者有“有效输入”，关键是回车也会进去，也是有效的，但是数字不是一般的整数了。
翻了下网页，https://blog.csdn.net/u014182411/article/details/62053816
这篇文章好在又说到了标准输入是键盘，这下才理解了这个模糊的地方，我现在理解是这样，cin不是从控制台读的，是从输入缓冲区读的，是内存中的地方，有回车cin才会去读，控制台看到的也是从键盘读到显示的，和cin是读的是有关的东西，只是控制台还要将键盘输入内容显示在屏幕上，终端上不用回车就拿到了。
while(cin) 结果难分析，别用它了
5
1 2 3 4 5
4
当一轮执行结束，虽然程序位置没停在while(cin >> n), 但是应该是要停在那的，ctrl z后刚好停在while()之后第一句。
结果对了
不过还有个要求，构建好链表后要忘记链表长度，感觉需要个双链表。
就是有preNode *吧。但是，链表的结构定了，只有next指针，没有pre指针， 快慢指针不错。
奇怪，
腾讯电脑管家的软件市场老是打不开， 换360试下
如果最后的k=2 后面跟个空格，再跟CTRL Z就会正确，为什么先回车就错了？
每次计算完，新构建链表前，上一个链表没销毁。
bool hasKcounts = true; for循环里有这句话但没有说重定义
通过的答案
#include
using namespace std;
struct ListNode {
int m_nKey;
ListNode *m_pNext;
};
int main()
{
/* head-> 1.key 1.next -> 2.key 2.next -> 3.key 3.next(nullptr)
*/
int n=0;
int k=0;
int ret =0;
auto *head = new(ListNode); // alloc space
auto *p = new(ListNode); // alloc space
auto *fast = new(ListNode); // alloc space
auto *slow = new(ListNode); // alloc space
if(head == nullptr || p == nullptr || fast== nullptr || slow == nullptr){
cout<< “failed, head == nullptr || p == nullptr || fast== nullptr || slow == nullptr” << endl;
ret = -1;
}
p = head;
fast = head;
slow = head;
// while(cin){ 写一个cin就是从输入流里取一次吧，这样没把n保留下来吧
// cin >> n;
// 8
// 1 2 3 4 5 6 7 8
// 4
// 5
// 1 2 3 4 5
// 2
while(cin >> n){
head = new(ListNode); // alloc space
p = new(ListNode); // alloc space
fast = new(ListNode); // alloc space
slow = new(ListNode); // alloc space
if(head == nullptr || p == nullptr || fast== nullptr || slow == nullptr){
cout<< “failed, head == nullptr || p == nullptr || fast== nullptr || slow == nullptr” << endl;
ret = -1;
}
p = head;
fast = head;
slow = head;
for(int i=0; i<n; ++i){
cin >> p->m_nKey; // store input to data area
/* p x.key x.next
*/
// p 2.key store cin
// p 3.key store cin
// if(i==0){
// head = p; // head -> p 1.key
// }
if(i==n-1){
p->m_pNext = nullptr; // 3.p.next(nullptr)
break;
}
/* head-> 1.key 1.next -> 2.key 2.next -> 3.key 3.next(nullptr)
*/
p->m_pNext = new(ListNode); // p at 1.key, create new node
// how to link 2.key to 1.next
// p.next ->2.key 1.next->2.key
// 2.next -> 3.key
p = p->m_pNext;
// p -> 2.key
// p-> 3.key
}
// 双向链表 <- 1.pre <- 2.pre <-3.pre
// head-> 1. key 1.next -> 2.key 2.next -> 3.key 3.next(nullptr)
// 双向链表不符合链表结构，先不能用，看别人提的快慢指针可以，怎么想到的，厉害
cin >> k;
// 快指针要超前慢指针k-1个位置，慢指针起点在head, 快指针起点在head向前K-1个位置，要找k-1下， 1- k-1
// 如果i< k-1时，fast指向空, 也就是链表才k<-1的长度 举例 k=4, i要等于3 (k-1)时next才可以为nullptr,
// i=2时i<=k-2时为空，就是倒数的数给大了，总数都不到k个，返回nullptr. n =3 1 2 3, k =4 error
// fast first forward k-1 step, it's k-1 times, how to go when want backcount one, can cover
bool hasKcounts = true;
for(int i=0;i<k-1;++i){
fast = fast->m_pNext;
if(fast->m_pNext == nullptr && i < k-2){ // 不到k-1步就到最后一个节点了
hasKcounts = false;
cout << "hasn't k counts nodes" << endl;
break;
}
}
// verify the backcount k node location
while(fast->m_pNext != nullptr){
fast = fast->m_pNext;
slow = slow->m_pNext;
}
if (hasKcounts) {
cout << slow->m_nKey << endl;
} else {
ret = -2;
}
delete head;
// delete p; // wont release two times?
head=nullptr;
p=nullptr;
fast=nullptr;
slow=nullptr;
}
/* for(int i=0;i<n;++i){
if(i==0){
p=head;
}
else {
p = p->m_pNext;
}
delete p; // second to here, cant go on, serveral times said exception
} / // delete fast; unknown signal
// delete slow;
/ ListNode *p1 = head->m_pNext;
cout << “second node:” << p1->m_nKey << “watch first node whether released” << endl; */
return ret;
}
链表delete头结点后应该就不能再delete链表其他节点了，会被认为重复释放，例如再delete p。
##HJ48 从单向链表中删除指定值的节点
unique_ptr will auto to free ?当程序结束的时候
// free a pointer p, p will be a random value? it won’t change, *p will be a random value?
}
智能指针如果某时刻想自己释放可以吗
不行
#####什么时候算引用数不为0，感觉是shared类型的才会有引用不为0的情况吧
shift tab可以往后退四格
for(i=0;i<5;i++){
a++;
}
for‘s run steps, initial value, compare enter condition, entry or skip for, if enter, step forward value +1,
every want entry, need first to look whether condition match
为什么不能读空指针的值
有人说页表发现是无效地址，反馈给操作系统，操作系统报段错误11，让程序自杀，应该是操作系统认为程序已经出错了，再执行肯定不符合期望，就让程序结束吧。
https://so.csdn.net/so/search?spm=1000.2115.3001.4498&q=%E4%B8%BA%E4%BB%80%E4%B9%88%E4%B8%8D%E8%83%BD%E8%AF%BB%E7%A9%BA%E6%8C%87%E9%92%88%E7%9A%84%E5%80%BC&t=&u=
删除链表的特定值的那个节点 还没做完
// title is thi
// https://www.nowcoder.com/practice/f96cd47e812842269058d483a11ced4f?tpId=37&tqId=21271&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D37&difficulty=undefined&judgeStatus=undefined&tags=&title=
/* 描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1 3 2表示为 2->3 链表为2->3->1
5 1表示为
1->5
链表为2->3->1->5
最后的链表的顺序为 2 7 3 1 5 4
最后一个参数为2，表示要删掉节点为2的值
删除 结点 2
则结果为 7 3 1 5 4
数据范围：链表长度满足
>=1 int足够
节点中的值满足 >=0 int足够
测试用例保证输入合法
输入描述：
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值 */
/*要放的节点值 它前面的那个节点的值 */
// 示例1
// 输入：
// 5 2 3 2 4 3 5 2 1 4 3
// 复制
// 输出：
// 2 5 4 1
// 复制
// 说明：
// 形成的链表为2->5->3->4->1
// 删掉节点3，返回的就是2->5->4->1
// 示例2
// 输入：
// 6 2 1 2 3 2 5 1 4 5 7 2 2
// 复制
// 输出：
// 7 3 1 5 4
// 复制
// 说明：
// 如题
#include <iostream>
#include <memory>
using namespace std;
typedef struct ListNode
{
int m_value;
ListNode *m_pNext;
} ListNode;
int main()
{
// first value is how many nodes, second value is first node value
// begin from third value, according value find a node then insert one value after it
auto head = make_unique<ListNode>();
auto p = make_unique<ListNode>();
auto pFind = make_unique<ListNode>();
if (p == nullptr || head == nullptr || pFind == nullptr)
{
cout << "create head or p or pFind failed," << "head:" << head << ",p:" << p
<< ",pFind:" << pFind << << endl;
}
// 2 + (n-1) * 2 + 1 = 2n +1 will get these values
int n = 0;
cin >> n;
constexpr int allInCount = 2 + (n - 1) * 2 + 1;
int toInsertValue = 0;
int toInsertAfterIt = 0;
int toDeleteNumber = 0;
for (int i = 0; i < allInCount - 2; ++i)
{
// can't define a variable in loop?
if (i == 0)
{
cin >> *head;
}
else if (i < allInCount - 3)
{
if (i % 2 == 1)
{ // index 2 开始 要插入的值 要插入哪个值之后
cin >> toInsertValue;
}
else
{
cin >> toInsertAfterIt;
for (pFind = head; *pFind != toInsertAfterIt; pFind = pFind->m_pNext) // find every node to find toInsertAfterIt
{
if (pFind->m_pNext != nullptr)
{
p->m_pNext = make_unique<ListNode>();
if (p->m_pNext == nullptr)
{
cout << "make_unique p->m_pNext failed in loop" << "p:" << p << endl;
}
// a node amend to this List
// p point to the lastest node
p = p->m_pNext;
p->m_value = toInsertValue;
}
}
p = make_unique<ListNode>();
p->m_pNext = pFind->m_pNext;
pFind->m_pNext = p;
p->m_value = toInsertValue;
}
}
else
{
cin >> toDeleteNumber;
}
// if want to delete a node，find next node value,
// that easier to process need to delete node, and link previous node and next node of to delete node
// 不容易判断是否是最后一个节点，if(toDeleteNumber == pFind->m_value){
// pFind->m_value = 0; // restore default value
// p->m_pNext = p->m_pNext->m_pNext;
// p->m_pNext->m_pNext = nullptr; // auto to free ? don't need i to free?
// // free a pointer p, p will be a random value? it won't change, *p will be a random value?
// for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
// cout << p->m_value << " ";
// }
// cout << endl;
// }
// for(pFind = head; *pFind->m_pNext->m_value == toDeleteNumber && pFind!= nullptr; pPrevioud = pFind && pFind = pFind->m_pNext){
// 太长看的记不住
// 保存上一个节点的指针，方便删除当前节点，for循环第三句可以做两个事情吗--多半不行-没怎么见过-看答案，保存当前节点的指针，寻找指针指向下一个节点
// 一种写法是while, 在循环内保存previous节点指针
// for(pFind = head; *pFind->m_value == toDeleteNumber && pFind!= nullptr; pPrevioud = pFind && pFind = pFind->m_pNext){
// pFind = head;
// while(pFind!= nullptr){
// if(toDeleteNumber == pFind->m_value){
// delete pFind;
// link next node to previous node
// break; // 中止吗？
// }
// pPrevious = pFind;
// }
for(pFind = head;pFind!= nullptr;){
if next=!nullptr
pPre = p;
pPrevious = pFind; // 先保存当前节点，如果是要删除的节点就删除呀
if(toDeleteNumber == pFind->m_value){
// pFind->m_pNext->m_value = 0; // restore default value
// p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// p->m_pNext->m_pNext = nullptr; // 自动释放？设置的值会自己归零吗 auto to free ? don't need i to free?p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
p->m_pNext = p->m_pNext->m_pNext; // 链接这个个节点和它的下下一个节点,
// free a pointer p, p will be a random value? it won't change, *p will be a random value?
for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
cout << p->m_value << " "; // 打印删除后的结果
}
cout << endl;
}
pFind = pFind->m_pNext; // 不相等就是没找到，就移到下一个节点下来再对比
}
// for 是否可以把不相等放在条件内，如果在循环体内相等了，退出就行
// not found
if(pFind->m_value != toDeleteNumber && pFind->m_pNext == nullptr){
cout << "nullptr" << endl;
}
}
// want to save it to a vector
return 0;
}
11.23 样子
// title is thi
// https://www.nowcoder.com/practice/f96cd47e812842269058d483a11ced4f?tpId=37&tqId=21271&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D37&difficulty=undefined&judgeStatus=undefined&tags=&title=
/* 描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1 3 2表示为 2->3 链表为2->3->1
5 1表示为
1->5
链表为2->3->1->5
最后的链表的顺序为 2 7 3 1 5 4
最后一个参数为2，表示要删掉节点为2的值
删除 结点 2
则结果为 7 3 1 5 4
数据范围：链表长度满足
=1 int足够
节点中的值满足 >=0 int足够
测试用例保证输入合法
输入描述：
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值 */
/*要放的节点值 它前面的那个节点的值 */
// 示例1
// 输入：
// 5 2 3 2 4 3 5 2 1 4 3
// 复制
// 输出：
// 2 5 4 1
// 复制
// 说明：
// 形成的链表为2->5->3->4->1
// 删掉节点3，返回的就是2->5->4->1
// 示例2
// 输入：
// 6 2 1 2 3 2 5 1 4 5 7 2 2
// 复制
// 输出：
// 7 3 1 5 4
// 复制
// 说明：
// 如题
// 代码考虑上传github, 有git记录
#include
#include
using namespace std;
typedef struct ListNode
{
int m_value;
ListNode *m_pNext;
} ListNode;
int main()
{
// 执行过程 创建指针 按要构造的链表长度逐个插入节点 找到要删除的节点 打印所有节点
//
// 构造过程，例如输入一行数据为:
// 6 2 1 2 3 2 5 1 4 5 7 2 2
// 则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
// 构造过程不一般 输入2n+1个数，告诉在哪个节点后插入一个节点 先要插入的节点 再告诉在谁之后
// 节点个数1个, 第一个节点1个，告诉n-1个节点的内容的数就是 插入n-1个要2（n-1）个，要删除的节点的值1个, 共1+1+2（n-1）个数
// first value is how many nodes, second value is first node value
// begin from third value, according value find a node then insert one value after it
auto head = make_unique();
auto p = make_unique();
auto pFind = make_unique();
if (p == nullptr || head == nullptr || pFind == nullptr)
{
cout << “create head or p or pFind failed,” << “head:” << head << “,p:” << p
<< “,pFind:” << pFind << endl;
}
// 2 + (n-1) * 2 + 1 = 2n +1 will get these values
int n = 0;
cin >> n;
cin >> *head;
// constexpr int leftInputCount = (n - 1) * 2 + 1; // 开始这个allInCount之后看怎么还赌博上了，嘴角抽动, 改成allInputCount， 再改成leftInputCount
int insertNodeNeedCount = (n - 1) * 2;
int toInsertValue = 0;
int toInsertAfterIt = 0;
int toDeleteNumber = 0;
// 插入
// 拿节点值构造链表 步进多少步 重复做的事情多少遍 处理过程有环 循环
// 还需执行
for (int i = 0; i < insertNodeNeedCount; ++i) // 之前有输入过allInputCount -2, leftInputCount就是2n, 就是< 2n
{
// can't define a variable in loop?
// if (i < leftInputCount - 1) // < 2n-1 , 最大到2n-2, n-1个节点值
// {
if (i % 2 == 0) // 0 1 2 3 4 5 ... 0 2 4是要插入的值，规律它们都是2的倍数
{ // 开始 要插入的值
cin >> toInsertValue;
}
else
{ // 输入要插入到哪个点之后的点，插入
cin >> toInsertAfterIt;
// 插入新节点 pFind和p什么关系，有必要留p吗？
for (pFind = head; pFind != nullptr; pFind = pFind->m_pNext) // find every node to find toInsertAfterIt
{
// 这句话取消 第二句->m_pNext要单独放一行吗，先不留，看下, 如果是空怎么办，再单独判断， && pFind->m_pNext->m_pNext != nullptr
// if (pFind->m_pNext != nullptr) // next不解引用, 不用判断它
// {
//这个节点是要找的了，就先把下个节点先和要插入的节点连起来，再把这个节点和要插入的节点连起来
if(pFind->m_value == toInsertAfterIt){
p = make_unique<ListNode>(); // 按结构体要求分配内存，头指针交给pFind,
if (p == nullptr)
{
cout << "make_unique p->m_pNext failed in loop" << "p:" << p << endl;
}
// a node amend to this List
// p point to the lastest node
p->m_value = toInsertValue; // 分配一个节点后，赋值给它
p->m_pNext = pFind->m_pNext; // 当前节点的下一个节点连在要插入的节点后面，
// 第一个节点或者最后一个节点后面都是空节点，这句也适用
pFind->m_pNext = p; // 要插入的节点连在找到的节点后面
break; // 找到就退出循环
}
}
if (pFind == nullptr) {
// 最后一个节点了，也没找到要插入的
cout << "node had input may has error, not found that node to insert after it" << endl;
}
}
}
// 删除
cin >> toDeleteNumber;
for(pFind = head; pFind!= nullptr; pFind = pFind->m_pNext;){
// if next=!nullptr
// pPre = p;
// 链接上一个节点和下一个节点 难
// 用下一个节点的值去和要比较的值对比，如果相等了，再做这个节点和下下个节点的连接, 这样也不用保存了
if(pFind->m_pNext != nullptr){
if(pFind->m_pNext->m_pNext != nullptr){
if(toDeleteNumber == pFind->m_pNext->m_pNext->m_value){ // 判断下下个节点和要删除的值是不是相等，不相等就回到for 条件步进那
// pFind->m_pNext->m_value = 0; // restore default value
// p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// p->m_pNext->m_pNext = nullptr; // 自动释放？设置的值会自己归零吗 auto to free ? don't need i to free?p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// pFind->m_pNext 这种也指向的是下个节点存储数据的地址 表格 第一列 编号 内存位置编号
// 怕以下2句把pFind->m_pNext的值也改为nullptr了。应该不会
// auto p_next_next = pFind->m_pNext->m_pNext;
// pFind->m_pNext->m_pNext = nullptr;
// pFind->m_pNext = p_next_next; 考虑要这么做，auto p_next_next 这句性能，语法要再考虑
// (下个节点的next要设置为空了, 以免没有释放掉后面能操作这个链表的节点的值。也避免释放这个节点时把它连接的后续节点给释放了//这句还没实现)
// 链接这个词语像是轻巧的东西，抓住这个一甩，后面的也动了，连接像很重的东西，两者能交流，但是动一个，另一个一般不动
// 假如p-next-next 是16 打印一个指针的值 显示的是它的虚拟内存地址 还是真实内存地址 真实的也无妨吧
// 假如开始pFind->m_pNext是8，pFind->m_pNext->m_pNext是16，把16保存给a, 把pFind->m_pNext->m_pNext置为0，
// 现在保存把16记住，要申请后分配一个节点，这个节点不分配节点只用int保存下指针值行不行，ListNode *m_pNext; 第一种方法Int *赋值的时候强制转换？
// 第二种方法是复制一个节点，指向它的指针的值是pFind->m_pNext->m_pNext的值16，它的next置为0，但是它的地址值估计只能是分配的吧，不能设置
int * p_next_next = (int *)pFind->m_pNext->m_pNext;
// pFind->m_pNext = pFind->m_pNext->m_pNext; // // 链接这个个节点和它的下下一个节点, 把下个节点断开了，
pFind->m_pNext->m_pNext = nullptr;
pFind->m_pNext = (ListNode *)p_next_next; // // 链接这个个节点和它的下下一个节点, 把下个节点断开了，
// free a pointer p, p will be a random value? it won't change, *p will be a random value?
}
} else {
}
} else { // 到最后一个节点了
if(toDeleteNumber == pFind->m_pNext->m_value){ // 不相等就回到for 条件步进那
// pFind->m_pNext->m_value = 0; // restore default value
// p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// p->m_pNext->m_pNext = nullptr; // 自动释放？设置的值会自己归零吗 auto to free ? don't need i to free?p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
pFind->m_pNext = pFind->m_pNext->m_pNext; // 链接这个个节点和它的下下一个节点,
// free a pointer p, p will be a random value? it won't change, *p will be a random value?
}
}
//pFind = pFind->m_pNext; // 不相等就是没找到，就移到下一个节点下来再对比
}
// for(pFind = head;pFind!= nullptr;pFind = pFind->m_pNext;){
// // if next=!nullptr
// // pPre = p;
// if(toInsertAfterIt == pFind->m_value){ // 不相等就回到for 条件步进那
// // pFind->m_pNext->m_value = 0; // restore default value
// // p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// // p->m_pNext->m_pNext = nullptr; // 自动释放？设置的值会自己归零吗 auto to free ? don't need i to free?p->m_pNext = p->m_pNext->m_pNext;
// // // 链接上一个节点和下一个节点
// p->m_pNext = pFind->m_pNext->m_pNext; // 链接这个个节点和它的下下一个节点,
// // free a pointer p, p will be a random value? it won't change, *p will be a random value?
// for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
// cout << p->m_value << " "; // 打印删除后的结果
// }
// cout << endl;
// }
// //pFind = pFind->m_pNext; // 不相等就是没找到，就移到下一个节点下来再对比
// }
// }
// if want to delete a node，find next node value,
// that easier to process need to delete node, and link previous node and next node of to delete node
// 不容易判断是否是最后一个节点，if(toDeleteNumber == pFind->m_value){
// pFind->m_value = 0; // restore default value
// p->m_pNext = p->m_pNext->m_pNext;
// p->m_pNext->m_pNext = nullptr; // auto to free ? don't need i to free?
// // free a pointer p, p will be a random value? it won't change, *p will be a random value?
// for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
// cout << p->m_value << " ";
// }
// cout << endl;
// }
// for(pFind = head; *pFind->m_pNext->m_value == toDeleteNumber && pFind!= nullptr; pPrevioud = pFind && pFind = pFind->m_pNext){
// 太长看的记不住
// 保存上一个节点的指针，方便删除当前节点，for循环第三句可以做两个事情吗--多半不行-没怎么见过-看答案，保存当前节点的指针，寻找指针指向下一个节点
// 一种写法是while, 在循环内保存previous节点指针
// for(pFind = head; *pFind->m_value == toDeleteNumber && pFind!= nullptr; pPrevioud = pFind && pFind = pFind->m_pNext){
// pFind = head;
// while(pFind!= nullptr){
// if(toDeleteNumber == pFind->m_value){
// delete pFind;
// link next node to previous node
// break; // 中止吗？
// }
// pPrevious = pFind;
// }
// for(pFind = head;pFind!= nullptr;pFind = pFind->m_pNext;){
// // if next=!nullptr
// // pPre = p;
// if(toDeleteNumber == pFind->m_value){ // 不相等就回到for 条件步进那
// // pFind->m_pNext->m_value = 0; // restore default value
// // p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// // p->m_pNext->m_pNext = nullptr; // 自动释放？设置的值会自己归零吗 auto to free ? don't need i to free?p->m_pNext = p->m_pNext->m_pNext; // 链接上一个节点和下一个节点
// p->m_pNext = p->m_pNext->m_pNext; // 链接这个个节点和它的下下一个节点,
// // free a pointer p, p will be a random value? it won't change, *p will be a random value?
// for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
// cout << p->m_value << " "; // 打印删除后的结果
// }
// cout << endl;
// }
// //pFind = pFind->m_pNext; // 不相等就是没找到，就移到下一个节点下来再对比
// }
// for 是否可以把不相等放在条件内，如果在循环体内相等了，退出就行:可以，不过下面再判断一次指向的值不等于要删除的值更保险
// not found
// if(pFind->m_value != toDeleteNumber && pFind->m_pNext == nullptr){
// 现在应该是输出这个条件了。指针值已经是0了。
if(pFind == nullptr){
cout << "nullptr" << endl;
}
}
// want to save it to a vector
for(p==head; p->m_pNext != nullptr; p= p->m_pNext){
cout << p->m_value << " "; // 打印删除后的结果
}
cout << endl;
return 0;
}
智能指针能用cout输出吗
要改成这样吗？
/*
讯飞星火
#include
#include
using namespace std;
struct ListNode {
int val;
unique_ptr next;
ListNode(int x) : val(x), next(nullptr) {}
};
int main() {
auto head = make_unique(0); // 初始化head节点
auto p = make_unique(1); // 初始化p节点
auto pFind = make_unique(2); // 初始化pFind节点
if (!p || !head || !pFind) {
cout << "create head or p or pFind failed," << "head:" << head.get() << ",p:" << p.get()
<< ",pFind:" << pFind.get() << endl;
} else {
cout << "All nodes created successfully." << endl;
}
return 0;
}
讯飞星火大模型
ListNode(int x) : val(x), next(nullptr) {} 是 C++ 中一个构造函数的定义，用于初始化 ListNode 对象。具体来说：
ListNode(int x) 是一个构造函数，接受一个整数参数 x。
val(x) 表示将传入的参数 x 赋值给成员变量 val。
next(nullptr) 表示将成员变量 next 初始化为空指针（即 nullptr）。
这个构造函数的作用是创建一个 ListNode 对象，并初始化其 val 和 next 成员。
为什么需要 0？
在代码 auto head = make_unique(0); 中，make_unique(0) 创建了一个 ListNode 对象，并将其值初始化为 0。这里的 0 只是一个示例值，你可以根据需要将其替换为任何整数值。例如：
cpp
复制代码
auto head = make_unique(5); // 创建一个值为5的节点
没有 0 行不行？
如果没有提供初始值，编译器会报错，因为 ListNode 的构造函数需要一个整数参数。例如：
cpp
复制代码
auto head = make_unique(); // 错误：缺少必要的参数
这会导致编译错误，因为 ListNode 的构造函数没有默认参数。因此，必须提供一个整数参数来初始化 ListNode 对象的 val 成员。
完整示例
以下是一个完整的示例，展示如何定义和使用 ListNode 类及其构造函数：
cpp
复制代码
#include
#include
using namespace std;
struct ListNode {
int val;
unique_ptr next;
ListNode(int x) : val(x), next(nullptr) {}
};
int main() {
auto head = make_unique(0); // 创建一个值为0的节点
cout << "Head node value: " << head->val << endl; // 输出节点的值
return 0;
}
在这个示例中，我们定义了一个简单的链表节点结构 ListNode，并通过 make_unique(0) 创建了一个值为 0 的头节点。
*/
改成原始指针？
terminal 命令行终端
怎样从vscode工程中移除一个文件，只留一个文件供编译
两个#加一个空格就是能变2级标题
c++ 里用new, 不用malloc了吧
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
