打卡

class Node{
String data;
Node next;
public Node(String data){
this.data = data;
this.next = null;
}
}

class LinkList {
private Node head;

public LinkList(){
    this.head =new Node("head");
}

// 根据value查找结点
public Node findByValue(String value){
    Node currentNode = head;
    while (currentNode != null && !currentNode.data.equals(value)){
        currentNode = currentNode.next;
    }
    System.out.println(currentNode);
    return currentNode == null ? null : currentNode;
}

// 根据index 查找结点
public Node findByIndex(int index){
    int pos = 0;
    Node currentNode = head;
    while(currentNode != null && pos != index){
        currentNode = currentNode.next;
        pos++;
    }
    //判断是否找到该索引；
    System.out.println(currentNode);
    return currentNode == null ? null : currentNode;
}

// 插入元素指定元素向后插入
public void insert(String value,String element){
    //先查找该元素
    Node currentNode = findByValue(element);
    // 如果没有找到
    if (currentNode == null){
        System.out.println("未找到插入位置");
        return;
    }
    Node newNode= new Node(value);
    newNode.next = currentNode.next;
    currentNode.next = newNode;
}

public void delete(String value){
    Node currentNode = head;
    Node preNode = null;
    while (currentNode != null && !currentNode.data.equals(value)){
        preNode = currentNode;
        currentNode = currentNode.next;
    }
    if (currentNode == null){
        System.out.println("未找到该值！");
        return;
    }
    if(preNode != null){
        preNode.next = currentNode.next;
    }else{
        head = currentNode.next; //如果删除的是头结点：
    }
}

// 遍历所有结点
public void print() {
    Node currentNode = head;
    // 如果结点不为空
    while (currentNode != null) {
        System.out.println(currentNode.data);
        currentNode = currentNode.next;
    }
}

}

public class LinkedList{
public static void main(String[] args) {
LinkList list = new LinkList();
list.insert(“xiao”, “head”);
list.insert(“lu”, “xiao”);
list.insert(“ni”, “head”);
list.insert(“hellow”, “head”);
list.print();

    System.out.println("-------------删除元素------------");
    list.delete("ni");
    list.delete("xiao");
    list.print();

    System.out.println("-------------按值查找------------");
    list.findByValue("lu");

    System.out.println("-------------按索引查找------------");
    list.findByIndex(2);
    list.print();
}

} Java版本

帅地哥 这个python的答案会超出时间限制 过不了 下面这个答案也是递归 原理一样
class Solution:
def lowestCommonAncestor(self, root: ‘TreeNode’, p: ‘TreeNode’, q: ‘TreeNode’) -> ‘TreeNode’:
# 基准情况
if root is None or root p or root q:
return root

    # 递归查找左子树和右子树
    left = self.lowestCommonAncestor(root.left, p, q)
    right = self.lowestCommonAncestor(root.right, p, q)

    # 如果左右子树都有结果，说明当前节点是最近公共祖先
    if left and right:
        return root

    # 否则返回非空的那个结果
    return left if left else right

# def find(self, root, p):
# if root is None:
# return False
# if root p:
# return True
# return self.find(root.left, p) or self.find(root.right, p)

class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
int n = 0;
for (ListNode cur = head; cur != null; cur = cur.next)
++n; // 统计节点个数

    ListNode dummy = new ListNode(0, head), p0 = dummy;
    ListNode pre = null, cur = head;
    for (; n >= k; n -= k) {
        for (int i = 0; i < k; ++i) { // 同 92 题
            ListNode nxt = cur.next;
            cur.next = pre; // 每次循环只修改一个 next，方便大家理解
            pre = cur;
            cur = nxt;
        }

        // 见视频
        ListNode nxt = p0.next;
        p0.next.next = cur;
        p0.next = pre;
        p0 = nxt;
    }
    return dummy.next;
}

}

已完成阅读

为什么网页端要会员而手机端不需要

已阅读完成

已完成阅读

github仓库:https://github.com/CurryisCoat/community/tree/dev

@Component
public class SensitiveFilter {

    private static final Logger logger = LoggerFactory.getLogger(SensitiveFilter.class);

    private static final String REPLACEMENT = "***";

    // 根节点
    private TrieNode rootNode = new TrieNode();

    @Autowired
    private DisallowService disallowService;

    @PostConstruct
    public void init()
    {
//        InputStream is = this.getClass().getClassLoader().getResourceAsStream("sensitive-filter.txt");
//        BufferedReader read = new BufferedReader(new InputStreamReader(is));

//        try {
//            String keyWord;
//            while((keyWord=read.readLine())!=null)
//            {
//                this.addKeyword(keyWord);
//            }
//        } catch (IOException e) {
//            logger.error("加载敏感词文件失败: " + e.getMessage());
//        }

        List<DisallowWord> list = disallowService.wordList();
        for(DisallowWord t:list){
            String temp = t.getValue();
            this.addKeyword(temp);
        }
    }

    //将一个敏感词添加到前缀树中
    private void addKeyword(String keyWord)
    {

        TrieNode tempNode = rootNode;
        for(int i = 0;i < keyWord.length();i ++)
        {
            char c = keyWord.charAt(i);
            TrieNode subNode = tempNode.getSubNode(c);

            if(subNode==null){
                subNode = new TrieNode();
                tempNode.addSubNode(c,subNode);
            }

            tempNode=subNode;
            if(i == keyWord.length()-1){
                tempNode.setKeywordEnd(true);
            }
        }
    }
    //过滤文本
    public String filter(String text)
    {
        if(StringUtils.isBlank(text)){
            return null;
        }

        TrieNode p1 = rootNode;
        int p2 = 0;
        int p3 = 0;
        StringBuilder sb = new StringBuilder();
        while(p3 < text.length())
        {
            char c = text.charAt(p3);
            if(isSymbol(c)){

                if(p1 == rootNode){
                    sb.append(c);
                    p2++;
                }
                p3++;
                continue;
            }

            p1 = p1.getSubNode(c);
            if(p1==null){
                sb.append(text.charAt(p2));
                p3 = ++p2;
                p1 = rootNode;
            }else if(p1.isKeywordEnd()==true){
                sb.append(REPLACEMENT);
                p2 = ++p3;
                p1 = rootNode;
            }else{
                p3++;
            }
        }
        sb.append(text.substring(p2));
        return sb.toString();
    }


    // 判断是否为符号
    private boolean isSymbol(Character c) {
        // 0x2E80~0x9FFF 是东亚文字范围
        return !CharUtils.isAsciiAlphanumeric(c) && (c < 0x2E80 || c > 0x9FFF);
    }
    //树结构
    private class TrieNode{

        private boolean iskeywordEnd = false;

        private HashMap<Character,TrieNode> subNodes = new HashMap<>();

        public boolean isKeywordEnd() {
            return iskeywordEnd;
        }

        public void setKeywordEnd(boolean keywordEnd) {
            iskeywordEnd = keywordEnd;
        }

        public void addSubNode(Character c,TrieNode node){
            subNodes.put(c,node);
        }

        public TrieNode getSubNode(Character c){
            return subNodes.get(c);
        }
    }
}

2.建表语句
CREATE TABLE disallow_word (
id int NOT NULL AUTO_INCREMENT,
value varchar(255) NOT NULL,
type int NOT NULL DEFAULT ‘0’,
PRIMARY KEY (id)
) ENGINE=InnoDB

CREATE TABLE user (
id int NOT NULL AUTO_INCREMENT,
username varchar(20) NOT NULL,
password int NOT NULL,
salt varchar(5) NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB
提交地址:https://github.com/CurryisCoat/community/tree/dev

1.key = “first” value= “encodedValue”
2.C:\Users\zouliang\AppData\Local\Microsoft\Edge\User Data\Default\Network
3.https://github.com/CurryisCoat/community/tree/dev