JAVA-日常工作解决的bug1-热点线路的选择

业务场景：解决热点链路为访问量高的路径，如图中间路径访问量更高但热点链路展示未切换的问题

之前所使用的的方法是计算总节点最大的值来确定热点线路--使用后发现与业务不符合，之前的代码如下：

                linkStatList.sort(LinkStat::compare);
                LinkStat maxLink = linkStatList.get(0);
                LinkedList list = maxLink.getEdgeList();
                Set topoEdges = topologyBo.getEdges();
               for (TopologyDto.Edge topoEdge : topoEdges) {
                    if(list.contains(topoEdge.getId())){
                        topoEdge.setHot("1");
                    }
               }

然后根据业务需要修改成如下的计算最大节点的线路思路一：

 Map nodeDoc = new HashMap<>();
 Long max = 0L;
 for (TopologyDto.Node c : topologyBo.getNodes()) {
                long doc = Long.parseLong(c.getDocs());
 nodeDoc.put(c.getId(), doc);
 if (max < doc) {
                    max = doc;
 }
            }
            if (max == 0) {
                return;
 }
            List> result = new ArrayList<>();
 int maxIndex = 0;
 for (LinkStat c : linkStatList) {
                Set nodes = new TreeSet<>();
 c.getNodeList().forEach(n -> nodes.add(nodeDoc.get(n)));
 if (maxIndex < c.getNodeList().size()) {
                    maxIndex = c.getNodeList().size();
 }
                result.add(nodes);
 }
            Set rowNum = new HashSet<>();
 long[][] array = new long[result.size()][maxIndex];
 for (int i = 0; i < result.size(); i++) {
                rowNum.add(i);
 int j = result.get(i).size() - 1;
 for (Long aLong : result.get(i)) {
                    array[i][j--] = aLong.longValue();
 }
            }
            long nextMax = 0;
 //循环次数
 for (int i = 0; i < maxIndex; i++) {
                Set newRowNum = new HashSet<>();
 for (int j = 0; j < result.size(); j++) {
                    if (rowNum.contains(j)) {
                        if (array[j][i] > max - 1) {
                            newRowNum.add(j);
 if (i + 1 < maxIndex && array[j][i + 1] > nextMax) {
                                nextMax = array[j][i + 1];
 }
                        }
                    }
                }
                if (newRowNum.size() < 2 || nextMax == 0) {
                    rowNum = newRowNum;
 break; }
                rowNum = newRowNum;
 max = nextMax;
 nextMax = 0;
 }
            for (Integer integer : rowNum) {
                LinkStat maxLink = linkStatList.get(integer.intValue());
 LinkedList list = maxLink.getEdgeList();
 Set topoEdges = topologyBo.getEdges();
 for (TopologyDto.Edge topoEdge : topoEdges) {
                    if (list.contains(topoEdge.getId())) {
                        topoEdge.setHot("1");
 }
                }
                break;
 }
        }
    }
}

知识点的补充：链表
链表的定义：
链表是一种物理[存储单元]上非连续、非顺序的[存储结构]，[数据元素]的逻辑顺序是通过链表中的[指针](链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储[数据元素]的数据域，另一个是存储下一个结点地址的[指针]域。
换句话说，链表就是每一个节点都存储着下一个节点的地址（最后的节点除外），根据这种方法依次连接， 构成的一个链式结构。
`class ListNode {

int val;
ListNode next;
ListNode(int x) { val = x; }

}
public class test{

public static void main(String[] args){
    ListNode head=new ListNode(0);
    ListNode firstNode = new ListNode(1);
    ListNode secondNode = new ListNode(2);
    ListNode thirdNode = new ListNode(3);
    head.val=1;
    head.next=firstNode;
    firstNode.next = secondNode;
    secondNode.next = thirdNode;
    a(head);
}
public static void a(ListNode l1){
    System.out.println("secondNode 的值为："+l1.next.next.val);
}

}`
题目加深理解：
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

 

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

class Solution {

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    // 类似归并排序中的合并过程
    ListNode dummyHead = new ListNode(0);
    ListNode cur = dummyHead;
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            cur.next = l1;
            cur = cur.next;
            l1 = l1.next;
        } else {
            cur.next = l2;
            cur = cur.next;
            l2 = l2.next;
        }
    }
    // 任一为空，直接连接另一条链表
    if (l1 == null) {
        cur.next = l2;
    } else {
        cur.next = l1;
    }
    return dummyHead.next;
}

参考文档：
链接：https://leetcode-cn.com/probl...
https://blog.csdn.net/weixin_...