【算法】深信服8月31日的笔试题，获取ip的区间

1、题目：有一组ip地址，把这组ip地址，相邻的、和包含的给放在一起。

比如：192.168.0.1、192.168.0.2，要连在一起：“192.168.0.1-192.168.0.2”。
比如：1-3、2-4，要连在一起：“1-4”。

new ArrayList<String>(){{
add("192.168.0.1");
add("192.168.0.12-192.168.0.15");
add("192.168.0.2");
add("192.168.0.7-192.168.0.9");
add("192.168.0.11");
add("192.168.0.3-192.168.0.5");
add("0.0.0.0-255.255.255.255");
add("192.168.0.16");
add("192.168.0.100");
}}

2、我的步骤（顶级low）

1）ip变为long类型的整数
2）在x轴上打点（一个list），如果当前字符串是区间，则左右两点加上一个自增的标记"0.0.0.0-255.255.255.255" 记录为 {0.0.0.0,1}和{255.255.255.255,1}。
如果不是区间，则该点为{值,-1}。
3）根据数组的第一个元素排序。排序后如下图

4）一次遍历，即可得出答案。代码如下：

package bishi.shenxinfu;

import java.util.*;

/**
 * @author: 唐小尊
 * @email: 1171702529@qq.com
 * @cate: 2021/08/31 16:53
 */

/**
 * Ip地址区间
 * 在同一个区间内的ip地址，把它们连接起来
 */
public class two {
    public static void main(String[] args) {
        two two = new two();
        System.out.println(two.merge(new ArrayList<String>() {{
            add("192.168.1.1");
            add("192.168.1.2");
            add("92.168.20.3-92.168.20.3");
        }}));
    }

    public ArrayList<String> merge(ArrayList<String> input) {
        ArrayList<String> res = new ArrayList<>();
        // write code here
        List<long[]> list = new ArrayList<>();
        int p = 1;//标记
        for (String str : input) {
            if (!str.contains("-")) {
                list.add(new long[]{toLong(str), -1L});
            } else {//是区间，打标记
                String[] split = str.split("-");
                list.add(new long[]{toLong(split[0]), p});
                list.add(new long[]{toLong(split[1]), p});
                p++;
            }
        }
        list.sort((o1, o2) -> (int) (o1[0] - o2[0]));//排序

        //栈中最深元素，就是当前最左的区间值。：1232345154：最左区间的位置为1，最右区间的位置为4！！1、4并不代表值的大小，只是标记的大小。
        Deque<long[]> deque = new LinkedList<>();//0：当前值；1：标记
        Set<Long> set = new HashSet<>();//解决1212问题
        List<long[]> listArr = new ArrayList<>();//用于存储第一次组合后的值。没有组合{2,3}，这个会在后面进行操作即{2,3}变为{2-3}
        for (int i = 0; i < list.size(); i++) {
            if (deque.size() == 0) {
                if (list.get(i)[1] == -1L) {
                    listArr.add(new long[]{list.get(i)[0], -1});
                } else {
                    deque.offerLast(list.get(i));
                    set.add(list.get(i)[1]);
                }
            } else {
                if (set.contains(list.get(i)[1]) && deque.peekLast()[1] != list.get(i)[1]) {//当前标记之前遇到过，但是前一个标记不是这个，说明这个标记被包含了，即1212，这个标记为第二个1
                    set.remove(list.get(i)[1]);//1212情况，第二次遇到1，删掉set中的1，此时遇到2，再回滚遇到1则畅通无阻。（回滚到1的时候，不会被阻塞，因为1-1前面已经结束了）
                } else if (deque.peekLast()[1] == list.get(i)[1]) {
                    long[] nextRes = new long[0];
                    while (deque.size() > 0 && (deque.peekLast()[1] == list.get(i)[1] || !set.contains(deque.peekLast()[1]))) {
                        //出栈，保存当前的栈顶元素，如果这次操作后deque.size()==0，则nextRes就为左区间值。
                        nextRes = deque.pollLast();
                    }
                    if (deque.size() == 0) {
                        if (nextRes[0] != list.get(i)[0]) {
                            listArr.add(new long[]{nextRes[0], list.get(i)[0]});
                        } else {
                            listArr.add(new long[]{list.get(i)[0], -1});
                        }
                    }
                } else {
                    //-1的情况，代表没有标记，且当前deque.size() != 0，即有左区间，则当前元素包含在正在找的区间范围中，不用记录
                    if (list.get(i)[1] != -1) {
                        deque.offerLast(list.get(i));
                        set.add(list.get(i)[1]);
                    }
                }
            }
        }

        // 组合相连的区间，{2,3}->{2-3}
        int i = 0;
        while (i < listArr.size() - 1) {
            if (listArr.get(i)[1] == -1 && isGebi(listArr.get(i)[0], listArr.get(i + 1)[0]) ||
                    (isGebi(listArr.get(i)[1], listArr.get(i + 1)[0])) ||
                    listArr.get(i)[1] == listArr.get(i + 1)[0] ||
                    listArr.get(i)[0] == listArr.get(i + 1)[0]) {
                //可以合并
                long[] now = new long[2];
                now[0] = listArr.get(i)[0];
                if (listArr.get(i + 1)[1] == -1) {
                    now[1] = listArr.get(i + 1)[0];
                } else {
                    now[1] = listArr.get(i + 1)[1];
                }
                listArr.set(i, now);
                listArr.remove(i + 1);
            } else {
                i++;
            }
        }
        for (long[] longs : listArr) {
            if (longs[1] == -1) {
                res.add(toIp(longs[0]));
            } else {
                res.add(toIp(longs[0]) + "-" + toIp(longs[1]));
            }
        }
        return res;
    }

    /**
     * long类型，得到字符串的ip地址
     *
     * @param l ip地址转化为的long类型整数
     * @return ip地址
     */
    private String toIp(long l) {
        StringBuilder sb = new StringBuilder();
        int p = 1000000000;
        for (int i = 0; i < 4; i++) {
            sb.append(l / p);
            if (p != 1) {
                sb.append(".");
            }
            l %= p;
            p /= 1000;
        }
        return sb.toString();
    }

    /**
     * ip地址转化为long类型整数
     *
     * @param str ip地址
     * @return ip地址转化为的long类型整数
     */
    private long toLong(String str) {
        String[] split = str.split("\\.");
        long now = 0L;
        long p = 1000;
        for (String s : split) {
            now = now * p + Integer.parseInt(s);
        }
        return now;
    }

    //两个ip是否相连
    private boolean isGebi(long l1, long l2) {
        boolean b1 = l2 % 1000 == (l1 + 1) % 1000 % 255;
        boolean b2 = l1 / 1000 == l2 / 1000;
        boolean b3 = l1 / 1000000 == l2 / 1000000;
        boolean b4 = l1 / 1000000000 == l2 / 1000000000;
        return b1 && b2 && b3 && b4;
    }
}

3、面试官问到了这道题

他引导我用更简单的方法实现。
1、将ip转为256进制的连续数字。（说错，说成255进制）
2、贪心，排序所有的ip。
3、判断ip是否相连。（说错，忘记了1-2和3-4要连在一起）

所以结果可想而知。
我的做法和面试官的做法，一个本质的区别就是，ip转为整数的部分，我没有按照进制来转，所以非常复杂。