Day03算法| 203.移除链表元素 707.设计链表 206.反转链表

最新推荐文章于 2024-11-12 18:31:40 发布
最新推荐文章于 2024-11-12 18:31:40 发布
阅读量1k 收藏 32
点赞数 24
分类专栏： 算法 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53770893/article/details/135875195
版权
本文详细介绍了如何在Java中创建单链表，包括节点类的设计，链表类的实现，以及删除元素（移除满足条件的节点）的方法，同时探讨了双指针法和递归法来反转链表。
摘要由CSDN通过智能技术生成

创建单链表

1.首先需要一个节点类，基础的包括值与next属性（双链表需要prev属性），并实例化：

class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 }

 2.基于节点类，创建链表类，这其中可以包含各种属性，类似头结点，尾结点，编号之类

class MyLinkedList {
	    int size;
	    ListNode head;

	    public MyLinkedList() {
	        size = 0;
	        head = new ListNode(0);
	    }
}

 3.在链表类中可以创建各种方法用以实现增删改查以及输出的功能，具体实现在第二题中展开

203.移除链表元素

文章讲解/视频讲解：代码随想录

题目链接：力扣题目链接

 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。其实类似于基础增删改查中的删除功能。

思路：空链表直接返回；删头结点分两种（直接删，创建虚拟头结点删），其余pre.next=cur.next

三种方法:

  • 直接使用原来的链表来进行删除操作。
  • 设置一个虚拟头结点在进行删除操作。
  • 链表的定义具有递归的性质，因此链表题目常可以用递归的方法求解。
/**
 * 添加虚节点方式
 */
public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
    ListNode dummy = new ListNode(-1, head);
    ListNode pre = dummy;
    ListNode cur = head;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}
/**
 * 不添加虚拟节点方式
 */
public ListNode removeElements(ListNode head, int val) {
    while (head != null && head.val == val) {
        head = head.next;
    }
    // 已经为null，提前退出
    if (head == null) {
        return head;
    }
    // 已确定当前head.val != val
    ListNode pre = head;
    ListNode cur = head.next;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return head;
}

 还能采取递归的方法：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }
}

707.设计链表

文章讲解：代码随想录

题目：力扣题目链接 

题目要求实现增删改查

我的思路：

1.首先确定 单双链表，我选择使用单链表，并将编号作为结点的属性，而非链表的属性（我与答案的不同），并使用（直接）头结点（first）与（直接）尾结点（last）：

结点类：

//节点
class Node
{
	int val;
	int index;
	Node next;
	public Node() {
		super();
	}
	public Node(int val) {
		super();
		this.val = val;
		
	}
	public Node(int data,int index) {
		super();
		this.val = data;
		this.next = null;
		this.index=index;
	}
}

链表类：

//链表类
class MyLinkedList {
	public Node first;//头结点
	public Node last;//尾结点

	public boolean isEmpty()
	{
		return first==null;
	}
	//将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
	public void addAtTail(int val)
	{
		//创建作为需要插入的节点
		Node newn=new Node(val);
		//插头节点
		if(this.isEmpty())
		{
			newn.index=0;
			first=newn;//头结点指向
			last=newn;//尾结点指向
		}
		//插到尾部
		else
		{
			newn.index=last.index+1;
			last.next=newn;
			last=newn;
		}
	}
	//将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    public void addAtHead(int val) {
    	//创建作为需要插入的头节点
    	Node newn=new Node(val,0);
    	newn.next=first;//插到头部
    	Node temp=first;
		first=newn;//将头指针指向新的头结点
		if(last==null)last=newn;//若原链表为空则将尾指针指向新节点
		//处理中部的序号问题
		while(temp!=null) {
			temp.index+=1;
			temp=temp.next;
		}
    }
	
	获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
	public int get(int index) {
		//非空链表
		if(!this.isEmpty())
		{
			Node temp=first;//从头开始循环
			while(temp!=null) {
				if(temp.index==index) {
					return temp.val;
				}
				temp=temp.next;
			}
			
		}
		return -1;
    }
	
//    将一个值为 val 的节点插入到链表中下标为 index 的节点之前。(取代index节点)
//    如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。
//    如果 index 比长度更大，该节点将 不会插入 到链表中。
    public void addAtIndex(int index, int val) {
    	Node newn=new Node(val,index);
    	if(this.isEmpty()&&index>=1)
    	{
    		return;
    	}
    	else if(index==0)
    	{
    		this.addAtHead(val);
    	}
    	else if(last.index<index-1)
    	{
    		return;
    	}
    	else if(last.index==index-1) {
    		this.addAtTail(val);
    	}
    	else {
    		Node temp=first;
    		while(temp!=null)
    		{
    			if(temp.index==index-1)
    			{
    				newn.next=temp.next;
    				temp.next=newn;
    				temp=temp.next.next;
    				break;
    			}
    			temp=temp.next;
    		}
    		while(temp!=null)
    		{
    			temp.index+=1;
    			temp=temp.next;
    		}
    	}
    }
//    如果下标有效，则删除链表中下标为 index 的节点。
    public void deleteAtIndex(int index) {
    	if (this.get(index)!=-1) {
    		Node tmp=first;
    		if(first.index==index)//删表头
    		{
    			first=first.next;
    			tmp=first;
    		}
    		else if(last.index==index)//删表尾
    		{
    			Node newNode=first;
    			while(newNode.next!=last) newNode=newNode.next;
    			last=newNode;
    			newNode.next=null;
    			tmp=last.next;
    		}
    		else
    		{
    			Node newNode=first;
    			while(newNode.index<index)
    			{
    				tmp=newNode;
    				newNode=newNode.next;
    			}
    			tmp.next=newNode.next;
    			tmp=tmp.next;
    		}
    		while(tmp!=null) {
				tmp.index-=1;
				tmp=tmp.next;
			}
		}
    }
  //输出
  	public void print ()
  	{
  		Node a=first;
  		while(a!=null)
  		{
  			System.out.print("("+a.index+")"+a.val+"  ");
  			a=a.next;
  		}
  	}
}

官方解答：

单链表：

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

双链表：

//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.head;
        //判断是哪一边遍历时间更短
        if(index >= size / 2){
            //tail开始
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}

206.反转链表

文章讲解：代码随想录

题目：力扣题目链接

 

题意：反转一个单链表。

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

两种思路：（这里引用一下动画）

双指针法：

​

// 双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}

 

递归法 ：

相当于用递归帮忙记住了上一个是谁，那么问题是我是谁，下一个是谁？第一行的if判断，是两种临界情况，第一种是头结点为空，不用管；第二种是没有下一个了，只用知道我是谁，直接返回就行。下面的几行代码，我明显是head，下一个就是head->next，由于要反转链表，我的下一个要变成我的上一个，因此head->next->next = head，我的上一个（递归）等到这层递归出去再解决。可以看到newHead在递归结束返回后是没有进行任何操作的，也就是返回的是最底层的那个，起到传递尾（新首）结点的作用

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

其中双指针：

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。

  • 空间复杂度：O(1)。

 递归：

时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。

空间复杂度：O(n)，其中 n是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n 层。

数据结构与算法.md
02-04
### 数据结构与算法知识点 #### 一、线性结构与非线性结构 在计算机科学领域，数据结构被划分为两大类：线性结构和非线性结构。 1. **线性结构**： - 特征：数据元素之间存在一对一的关系。 - 常见类型包括：...
leetcode2-Algorithm-swift:记录一下，算法学习
06-29
leetcode 2 Algorithm-swift 记录一下，算法学习 ...移除链表元素 206、反转链表 215. 数组中的第K个最大元素 221. 最大正方形 236. 二叉树的最近公共祖先 237. 删除链表中的节点 354. 俄罗斯套娃信封问题 393
数据结构航空客运订票系统实验报告.doc
03-08
数据结构航空客运订票系统实验报告主要探讨了如何利用数据结构设计一个航空客运订票系统。在这个系统中，数据结构是实现关键功能的基础，主要包括队列、链表和结构体等概念。 首先，实验目标强调了对VC++编程环境的...
7DaysPerTopicChallenge-Day1-Linked-list
03-20
链表是一种基础且重要的数据结构，在计算机科学中广泛应用于各种算法和程序设计中。在这个“7DaysPerTopicChallenge-Day1-Linked-list”挑战中，我们将深入探讨链表的基本概念、类型、操作以及其在实际问题中的应用...
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 489
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 243
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1290
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 59
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 1245
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
二分查找习题篇(上)
zoelinkailuo的博客
11-07 1014
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
AI 写作（三）文本生成算法：创新与突破（3/10）
小相探索IT世界
11-08 1769
本文深入探讨了 AI 写作中的多种文本生成算法。首先介绍了生成式与判别式模型的区别与特点，包括优化准则、对观察序列的处理、训练复杂度以及支持的训练方式等方面的差异，并对比了它们在 AI 写作中的优缺点。接着详细阐述了长短期记忆网络（LSTM）在文本生成中的应用，包括技术原理与结构、实现步骤与流程以及应用示例与效果。还深入分析了 Transformer 与自注意力机制，介绍了其模型架构与组成、自注意力机制的作用以及在 AI 写作中的重要作用。
数组类算法【leetcode】
随便写写
11-07 383
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
以太坊系地址衍生算法分层确定性生成逻辑
J_Lee
11-12 183
以太坊系地址衍生算法分层确定性生成逻辑
LeetCode题练习与总结：迷你语法分析器--385
一直学习永不止步
11-09 540
本文详细介绍了如何解析整数嵌套列表字符串并返回 NestedInteger 对象的解题思路和具体实现。涉及知识点包括字符串处理、栈的使用、递归逻辑等，时间复杂度为 O(n)，空间复杂度也为 O(n)。
程序设计方法与实践-变治法
最新发布
MaverickCoder的博客
11-12 620
变治法就是基于变换的思路，进而使原问题的求解变得简单的一种技术。
算法通关（4）-- 前缀树
2301_79985750的博客
11-07 1016
前缀树（Trie树），也称为字典树，是一种用于的数据结构。它是一种树形结构，能够利用字符串的公共前缀来减少存储空间和查询时间。现在有“acb”,"cba","acc"，"ac"四个字符串，利用这四个字符串构出一颗前缀树。根节点不包含任何字符，是所有字符串的公共前缀；每个节点包含pass信息，代表加节点的时候路过了几次，还有一个end信息表示多少个字符串是以当前字符串结尾的。举个例子：插入完成后得到的树形结构：那么现在问：字符串acb出现了几次。
100种算法【Python版】第59篇——滤波算法之扩展卡尔曼滤波
AnFany
11-08 147
100种算法【Python版】第59篇——滤波算法之扩展卡尔曼滤波
三天精通一种算法之移除数组元素（暴力）（双指针）
ghw666666的博客
11-11 100
/ 如果当前元素不等于 val，则将其复制到 nums[k] 的位置，并增加 k。// 将 nums 的长度设置为 k，这样数组中多余的部分就被删除了。// 初始化 k，用于记录非 val 元素的索引。// 遍历 nums 数组。// 返回修改后的数组。代码随想录另一种算法。
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值等于`val`的节点。解题的关键在于处理可能的头节点删除情况。通过在链表的头节点前添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值