leetcode链表 2021-01-30

最新推荐文章于 2024-08-08 12:10:54 发布

涛&宇

最新推荐文章于 2024-08-08 12:10:54 发布

阅读量101

点赞数

分类专栏：学习笔记文章标签：链表列表指针 leetcode 算法

本文链接：https://blog.csdn.net/weixin_43111836/article/details/113447402

版权

学习笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

这篇博客探讨了链表操作的几种常见问题，包括删除链表中的节点、找到链表的中间节点以及将二进制链表转换为整数。通过提供不同方法的实现，如快慢指针法和递归，深入解析了这些算法的思路和优化。同时，还介绍了从头到尾打印链表的解决方案。这些内容对于理解和提升链表操作的技巧非常有帮助。

摘要由CSDN通过智能技术生成

题目237.删除链表中的结点

/**
class Solution {
    public void deleteNode(ListNode node) {
        node.val=node.next.val;
        node.next=node.next.next;
    
    
    }
}

题目876.链表的中间节点

定义一个指向当前节点的curr指针，如果curr不为空，则把值传到列表中，循环结束后判断列表长度，奇数则n/2+1，偶数也为n/2+1，返回该节点的值。对head进行后移n/2+1位操作返回

- ```java
  /**
   * Definition for singly-linked list.
 * public class ListNode {
   *     int val;
   *     ListNode next;
   *     ListNode(int x) { val = x; }
   * }
   */
  class Solution {
      public ListNode middleNode(ListNode head) {
         /* //方法一：利用数组
          List<Integer> list=new ArrayList<>();
          ListNode curr=head;
          while(curr!=null){
              list.add(head.val);
              curr=curr.next;
          }
          int n=list.size()/2+1;
          for(int i=0;i<n-1;i++){
              head=head.next;
          }
          return head;*/
          //方法二：遍历两边链表
          /*ListNode curr=head;
          int n=0;
          while(curr!=null){
              curr=curr.next;
              n++;
          }
          for(int i=0;i<n/2;i++){
              head=head.next;
          }
          return head;*/
          //方法三：快慢指针法
          //慢指针走一步，快指针走两步。
          ListNode fast=head;
          ListNode slow=head;
          while(fast!=null&&fast.next!=null){
              fast=fast.next.next;
               slow=slow.next;
          }
          return slow;
      }
  }




# 题目1290.二进制链表转整数

```java

```java
- 递归；递归结束条件为curr==null时返回0；

- 上一轮的返回值加上这一轮head的权重。需统计head的长度。

- ``

  /**
   * Definition for singly-linked list.
   * public class ListNode {
   *     int val;
   *     ListNode next;
   *     ListNode(int x) { val = x; }
   * }
   */
  class Solution {
      public int getDecimalValue(ListNode head) {
          
         /* List<Integer> list=new ArrayList<>();
          ListNode curr=head;
          //先统计链表长度
          while(curr!=null){
              list.add(curr.val);
              curr=curr.next;
          }
          int n=list.size();
          //对链表计数
          int Index=n-1,ans=0;
          while(Index>=0){
              if(head.val==1){
                  if(Index==0) ans+=1;
                      else ans+=Math.pow(2,Index);   
              }
              head=head.next;
              Index--;
          }
          return ans;*/
  
          //递归结束条件，递归速度很慢，性能不够优越。
          if(head==null) return 0;
          //考虑递归,递归同样需要链表长度。
          List<Integer> list=new ArrayList<>();
          ListNode curr=head;
          //先统计链表长度
          while(curr!=null){
              list.add(curr.val);
              curr=curr.next;
          }
          int n=list.size();
          double ans=0;
          if(head.val==1)
          ans=Math.pow(2,n-1)+getDecimalValue(head.next);
          else ans=getDecimalValue(head.next);
          return (int)ans;
      }
  }

题目剑O06.从头到尾打印链表

- ```java
  /**
   * Definition for singly-linked list.
 * public class ListNode {
   *     int val;
   *     ListNode next;
   *     ListNode(int x) { val = x; }
   * }
   */
  class Solution {
      public int[] reversePrint(ListNode head) {
          List<Integer> list=new ArrayList<>();
          while(head!=null){
              list.add(head.val);
              head=head.next;
          }
          int[] nums=new int[list.size()];
          for(int i=list.size()-1;i>=0;i--){
              nums[list.size()-1-i]=list.get(i);
          }
          return nums;
      }
  }