在 O(1) 时间内删除链表节点、删除链表中的重复的节点、正则表达式匹配

最新推荐文章于 2022-08-15 16:07:23 发布

原创最新推荐文章于 2022-08-15 16:07:23 发布 · 395 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

笔记专栏收录该内容

85 篇文章

订阅专栏

本文介绍如何在O(1)时间内删除链表节点，并提供了解决方案。同时，探讨了删除链表中重复节点的方法，以及实现正则表达式匹配的算法。这些算法在数据结构和算法设计中具有重要作用。

在 O(1) 时间内删除链表节点

思路：

如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。

综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N ~ 2，因此该算法的平均时间复杂度为 O(1)。

public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
    if (head == null || tobeDelete == null)
        return null;
    if (tobeDelete.next != null) {
        // 要删除的节点不是尾节点
        ListNode next = tobeDelete.next;
        tobeDelete.val = next.val;
        tobeDelete.next = next.next;
    } else {
        if (head == tobeDelete)
             // 只有一个节点
            head = null;
        else {
            ListNode cur = head;
            while (cur.next != tobeDelete)
                cur = cur.next;
            cur.next = null;
        }
    }
    return head;
}

删除链表中的重复的节点

题目：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。牛客链接
例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

思路：

判断pHead.val和next.val是否相等
相等：则循环，next往后移，找到不等于pHead.val的节点，返回值为递用deleteDuplication(next)
不相等：则pHead.next = deleteDuplication(pHead.next);

public class 删除链表中的重复的节点 {
    public ListNode deleteDuplication(ListNode pHead) {
        if(pHead==null || pHead.next==null){
            return pHead;
        }
        ListNode next=pHead.next;
        if(next.val==pHead.val){
            while(next!=null && pHead.val==next.val){
                next=next.next;
            }
            return deleteDuplication(next);
        }else {
            pHead.next=deleteDuplication(pHead.next);
            return pHead;
        }
    }
}

正则表达式匹配

题目：请实现一个函数用来匹配包括 ‘.’ 和 ‘’ 的正则表达式。模式中的字符 ‘.’ 表示任意一个字符，而 '’ 表示它前面的字符可以出现任意次（包含 0 次）。

在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 “aaa” 与模式 “a.a” 和 “abaca” 匹配，但是与 “aa.a” 和 “ab*a” 均不匹配。

思路：

应该注意到，’.’ 是用来当做一个任意字符，而 ‘’ 是用来重复前面的字符。这两个的作用不同，不能把 ‘.’ 的作用和 '’ 进行类比，从而把它当成重复前面字符一次。

public boolean match(char[] str, char[] pattern) {

    int m = str.length, n = pattern.length;
    boolean[][] dp = new boolean[m + 1][n + 1];

    dp[0][0] = true;
    for (int i = 1; i <= n; i++)
        if (pattern[i - 1] == '*')
            dp[0][i] = dp[0][i - 2];

    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
                dp[i][j] = dp[i - 1][j - 1];
            else if (pattern[j - 1] == '*')
                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
                } else
                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty

    return dp[m][n];
}