LeetCode——链表

链表

链表类型:单链表(只有next指针)、双链表(pre指针和next指针)、循环链表(尾节点指向头节点)

增、删、改、遍历、翻转、交换

1.设计链表707中等

class LinkedNode {
    int val;
    LinkedNode next;
    public LinkedNode() {

    }
    public LinkedNode(int val) {
        this.val = val;
    }
}
class MyLinkedList {
    // 链表的长度
    private int size;
    // 链表的虚拟头节点和虚拟尾节点
    private LinkedNode head;


    public MyLinkedList() {
        size = 0;
        head = new LinkedNode(0);
    }
    
    public int get(int index) {
        if (index >= size) {
            return -1;
        }
        LinkedNode cur = head.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.val;

    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    public void addAtIndex(int index, int val) {
        // 检查要插入元素索引的范围
        if (index < 0 || index > size) {
            return;
        }
        size++;
        LinkedNode cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        LinkedNode newNode = new LinkedNode(val);
        newNode.next = cur.next;
        cur.next = newNode;

    }
    
    public void deleteAtIndex(int index) {
        // 检查要插入元素索引的范围
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        LinkedNode cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }
}

2.移除链表元素

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 定义虚拟头节点
        ListNode newhead = new ListNode(0, head);
        // pre表示前一个元素,为了删除元素后可以把链表串起来
        ListNode pre = newhead;
        // 循环链表的节点,判断该节点的值是否与val相等
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == val) {
                // cur = cur.next;
                // pre.next = cur;
                pre.next = cur.next;
            } else {
                pre = pre.next;
                // cur = cur.next;
            }
            cur = cur.next;
        }
        return newhead.next;
    }
}

3.删除链表的倒数第N个结点

//  // 先实现,写两次遍历,第一次记录链表的结点总个数,第二次删除;这里要防止第一次遍历结束后还能找到头
// class Solution {
//     public ListNode removeNthFromEnd(ListNode head, int n) {
//         // 第一次遍历
//         ListNode newhead = new ListNode (-1, head);
//         ListNode cur = head;
//         int count = 0;
//         // 第一次遍历
//         while (cur != null) {
//             count += 1;
//             cur = cur.next;
//         }
//         // 第二次遍历
//         // num记录要从前往后遍历到第几个位置
//         int num = count - n;
//         ListNode now = newhead;
//         while (num > 0) {
//             now = now.next;
//             num -= 1;
//         }
//         now.next = now.next.next;
//         return newhead.next;
//     }
// }


// // 双指针,快慢指针,第一个指针先走n步,第二个指针留在初始位置,那么当第一个位置走到链表尾部的时候,第二个指针就处在在删除的节点位置(如果加上虚拟头节点,就是走在了要删除节点的前一个节点上)
// class Solution {
//     public ListNode removeNthFromEnd (ListNode head, int n) {
//         // 定义一个虚拟头节点
//         ListNode newhead = new ListNode(-1, head);
//         // 定义第一个节点
//         ListNode first = head;
//         // 定义第二个节点
//         ListNode second = newhead;
//         int i = 0;
//         while (i < n) {
//             i ++;
//             first = first.next;
//         }
//         while (first != null) {
//             first = first.next;
//             second = second.next;
//         }
//         // 删除节点
//         second.next = second.next.next;
//         return newhead.next;
//     }
// }


// 栈
class Solution {
    public ListNode removeNthFromEnd (ListNode head, int n) {
        // 定义虚拟头节点
        ListNode newhead = new ListNode (-1, head);
        // 定义栈
        Deque<ListNode> stack = new LinkedList<ListNode>();
        ListNode cur = newhead;
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        for (int i = 0; i < n; i ++) {
            stack.pop();
        }
        // stack.peek()检索到栈顶元素并获取到,但是不会被删除
        ListNode prev = stack.peek();
        prev.next = prev.next.next;
        return newhead.next;
    }
}

4.两两交换链表中的节点24中等

重点是要一直链起来,不要忽略某个步骤断掉链表

class Solution {
    public ListNode swapPairs(ListNode head) {
        // 定义一个虚拟头节点
        ListNode newhead = new ListNode(-1, head);
        // 一个节点一个节点进行遍历
        ListNode cur = newhead;
        while (cur.next != null && cur.next.next != null) {
            ListNode bef = cur.next;
            ListNode aft = cur.next.next;
            // 交换
            cur.next = aft;  // 链住
            bef.next = aft.next;  // 交换
            aft.next = bef;
            cur = bef;

        }
        return newhead.next;
    }
}

5.相交链表160简单

// class Solution {
// public:
//     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
//         // 使用哈希表存储节点。首先遍历链表A,将A中的节点存入哈希表,遍历链表B,如果B中的节点在哈希表中,之后的所有节点都要在hash表中;如果不在,继续遍历B的下一个节点
//         // 定义以节点为元素的hash表
//         unordered_set<ListNode *> visited;
//         ListNode *temp = headA;
//         while (temp != nullptr) {
//             visited.insert(temp);
//             temp = temp -> next;
//         }
//         temp = headB;
//         while (temp != nullptr) {
//             if (visited.count(temp)) {
//                 return temp;
//             }
//             temp = temp -> next;
//         }
//         return nullptr;
//     }
// };


class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 双指针,利用相遇的时候两个指针应该走过一样的步数
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        ListNode *pA = headA;
        ListNode *pB = headB;
        while (pA != pB) {
            if (pA == nullptr) {
                pA = headB;
            } else {
                pA = pA->next;
            }
            if (pB == nullptr) {
                pB = headA;
            } else {
                pB = pB->next;
            }
        }
        return pB;
    }
};

【未完待续……】

总结:

如果由遍历且修改的需求,虚拟头接带你好使

链表要链起来始终

找规律,有没有简单实现的方法,例如反转链表,是不是头插法就很合适

思想:双指针!排序的话归并!

  • 16
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Rust 是一种现代的编程语言,特别适合处理内存安全和线程安全的代码。在 LeetCode 中,链表是经常出现的题目练习类型,Rust 语言也是一种非常适合处理链表的语言。接下来,本文将从 Rust 语言的特点、链表的定义和操作,以及 Rust 在 LeetCode链表题目的练习等几个方面进行介绍和讲解。 Rust 语言的特点: Rust 是一种现代化的高性能、系统级、功能强大的编程语言,旨在提高软件的可靠性和安全性。Rust 语言具有如下几个特点: 1. 内存安全性:Rust 语言支持内存安全性和原语级的并发,可以有效地预防内存泄漏,空悬指针以及数据竞争等问题,保证程序的稳定性和可靠性。 2. 高性能:Rust 语言采用了“零成本抽象化”的设计思想,具有 C/C++ 等传统高性能语言的速度和效率。 3. 静态类型检查:Rust 语言支持静态类型检查,可以在编译时检查类型错误,避免一些运行时错误。 链表的定义和操作: 链表是一种数据结构,由一个个节点组成,每个节点保存着数据,并指向下一个节点。链表的定义和操作如下: 1. 定义:链表是由节点组成的数据结构,每个节点包含一个数据元素和一个指向下一个节点的指针。 2. 操作:链表的常用操作包括插入、删除、查找等,其中,插入操作主要包括在链表首尾插入节点和在指定位置插入节点等,删除操作主要包括删除链表首尾节点和删除指定位置节点等,查找操作主要包括根据数据元素查找节点和根据指针查找节点等。 Rust 在 LeetCode链表题目的练习: 在 LeetCode 中,链表是常见的题目类型,而 Rust 语言也是一个非常适合练习链表题目的语言。在 Rust 中,我们可以定义结构体表示链表的节点,使用指针表示节点的指向关系,然后实现各种操作函数来处理链表操作。 例如,针对 LeetCode 中的链表题目,我们可以用 Rust 语言来编写解法,例如,反转链表,合并两个有序链表,删除链表中的重复元素等等,这样可以更好地熟悉 Rust 语言的使用和链表的操作,提高算法和编程能力。 总之,在 Rust 中处理链表是非常方便和高效的,而 LeetCode 中的练习也是一个非常好的机会,让我们更好地掌握 Rust 语言和链表数据结构的知识。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值