代码随想录DAT3|链表|203移除链表元素、707设计链表、206反转链表

于 2024-04-20 22:03:19 发布
阅读量736 收藏 25
点赞数 14
分类专栏： 算法训练 文章标签： 链表 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43388723/article/details/138012134
版权

文章目录

前言

补卡，突然接受一个新的stl容器，写法还不熟练，花了很多时间看懂代码，慢慢熟练链表写法
详细的包含main函数的代码，小白可直接在vs运行~

零、链表操作指南

1.判断不为空指针

对于需要操作的元素，牢记先while()判断是否为空;
索引的index，循环之前要判断是否超出范围

2.对于循环遍历

2.1 int i – >创建遍历的指针 ListNode*cur
2.2 i
2.3 i++ --> cur=cur->next

3.释放链表元素

ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
tmp = nullptr;

4.创建新节点

4.1 newNode

ListNode* newNode = new ListNode(val);

4.2 dummyHead

ListNode* dummyhead = new ListNode(0);
dummyhead->next = head;

数据和指针都要考虑到

5.初始化链表

ListNode* head = new ListNode(1);
	head->next = new ListNode(2);
	head->next->next = new ListNode(6);
	head->next->next->next = new ListNode(3);
	head->next->next->next->next = new ListNode(4);
	head->next->next->next->next->next = new ListNode(5);
	head->next->next->next->next->next->next = new ListNode(6);

6.输出链表

void printListNode(ListNode* head) {
	ListNode* cur = head;
	while (cur != nullptr) {
		cout << cur->val << " ";
		cur = cur->next;
	}
	cout << endl;
}

7.定义链表节点

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) :val(x), next(nullptr) {}
};

8.链表操作技巧

  1. cur指向需要操作（删除、在前面插值）元素前一位

一、203移除链表元素

文档&视频讲解：代码随想录

1. 题目

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

2. 思路

两个思路：

  1. 直接对原链表操作
    1.1 若val是头节点时，head->next为头节点
    1.2 若不为头节点，若为target，删除；若不为，向后遍历
  2. 增加虚拟头节点
    创建dummyhead，后同1.2
    ``

3. 代码实现

//Time：2024/4/19训练营跟练
//Time：2024/4/19
//1. 节点构造函数
//

#include<iostream>
#include<list>

using namespace std;

//构造链表，两个变量，一个内容，一个指针
struct ListNode {
	int val;
	ListNode* next;
	ListNode(int x):val(x),next(nullptr){}
};

class Solution {
public:
	ListNode* removeElements(ListNode* head, int val) {

		//创建虚拟头指针
		ListNode* dummyhead = new ListNode(0);
		dummyhead->next = head;//和头指针连接起来

		//只要开始遍历链表，就用cur代替开始遍历的起点
		ListNode* cur = dummyhead;

		//开始遍历判断之前，要先确定指针不为空
		while (cur!= nullptr&&cur->next!=nullptr) {
			if (cur->next->val == val) {

				//具体操作之前，定义临时指针，方便后续释放内存
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		//直接返回dummyhead不对，因为dummyhead的值没有改变，并不是原链表
		//return dummyhead;
		return dummyhead->next;
	}
};

//打印链表
void printListNode(ListNode* head) {
	ListNode* cur = head;
	while (cur != nullptr) {
		cout << cur->val << " ";
		cur = cur->next;
	}
	cout << endl;
}


int main() {

	//定义函数实参
	//初始化链表
	ListNode* head = new ListNode(1);
	head->next = new ListNode(2);
	head->next->next = new ListNode(6);
	head->next->next->next = new ListNode(3);
	head->next->next->next->next = new ListNode(4);
	head->next->next->next->next->next = new ListNode(5);
	head->next->next->next->next->next->next = new ListNode(6);

	//val是要删除的元素
	int val = 6;

	Solution solution;
	ListNode* result = solution.removeElements(head, val);

	printListNode(result);

	//释放链表内存
   //cur是索引，tmp是临时引用，为了释放内存
	ListNode* cur = result;
	while (cur != nullptr) {
		ListNode* tmp = cur;
		cur = cur->next;
		delete tmp;
	}

	return 0;
}

二、707设计链表（需要补一些小技巧奥&自己代码运行有点小问题，貌似是索引不对

文档&视频讲解：代码随想录

1. 题目

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

2. 思路

画图
还有一些小技巧，等有时间补

3. 代码实现

//Time：2024/4/19训练营跟练
#include<iostream>
#include<list>

using namespace std;

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct ListNode {
        int val;
        ListNode* next;
        ListNode(int x) :val(x), next(nullptr) {}
    };

    // 初始化链表
    MyLinkedList() {
        dummyHead = new ListNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (size - 1) || index < 0) {
            return -1;
        }
        ListNode* cur = dummyHead->next;
        while (index--) { // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        ListNode* newNode = new ListNode(val);
        newNode->next = dummyHead->next;
        dummyHead->next = newNode;
        size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        ListNode* newNode = new ListNode(val);
        //ListNode* cur = dummyHead;
        ListNode* cur = dummyHead->next;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newNode;
        size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if (index > size) return;
        if (index < 0) index = 0;
        ListNode* newNode = new ListNode(val);
        ListNode* cur = dummyHead;
        while (index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        ListNode* cur = dummyHead;
        while (index--) {
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp = nullptr;
        size--;
    }

    // 打印链表
    void printLinkedList() {
        ListNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int size;
    ListNode* dummyHead;

};

int main() {
    MyLinkedList myLinkedList;
    cout << "初始化的列表: ";
    myLinkedList.printLinkedList();

    myLinkedList.addAtHead(1);
    cout << "addAtHead: ";
    myLinkedList.printLinkedList();

    myLinkedList.addAtTail(3);
    cout << "addAtTail: ";
    myLinkedList.printLinkedList();

    myLinkedList.addAtIndex(1, 2);             // 链表变为 1->2->3
    cout << "addAtIndex（在索引1处添加val=2）: ";
    myLinkedList.printLinkedList();
    
    cout << "返回索引1的值: ";
    cout << myLinkedList.get(1) << endl;       // 返回 2
    cout << "get(1): ";
    myLinkedList.printLinkedList();

    myLinkedList.deleteAtIndex(1);             // 现在，链表变为 1->3
    cout << "deleteAtIndex: ";
    myLinkedList.printLinkedList();

    cout << "返回索引1的值: ";
    cout << myLinkedList.get(1) << endl;       // 返回 3  

    return 0;
}

三、206反转链表

文档&视频讲解：代码随想录

1. 题目

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

2. 思路

画图

3. 代码实现

//Time：2024/4/20训练营跟练
#include<iostream>
#include<list>

using namespace std;

struct ListNode {
		int val;
		ListNode* next;
		ListNode(int x):val(x),next(nullptr){}
	};

class Solution {
public:
	

	ListNode* reverseList(ListNode* head) {
		ListNode* pre = nullptr;
		ListNode* cur = head;
		//循环一次，反转一个指针
		while (cur!=nullptr) {
			ListNode* tmp = cur->next;

			//反转指针
			cur->next = pre;

			//pre和cur向后移动
			pre = cur;
			cur = tmp;
		}
		return pre;
	}

};



int main() {
	Solution solution;

	// 创建链表 1->2->3->4->5->NULL
	ListNode* head = new ListNode(1);
	head->next = new ListNode(2);
	head->next->next = new ListNode(3);
	head->next->next->next = new ListNode(4);
	head->next->next->next->next = new ListNode(5);

	// 反转链表
	ListNode* reversedHead = solution.reverseList(head);

	// 打印反转后的链表
	ListNode* cur = reversedHead;
	while (cur) {
		cout << cur->val << " ";
		cur = cur->next;
	}
	cout << "NULL" << endl;

	return 0;
}

总结

这次真的有点力不从心了，这60天我的执行方针要变成完成>完整了
(但是花时间在熟悉基础上，还是很有用的，后面可能不能保证完全自己写了，有些能copy的main()还是要copy，在题海中熟悉吧

还需复习：补充在设计链表部分的技巧

渝髨
关注
  • 14
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值