zilong-20231030

1)k个反转 

package org.example.reverse_nodes_in_k_group;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        showInfo(node1, "反转前");

        ListNode retNode = reverseKGroup(node1, 3);

        showInfo(retNode, "反转后");
    }


    public static ListNode reverseKGroup(ListNode head, int k) {
        ListNode p = head;

        List tmpArr = new ArrayList<>();

        List ret = new ArrayList<>();

        while (p != null) {
            if (tmpArr.size() < k) {
                tmpArr.add(p);
                p = p.next;
            }

            if (tmpArr.size() == k) {
                for (int i = tmpArr.size() - 1; i >= 0; i--) {
                    ret.add(tmpArr.get(i));
                }
                tmpArr.clear();
            }
        }

        ret.addAll(tmpArr);

        // 重新组织
        ListNode retNode = null;
        if (!ret.isEmpty()) {
            retNode = new ListNode(ret.get(0).val);
            p = retNode;
            for (int i = 1; i < ret.size(); i++) {
                ListNode curNode = new ListNode(ret.get(i).val);
                p.next = curNode;
                p = curNode;
            }
        }

        return retNode;
    }


    public static void showInfo(ListNode head, String desc) {
        System.out.print(desc + ":");
        ListNode p = head;
        while (p != null) {
            System.out.print(p.val + " ");
            p = p.next;
        }
    }
}

/*
反转前:1 2 3 4 5 反转后:3 2 1 4 5 
 */

2)n！转12进制 求末尾多少0  一共有几位 （考虑了溢出问题）

package org.example.zilong.jiecheng;

import java.math.BigInteger;

public class Main {
    public static void main(String[] args) {
        final int N = 2021;

        // 方法1: 找出质因数的个数  12 = 2*2*3,找出3的个数
        int n = N;
        int count = 0;

        while (n > 0) {
            count += n / 3;
            n = n / 3;
        }
        System.out.println(count);

        // 方法2
        BigInteger bigInteger = new BigInteger(String.valueOf(1));
        for (int i = 2; i <= N; i++) {
            bigInteger = bigInteger.multiply(new BigInteger(String.valueOf(i)));
        }

        String str = bigInteger.toString(12);

        int num = 0;
        for (int i = str.length() - 1; i >= 0; i--) {
            if (str.charAt(i) == '0') {
                num++;
            } else {
                break;
            }
        }
        System.out.println(num);
    }
}
/*
1005
1005
 */

3)大量数据获取前10个

桶排序

4)TreeMap数据结构

1.key不会重复，重复则覆盖。

2.会根据key进行排序。

3.内部结构是红黑树，是一种2叉平衡查找树。也就是保证树的左右子树高度不超过1，这样子不会退化成链表，具有log(n)的查找效率。

5)红黑树规则和特性

几个约束特性：

1.根节点是黑色

2.叶子节点是：黑色，且不存储数据。

3.节点之间黑色红色隔开。

6)热更

Instrumentation接口下的redefineClass

7)压测

8)业务跨服实现

9)有哪些线程以及怎么分配

10)死锁

11)xdb的理解

12)HashMap和ConcurrentHashMap

1.尾插法解决死循环问题。

2.数组长度>8且链表长度>64时，转换为红黑树

3.volatile+CAS:  位置数据为空，则CAS设置。

    synchronized： 节点不为空，则加锁进行替换。

13)ReentrantLock

基于AQS，是一个双向链表。

1.锁的竞争：

        CAS实现锁的竞争。

2.公平性和非公平性

        是否AQS队列中有等待的线程。

3，重入锁

        AQS有成员变量保存当前获得锁的线程，如果同一个锁再来竞争，则直接增加重入次数。