代码随想录刷题Day3

最新推荐文章于 2024-07-05 14:56:47 发布

kxm_lzu

最新推荐文章于 2024-07-05 14:56:47 发布

阅读量214

点赞数 2

文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/kxm_lzu/article/details/136307472

版权

本文介绍了在Java中处理链表的三个基础题目，包括移除指定值的元素、设计链表实现基本操作以及反转链表。作者强调了使用虚拟头节点和正确处理链表遍历、插入和删除的方法。

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

代码随想录刷题Day3

203-移除链表元素
707-设计链表
206-反转链表

今天是链表的基础题目，还好自己都做出来了。对于链表的题目，自己比较习惯于设置虚拟头结点的方式，这样不用单独考虑头节点的情况。

203-移除链表元素

策略很简单，就是遍历链表，然后找到符合条件的元素进行删除。
注意点就是链表删除一定要注意需要用一个指针指向前一个元素。

/**
 * Definition for singly-linked list.
 * public 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) {
        // 创建一个空的头结点，指向head
        ListNode head1 = new ListNode(0, head);
        
        ListNode front = head1;
        ListNode back = head;

        while(back != null){
            if(back.val == val){
                front.next = back.next;
                back = back.next;
            }else{
                front = back;
                back = back.next;
            }
        }
        return head1.next;
    }
}

707-设计链表

这就完全考验链表基本操作了。
需要注意的是：在某个索引位置添加，删除元素时，需要设置一个count变量来记录元素的位置，且和p指针要对应起来


// class ListNode{
//     int val;
//     ListNode next;

//     public ListNode(){
//     }
    
//     public ListNode(int val){
//         this.val = val;
//     }
    
// }

class MyLinkedList {

    ListNode head;

    public MyLinkedList() {
        head = new ListNode();
    }
    
    public int get(int index) {
        int count = 0;
        ListNode p = head.next;
        while(p != null){
            if(count == index){
                return p.val;
            }
            p = p.next;
            count++;
        }
        return -1;
    }
    
    public void addAtHead(int val) {
        ListNode l = new ListNode(val);
        ListNode l1 = head.next;
        head.next = l;
        l.next = l1;
    }
    
    public void addAtTail(int val) {
        ListNode p = head;
        while(p.next != null){
            p = p.next;
        }
        ListNode l = new ListNode();
        l.val = val;
        p.next = l;
        p.next.next = null;
    }
    
    public void addAtIndex(int index, int val) {
        int count = 0;
        ListNode p = head.next;
        ListNode front = head;
        while(p != null){
            if(count == index){
                front.next = new ListNode(val);
                front.next.next = p;
                return;
            }else{
                front = p;
                p = p.next;
                count++;
            }
        }

        if(count == index){
             front.next = new ListNode(val);
             front.next.next = null;
        }

    }
    
    public void deleteAtIndex(int index) {
        int count = 0;
        ListNode p = head.next;
        ListNode front = head;
        while(p != null){
            if(count == index){
                front.next = p.next;
                return;
            }else{
                front = p;
                p = p.next;
                count++;
            }
        }


    }
}

206-反转链表

可以说是很基本，也常遇到的题目了。
关键点在于：需要left， p 和right三个指针，初始化为left为null, p为首元素，right为p.next,然后不断遍历反转，具体看代码

/**
 * Definition for singly-linked list.
 * public 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 reverseList(ListNode head) {
        if(head == null)return null;
        ListNode left = null;
        ListNode p = head;
        ListNode right = p.next;
        while(right != null){
            p.next = left;
            left = p;
            p = right;
            right = right.next;
        }
        p.next = left;
        return p;

    }
}