代码随想录第三天| 203.移除链表元素（LeetCode203）、 707.设计链表 （LeetCode707）、 206.反转链表 （LeetCode206）

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量136 收藏
点赞数 1
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64566993/article/details/131988029
版权

 203.移除链表元素  

        题目链接 ：203. 移除链表元素 - 力扣（LeetCode）

        代码随想录题目解析  ：移除链表元素

题目描述：

        给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 ：

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

 具体代码实现：

//虚拟头节点删除链表的节点

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

class Solution {
	
    public ListNode removeElements(ListNode head, int val) {
    	ListNode dummyhead = new ListNode();
    	dummyhead.next = head;
    	ListNode cur = new ListNode();
    	cur = dummyhead;
    	while(cur.next!=null){
    		if(cur.next.val == val)
    			cur.next = cur.next.next;
    		else cur = cur.next;
    	}
    	return dummyhead.next;
    }
    
}

public class Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length-1 ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    	}
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);


    	int val = Integer.parseInt(args[args.length-1]);  //确定待删除元素
    	Solution solution = new Solution();
    	// 调用 removeElements 方法删除节点
    	ListNode modifiedListhead = solution.removeElements(head,val);

    	// 打印修改后的链表
    	System.out.println("修改后的链表：");
    	printLinkedList(modifiedListhead);

	}

	//打印链表
	private static void printLinkedList(ListNode head1) {
		ListNode current = head1;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

 707.设计链表  

        题目链接：707. 设计链表 - 力扣（LeetCode）

        代码随想录题目解析： 设计链表

题目描述: 

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

具体代码实现：

单链表：


//单向链表
//设计链表
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);
    }
    public MyLinkedList(int size, ListNode head) {
        this.size = size;
        this.head = new ListNode(0);             //必须定义虚指针，才能进行操作
        this.head.next = head;
    }
    
    //获取第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 等于链表的长度，则说明是新插入的节点为链表的尾结点

    public void addAtIndex(int index, int val) {
        // 如果 index 大于链表的长度，则返回空
        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;
    }
}

public class single_Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length-1 ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    	}
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);


    	int index = Integer.parseInt(args[args.length-1]);  //确定待删除元素
    	MyLinkedList a = new MyLinkedList(args.length-1,head);
    	
    	// 调用方法
    	//打印获取获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    	int x = a.get(index);
    	System.out.println(x);

	}

	//打印链表
	private static void printLinkedList(ListNode head) {
		ListNode current = head;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

双向链表：


//双向链表
//设计链表

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 MyLinkedList(int size, ListNode head, ListNode tail) {
        //初始化操作
        this.size = size;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        this.head.next = head;
        this.tail.prev = tail;
    }
    
    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;
    }
}

public class double_Solution_text {
    public static void main(String[] args){
    	
    	ListNode head = new ListNode (Integer.parseInt(args[0]));  //先创建头指针	
    	head.prev = null;                                          //头指针之前为空
    	
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length-2 ; i++){                      //从主函数中传入参数创建列表
    		ListNode newListNode = new ListNode (Integer.parseInt(args[i]));         //创建新节点
    		cur.next = newListNode;
    		newListNode.prev = cur;
    		cur = newListNode;                                     //cur后移
    	}
    	ListNode tail = new ListNode (Integer.parseInt(args[args.length-2]));       //创建尾节点
    	cur.next = tail;                                                            //尾结点的下一位为空
    	tail.prev = cur;															//尾结点的上一位为cur刚才创建的节点，即i=args.length-2
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);


    	int index = Integer.parseInt(args[args.length-1]);  //确定待删除元素
    	MyLinkedList a = new MyLinkedList(args.length-1,head,tail);
    	
    	// 调用方法
    	//打印获取获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    	int x = a.get(index);
    	System.out.println(x);

	}

	//打印链表
	private static void printLinkedList(ListNode head) {
		ListNode current = head;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

 206.反转链表 

        题目链接 ：206. 反转链表 - 力扣（LeetCode）

        代码随想录题目解析：代码随想录反转链表

题目描述：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 ：

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

 具体代码实现：


//反转链表

 class ListNode {
	int val;
	ListNode next;
	ListNode() {}
    ListNode(int val) { this.val = val; }
	ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 }
 
 
//双指针法
 
class Solution1 {
	
    public ListNode reverseList(ListNode head) { 
    	ListNode cur = head;
    	ListNode pre = new ListNode ();
    	pre = null;
    	while(cur != null){
    		ListNode temp = cur.next ;
    		cur.next = pre;
    		pre = cur;
    		cur = temp; 
    	}
    	return pre;

    }
    
}


//函数递归

class Solution2 {
	
    public ListNode reverseList(ListNode head) { 
    	return reverse(head,null);

    }

	private ListNode reverse(ListNode cur, ListNode pre) {
		if(cur == null)  return pre;
		ListNode temp = cur.next;
		cur.next = pre;
		return reverse(temp,cur);
	}
    
}

public class Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    	}
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);

    	// 打印修改后的链表
     	System.out.println("Solution1修改后的链表：");
    	Solution1 a = new Solution1();
    	ListNode result = a.reverseList(head);
    	printLinkedList(result);

     	System.out.println("Solution2修改后的链表：");
    	Solution2 b = new Solution2();
    	printLinkedList(b.reverseList(result));

	}

	//打印链表
	private static void printLinkedList(ListNode head1) {
		ListNode current = head1;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

        注意此处实现了两种转换的方式，一种为双链表法，一种为递归函数的方法，具体见代码。

原链表和两次翻转后的链表均打印出了。

        特别提醒的是在第二次实现反转的时候

    	Solution2 b = new Solution2();
    	printLinkedList(b.reverseList(result));

        result是第一次翻转后的返回值，即翻转后的头指针，这里做了保留。

千万不要写成以下格式

    	printLinkedList(b.reverseList(a.reverseList(head)));

该代码表面上 只执行了 b.reverseList(）一次，但实际上却执行了 a.reverseList(）和b.reverseList(）两次，原因是 a.reverseList(）不能作为固定的值，每次使用它时，都要执行一次。所以    printLinkedList(b.reverseList(a.reverseList(head)))    实际上等于    printLinkedList(head) 。所以    ListNode result = a.reverseList(head) ；     printLinkedList(b.reverseList(result))； 才是正确写法。

要动手啊
关注
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
xiaoxfan#leetcode#203. 移除链表元素1
07-25
示例:输出: 1->2->3->4->5方法一递归func removeElements(head *ListNode, val int) *ListNode
代码随想录day3 | LeetCode203. 移除链表元素、LeetCode707. 设计链表、LeetCode206. 反转链表
落雪的博客
08-16 1084
代码随想录day3 | LeetCode203. 移除链表元素、LeetCode707. 设计链表、LeetCode206. 反转链表 解决报错runtime error: member access within null pointer of type 'ListNode'
代码随想录算法训练营第三天|LeetCode203.移除链表元素 LeetCode707.设计链表 LeetCode206.反转链表
2301_79647020的博客
07-07 786
LeetCode203.移除链表元素LeetCode707.设计链表LeetCode206.反转链表
代码随想录训练营Day3|Leetcode 203.移除链表元素 Leetcode 707.设计链表 Leetcode 206.反转链表
littlesevenseven的博客
06-15 539
编程语言：C#链表定义。
代码随想录第3天|C++|链表|leetcode|203.移除链表元素|707.设计链表|206.反转链表
m0_74509890的博客
02-23 2387
链表的定义： 基本操作复杂度分析： 题目链接：203. 移除链表元素思路:本题是移除无头结点链表中所有指定val大小的元素，有两种思路(有无头结点都可使用1或2思路)1是通过创建临时变量temp存储将要删除的元素2是通过两个指针p,q动态移动，删除指定元素难点：由于无头结点，需要分开考虑最前面head为val和一般情况下中间值为val两种情况，以1思路为例：处理头指针时，当当前轮次前面head不为空且为val时才能删除head；处理中间值时，head位置已经确定，设current为head,若head后还有
代码随想录算法训练营第三天|LeetCode 203.移除链表元素 LeetCode 707.设计链表 LeetCode 206.反转链表
iwtup的博客
06-30 237
链表的相关知识和一些基本操作
代码随想录算法训练营第三天 | LeetCode203.移除链表元素、LeetCode707.设计链表、LeetCode206.反转链表
zhuabazhuabahuo的博客
10-01 920
但我总觉得这样浪费了空间，并且题目还说了可以用递归的方式去实现，因此花了近四十分钟去想递归的解法，之前算法课我觉得已经通透地掌握了递归，也就是把解法建立在递归的函数之上，但这道题一直没想出来咋递归而且看了代码随想录的递归之后还是百思不得其解，信心受挫！代码随想录提供的改变链表的next指针的指向，直接将链表反转的算法很有启发，在此基础上完成了递归的算法，但我一直无法理解这种递归，感觉像是为了递归而递归。：真正实现的时候由于c++不够熟练，花了相当长的时间去实现算法，但其实思路和代码随想录一致。
代码随想录-DAY3|203.移除链表元素、707.设计链表、206.反转链表
qq_40988139的博客
03-22 555
移除链表元素，设计链表，反转链表
代码随想录第三天|203.移除链表元素 707.设计链表 206.反转链表
qq_41692615的博客
12-31 194
代码随想录第三天|203.移除链表元素 707.设计链表 206.反转链表
代码随想录算法训练营第三天|203.移除链表元素、707.设计链表、206.反转链表
2402_84438596的博客
08-16 690
代码随想录算法训练营第三天|203.移除链表元素、707.设计链表、206.反转链表
代码随想录第三天|链表理论基础，LeetCode203.移除链表元素, LeetCode707.设计链表,LeetCode 206.反转链表
yec10的博客
05-27 1997
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。其实只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表。如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
bestlyg#bestlyg-leetcode#203.移除链表元素1
07-25
简介：删除链表中等于给定值val的所有节点。编辑时间：2020.2.13执行用时：1ms内存消耗：40.1MB编程语言：java解法介绍：创建新链表，遍历节点，
java-leetcode题解之第203题移除链表元素.zip
06-05
本题解集中关注的是LeetCode的第203题，即“移除链表元素”。这道题目主要涉及到链表操作，是数据结构中的基础概念，对于理解和解决实际问题具有重要意义。 链表是一种线性数据结构，它的每个元素（节点）包含数据...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 380
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 323
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1096
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1158
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 353
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值