牛客网算法小结(2)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_36904568/article/details/94056371

一:树

1. 折纸问题

【题目】 请把一段纸条竖着放在桌子上,然后从纸条的下边向上方对折1次,压出折痕后展开。此时 折痕是凹下去的,即折痕突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折2 次,压出折痕后展开,此时有三条折痕,从上到下依次是下折痕、下折痕和上折痕。给定一 个输入参数N,代表纸条都从下边向上方连续对折N次,请从上到下打印所有折痕的方向。 例如:N=1时,打印: down N=2时,打印: down down up

/**
 * 折纸问题,就是一棵左结点为down,右结点为up的二叉树
 */
public class Paper {
    static class TreeNode{
        private String val;
        private TreeNode left;
        private TreeNode right;

        public TreeNode(String val) {
            this.val = val;
        }

        @Override
        public String toString() {
            return "TreeNode{" +
                    "val=" + val +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }
    public static void print(int N){
        if (N < 1)
            return;
        TreeNode root = new TreeNode("down");
        build(root,N);
        print(root);
    }

    private static void print(TreeNode node){
        if (node.left != null)
            print(node.left);
        System.out.println(node.val);
        if (node.right != null)
            print(node.right);
    }

    private static void  build(TreeNode node,int N){
        if (N <= 1)
            return;
        node.left = new TreeNode("down");
        node.right = new TreeNode("up");
        build(node.left,N-1);
        build(node.right,N-1);
    }


    public static void main(String[] args) {
        print(3);
    }
}

2. 二叉树先序、中序,后序遍历的非递归实现

    //递归前序遍历
    public static void pre1(TreeNode node){
        if (node == null)
            return;
        System.out.printf(node.val+" ");
        pre1(node.left);
        pre1(node.right);
    }

    //非递归前序遍历
    public static void pre2(TreeNode node){
        if (node == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || node != null){
            //把所有左结点加入到栈
            if (node != null){
                System.out.printf(node.val+" ");
                stack.push(node);
                node = node.left;
            }
            //左结点都为空,把上一个结点的右结点入栈
            else
                node = stack.pop().right;
        }
    }

    //递归中序遍历
    public static void in1(TreeNode node){
        if (node == null)
            return;
        in1(node.left);
        System.out.printf(node.val+" ");
        in1(node.right);
    }

    //非递归中序遍历
    public static void in2(TreeNode node){
        if (node == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || node != null){
            //把所有左结点加入到栈
            if (node != null){
                stack.push(node);
                node = node.left;
            }
            //左结点都为空,把上一个结点的右结点入栈
            else
            {
                node = stack.pop();
                System.out.printf(node.val+" ");
                node = node.right;
            }
        }
    }

    //递归后序遍历
    public static void post1(TreeNode node){
        if (node == null)
            return;
        post1(node.left);
        post1(node.right);
        System.out.printf(node.val+" ");
    }

    //非递归后序遍历
    public static void post2(TreeNode node){
        if (node == null)
            return;
        ArrayList<TreeNode> nodes = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || node != null){
            //把所有右结点加入到栈
            if (node != null){
                nodes.add(node);
                stack.push(node);
                node = node.right;
            }
            //右结点都为空,把上一个结点的左结点入栈
            else
                node = stack.pop().left;
        }
        Collections.reverse(nodes);
        for (TreeNode node1:
             nodes) {
            System.out.printf(node1.val+" ");
        }
    }

3. morris遍历

特点:

  • 时间复杂度为O(N),空间复杂度为O(1),并且遍历过程不会改变树的形状
  • 对于有左子树的结点,访问两次,对于没有左子树的结点,只访问一次
  • 大体上沿着当前结点、左、当前结点、右方向移动

要求:

  • cur无左子树,向右移动(左边没路,那我直接向右走)
  • cur有左子树,找到左子树的最右结点mostRight
    • mostRight的右孩子为空:mostRight = cur,cur向左移动(标记自己来过一次,去左边看看)
    • mostRight的右孩子为cur:mostRight = null,cur向右移动(看到自己的标记了,左边我走过了,直接去右边)
/**
 * morris遍历
 */
public class MorrisTravel {
    static class TreeNode {
        private int val;
        private TreeNode left;
        private TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }

        @Override
        public String toString() {
            return "TreeNode{" +
                    "val=" + val +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }

    public static void inTravel(TreeNode root) {
        if (root == null)
            return;
        TreeNode cur = root;
        TreeNode next = null;
        while (cur != null) {
            next = cur.left;
           //有左子树
            if (next != null) {
                while (next.right != cur && next.right != null)
                    next = next.right;
                //第一次访问,改一下指针,向左走(中断)
                if (next.right == null) {
                    next.right = cur;
                    cur = cur.left;
                    continue;
                }
                //第二次访问,修复指针,向右走↓
                else
                    next.right = null;
            }

            //左子树遍历完成(左-根-右)
            System.out.printf(cur.val + " ");
            cur = cur.right;
        }
    }

    public static void preTravel(TreeNode root) {
        if (root == null)
            return;
        TreeNode cur = root;
        TreeNode next = null;
        while (cur != null) {
            next = cur.left;
           //有左子树
            if (next != null) {
                while (next.right != cur && next.right != null)
                    next = next.right;
                //第一次访问,改一下指针,向左走(中断)
                if (next.right == null) {
                     next.right = cur;
                    //(根-左)
                    System.out.printf(cur.val + " ");
                    cur = cur.left;
                    continue;
                }
                //第二次访问,修复指针,向右走↓
                else
                    next.right = null;
            }
            //左子树遍历完成
            else
                //(根-右)
                System.out.printf(cur.val + " ");
            cur = cur.right;

        }
    }

    public static void postTravel(TreeNode root) {
        if (root == null)
            return;
        TreeNode cur = root;
        TreeNode next = null;
        while (cur != null) {
            next = cur.left;
           //有左子树
            if (next != null) {
                while (next.right != cur && next.right != null)
                    next = next.right;
                //第一次访问,改一下指针,向左走(中断)
                if (next.right == null) {
                    next.right = cur;
                    cur = cur.left;
                    continue;
                }
                //第二次访问,修复指针,向右走↓
                else
                {
                    next.right = null;
                    //已经走完左边和右边了(左-右-根)
                    //打印左子树的倒置右结点
                    reverse(cur.left);
                }
            }
            cur = cur.right;

        }
        //打印根节点的倒置右结点
        //左边和右边都走完了
        reverse(root);
    }

    private static void reverse(TreeNode node){
        if (node == null)
            return;
        TreeNode next = node.right;
        TreeNode temp = null;
        node.right = null;
        while (next != null){
            temp = next.right;
            next.right = node;
            node = next;
            next = temp;
        }
        next = node;
        while (next != null){
            System.out.printf(next.val + " ");
            next = next.right;
        }
        next = node.right;
        node.right = null;
        while (next != null){
            temp = next.right;
            next.right = node;
            node = next;
            next = temp;
        }
    }
}

4. 在二叉树中找到一个节点的后继节点

【题目】 现在有一种新的二叉树节点类型如下:

public class Node { 
	public int value; 
	public Node left; 
	public Node right; 
	public Node parent;
	public Node(int data) { this.value = data; }
}

该结构比普通二叉树节点结构多了一个指向父节点的parent指针。假设有一 棵Node类型的节点组成的二叉树,树中每个节点的parent指针都正确地指向 自己的父节点,头节点的parent指向null。只给一个在二叉树中的某个节点 node,请实现返回node的后继节点的函数。在二叉树的中序遍历的序列中, node的下一个节点叫作node的后继节点。

    public static Node nextNode(Node node){
        if (node == null)
            return null;
        //中序遍历是左-中-右
        //如果有右结点,那么就在下一层找,找到右孩子的最左边的结点
        if (node.right != null){
            node = node.right;
            while (node != null && node.left != null) {
                node = node.left;
            }
            return node;
        }
        //如果没有右结点,那么就只能往上一层查找,找到一个作为左结点的父结点
        else
            while (node.parent != null && node != node.parent.left)
                node = node.parent;
            return node.parent;
    }

5. 何为前缀树? 如何生成前缀树?

/**
 * 前缀树
 */
public class PrefixTree {
    static class PrefixNode {
        //经过结点的单词个数
        private int pass;
        //单词长度
        private int end;
        //下一个结点
        private HashMap<Integer, PrefixNode> nexts;

        public PrefixNode() {
            pass = 0;
            end = 0;
            nexts = new HashMap<>();
        }

        @Override
        public String toString() {
            return "PrefixNode{" +
                    "pass=" + pass +
                    ", end=" + end +
                    ", nexts=" + nexts +
                    '}';
        }
    }
    private PrefixNode root;

    public PrefixTree() {
        root = new PrefixNode();
    }

    public void insert(String word){
        if (word == null || word.length() == 0)
            return;
        PrefixNode node = root;
        PrefixNode next;
        for (int i = 0; i < word.length(); i++) {
            char s = word.charAt(i);
            next = node.nexts.get((int)s);
            if (next == null)
                 next = new PrefixNode();
            node.nexts.put((int)s,next);
            next.pass++;
            node = next;
        }
        node.end++;
    }

    public void remove(String word){
        if (prefixSize(word) != 0)
        {
            PrefixNode node = root;
            PrefixNode next;
            for (int i = 0; i < word.length(); i++) {
                char s = word.charAt(i);
                next = node.nexts.get((int)s);
                if (--next.pass == 0){
                    node.nexts.put((int)s,null);
                    return;
                }
                node = next;
            }
            node.end--;
        }
    }

    public int prefixSize(String prefix){
        PrefixNode node = root;
        if (prefix == null || prefix.length() == 0)
            return 0;
        int index = 0;
        while (index < prefix.length() && node != null)
        {
            char c = prefix.charAt(index++);
            node = node.nexts.get((int)c);
        }
        if (node == null)
            return 0;
        return node.pass;
    }

    public int count(String word){
        PrefixNode node = root;
        if (word == null || word.length() == 0)
            return 0;
        int index = 0;
        while (index < word.length() && node != null)
        {
            char c = word.charAt(index++);
            node = node.nexts.get((int)c);
        }
        if (node == null)
            return 0;
        return node.end;
    }

    @Override
    public String toString() {
        return "PrefixTree{" +
                "root=" + root +
                '}';
    }
}

打印数组

一个字符串类型的数组arr1,另一个字符串类型的数组arr2。arr2中有哪些字符,是arr1中出现的?请打印

arr2中有哪些字符,是作为arr1中某个字符串前缀出现的?请打印

    public static void main(String[] args) {
        PrefixTree tree = new PrefixTree();
        String[] arr1 = {"abc","abd","bcd"};
        String[] arr2 = {"abd","cc","ab"};

        //打印数组
        for (int i = 0; i < arr1.length; i++) {
            tree.insert(arr1[i]);
        }
        System.out.println("出现的字符:");
        for (int i = 0; i < arr2.length; i++) {
            if (tree.count(arr2[i]) > 0)
                System.out.println(arr2[i]);
        }
        System.out.println("作为前缀的字符:");
        for (int i = 0; i < arr2.length; i++) {
            if (tree.prefixSize(arr2[i]) > 0)
                System.out.println(arr2[i]);
        }

    }

6. 搜索二叉树

大楼轮廓

给定一个N*3的矩阵,每一行表示有一座大楼,一共有N座大楼。 所有大楼的底部都坐落在x轴上,每一行的三个值(a,b,c)表示每座大楼 从(a,0)点开始,到(b,0)结束,高度为c. 输入数据可以保证a<b,且a,b,c均为正数,大楼之间可以有重合。 请输出整体的轮廓线。
例如
1,3,3
2,4,4
5,6,1

输出
1,2,3
2,4,4
5,6,1

/**
 * 描述建筑楼的轮廓
 */
public class BuildingOutSide {

    //辅助结构
    static class Building{
        boolean isUp;
        int start;
        int height;

        public Building(boolean isUp, int start, int height) {
            this.isUp = isUp;
            this.start = start;
            this.height = height;
        }
    }

    //比较位置
    static class BuildingComparator implements Comparator<Building>{

        @Override
        public int compare(Building o1, Building o2) {
            if (o1.isUp != o2.isUp)
                return o1.start - o2.start;
            return 0;
        }
    }

    public static int[][] outline(int[][] matrix){
        //记录大楼形状的每个节点
        Building[] buildings = new Building[matrix.length * 2];
        for (int i = 0; i < matrix.length; i++) {
            buildings[i * 2] = new Building(true,matrix[i][0],matrix[i][2]);
            buildings[i * 2 + 1] = new Building(false,matrix[i][1],matrix[i][2]);
        }
        //按照在X轴的位置排序
        Arrays.sort(buildings,new BuildingComparator());

        //统计高度height对应的出现次数(上和下),不断找出最大高度
        TreeMap<Integer,Integer> heightMap = new TreeMap<>();

        //记录变化的节点位置以及变化的高度
        TreeMap<Integer,Integer> maxMap = new TreeMap<>();

        for (int i = 0; i < buildings.length; i++) {

            //记录高度
            //上升
            if (buildings[i].isUp) {
                //初始化
                if (!heightMap.containsKey(buildings[i].height))
                    heightMap.put(buildings[i].height,1);
                //增加次数
                else
                    heightMap.put(buildings[i].height,heightMap.get(buildings[i].height) + 1);
            }
            //下降
            else{
                if (heightMap.containsKey(buildings[i].height))
                    //初始化
                    if (heightMap.get(buildings[i].height) == 1)
                        heightMap.remove(buildings[i].height);
                    //减少次数
                    else
                        heightMap.put(buildings[i].height,heightMap.get(buildings[i].height) - 1);
            }

            //记录当前位置的最大高度
            if (heightMap.isEmpty())
                maxMap.put(buildings[i].start,0);
            else
                maxMap.put(buildings[i].start,heightMap.lastKey());
        }

        List<List<Integer>> res = new ArrayList<>();
        int start = 0;
        int height = 0;
        for (Map.Entry<Integer,Integer> entry: maxMap.entrySet()) {
            int position = entry.getKey();
            int maxHeight = entry.getValue();
            //高度发生了变化,或高或低,进行更新
            if (height != maxHeight){
                if (height != 0){
                    List<Integer> record = new ArrayList<>();
                    record.add(start);
                    record.add(position);
                    record.add(height);
                    res.add(record);
                }
                //重新定义位置和高度为当前的位置和高度
                start = position;
                height = maxHeight;
            }
        }
        return getMatrix(res);
    }

    //把链表转换为数组
    private static int[][] getMatrix(List<List<Integer>> lists){
        if (lists == null || lists.size() == 0)
            return null;
        int row = lists.size();
        int col = lists.get(0).size();
        int[][] matrix = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                matrix[i][j] = lists.get(i).get(j);
            }
        }
        return matrix;
    }

    public static void main(String[] args) {
        int[][] matrix = {{1,3,3},{2,4,4},{5,6,1}};
        int[][] res = outline(matrix);
        for (int i = 0; i < res.length; i++) {
            for (int j = 0; j < res[i].length; j++) {
                System.out.printf("%d ",res[i][j]);
            }
            System.out.println();
        }
    }
}

7. 判断

搜索二叉树

中序遍历后值是递增的

完全二叉树

进行层序遍历

  • 有右孩子,没有左孩子:false
  • 有左孩子而没有右孩子,或者没有孩子:接下来必须全都是叶子节点
public static boolean isComplete(Node root){
        if (root == null)
            return true;
        //层序遍历
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        boolean found = false;
        while (!queue.isEmpty()){
            Node node = queue.poll();
            Node left = node.left;
            Node right = node.right;
            //违反规则
            if ((right != null && left == null) || (found && !node.isLeaf()))
                return false;
            if (left != null)
                queue.offer(left);
            if (right != null)
                queue.offer(right);
            if (node.isLeaf() || (node.left != null && node.right == null))
                found = true;
        }
        return true;
    }

平衡二叉树(树形DP)

递归判断

  • 如果左子树和右子树的高度差超过1,返回false
  • 递归判断左子树
  • 递归判断右子树

二:哈希表

1. 布隆过滤器

作用:黑名单是一个大文件,用于过滤某个信息。如果信息属于黑名单,则会被过滤;如果信息不属于黑名单,也可能会被失误过滤。

结构:大数组,数组元素是一个bit位

定位信息:

  1. 定位数组的索引:X/位数
  2. 定位该索引的位数:X%位数

描黑:

  1. 准备K个哈希函数
  2. 将信息分别通过哈希函数,得到K个哈希值,把相应的K个位数描黑

检测:

  1. 将信息分别通过哈希函数,得到K个哈希值
  2. 如果相应的位都是黑的,则拦截;如果有一个位不是黑的,则放过

特点:

  • 与单样本的大小无关
  • 与样本数量和失误率有关

2. 一致性哈希

原来的结构

  1. 客户端发出一个key,请求一个value
  2. 服务端通过对key的哈希函数求出哈希值,模服务器个数,确定提供服务的服务器X
  3. 由服务器X提供服务

问题:

  • 服务器的增加和删除,数据迁移的代价高
  • 改动代码

改进的结构

  1. 服务端通过对每个服务器的ip求出哈希值,连成环
  2. 客户端发出一个key,请求一个value
  3. 服务端通过对key的哈希函数求出哈希值,打到环上,确定环上顺时针方向的下一个服务器X(通过二分法确定)
  4. 由服务器X提供服务

特点:

  • 添加一个服务器X1后,找到顺时针方向的下一个服务器X2,请他把X1-X0的数据传给X1
  • 初级服务器个数少时,负载不均衡
  • 添加服务器后,负载不均衡

再改进的结构

  1. 每个服务器分配一定量的虚拟节点,放在路由表
  2. 服务端通过对每个服务器的每个虚拟节点求出哈希值,连成环

3. 并查集

  1. 查找两个元素是否属于同一个集合
  2. 把两个集合合并为一个大集合
/**
 * 并查集
 */
public class UnionSet {
    static class Node{
        private int val;

        public Node(int val) {
            this.val = val;
        }
    }
    //记录每个节点的代表节点
    HashMap<Node,Node> fathers;
    //记录每个代表节点的集合个数
    HashMap<Node,Integer> sizes;

    public UnionSet(List<Node> nodes){
        fathers = new HashMap<>();
        sizes = new HashMap<>();
        build(nodes);
    }

    //初始化
    private void build(List<Node> nodes){
        fathers.clear();
        sizes.clear();
        for (Node node :
                nodes) {
            fathers.put(node, node);
            sizes.put(node,1);
        }
    }

    //查找代表节点
    private Node findPresent(Node node){
        Node present = fathers.get(node);
        //找出代表节点为本身的节点
        if (present != node) {
            present = findPresent(present);
        }
        //找到之后,把其他节点都更新代表节点,加快查询速度
        fathers.put(node,present);
        return present;
    }

    //判断是否是同一个集合
    public boolean isSame(Node a,Node b){
        if (a == null || b == null)
            return false;
        return findPresent(a) == findPresent(b);
    }

    //合并集合
    public void union(Node a,Node b){
        if (a == null || b == null || isSame(a,b))
            return;
        int size1 = sizes.get(a);
        int size2 = sizes.get(b);
        if (size1 > size2) {
            fathers.put(b, a);
            sizes.put(a,size1+size2);
        }
        else {
            fathers.put(a, b);
            sizes.put(b,size1+size2);
        }
    }
}

岛问题

一个矩阵中只有0和1两种值, 每个位置都可以和自己的上、 下、 左、 右四个位置相连

如果有一片1连在一起, 这个部分叫做一个岛, 求一个矩阵中有多少个岛?

举例:
0 0 1 0 1 0
1 1 1 0 1 0
1 0 0 1 0 0
0 0 0 0 0 0
这个矩阵中有三个岛

/**
 * 岛问题
 */
public class Island {
    static int sum = 0;

	//遍历岛
    public static int getIsland(int[][] matrix){
        if (matrix == null || matrix[0] == null)
            return 0;
        int N = matrix.length;
        int M  = matrix[0].length;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (matrix[i][j] == 1){
                	//找到有病毒的岛,开始感染
                    sum++;
                    getIsland(matrix,i,j,N,M);
                }
            }
        }
        return sum;
    }
    //不断感染,直到没有病菌
    public static void getIsland(int[][] matrix,int x,int y,int N,int M){
        if (x < 0 || y < 0 || x >= N || y >= M || matrix[x][y] != 1)
            return;
        matrix[x][y] = 2;
        getIsland(matrix,x+1,y,N,M);
        getIsland(matrix,x-1,y,N,M);
        getIsland(matrix,x,y+1,N,M);
        getIsland(matrix,x,y-1,N,M);

    }
    public static void main(String[] args) {
        int[][] matrix = {{0,0,1,0,1,0},{1,1,1,0,1,0},{1,0,0,1,0,0},{0,0,0,0,0,0}};
        System.out.println(getIsland(matrix));
    }
}

. 随时找到数据流的中位数

【题目】 有一个源源不断地吐出整数的数据流,假设你有足够的空间来 保存吐出的数。请设计一个名叫MedianHolder的结构, MedianHolder可以随时取得之前吐出所有数的中位数。

【要求】

  1. 如果MedianHolder已经保存了吐出的N个数,那么任意时刻 将一个新数加入到MedianHolder的过程,其时间复杂度是 O(logN)。
  2. 取得已经吐出的N个数整体的中位数的过程,时间复杂度为 O(1)
/**
 * 保存中位数
 */
public class MedianHolder {
    class MyComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            if (o1 > o2)
                return -1;
            else if(o1 < o2)
                return 1;
            else
                return 0;
        }
    }
    //最小堆和最大堆
    PriorityQueue<Integer> min = new PriorityQueue<>();
    PriorityQueue<Integer> max = new PriorityQueue<>(new MyComparator());

    //最小堆只添加比自己大的数字,这样才不用调整
    //最大堆只添加比自己小的数字,或者比自己大又比其他小的数字
    //维持两个堆的平衡
    public void add(int num){
        if (max.isEmpty() || num <= max.peek())
            max.add(num);
        else if (min.isEmpty() || num >= min.peek())
            min.add(num);
        else
            max.add(num);
        modify();
    }

    //保证两个堆最多相差一个
    private void modify(){
        if (min.size() - max.size() > 1)
            max.add(min.poll());
        if (max.size() - min.size() > 1)
            min.add(max.poll());
    }

    //奇数个数字,则在多一个数量的堆里面
    //偶数个数字,取中间值
    public int get(){
        if (max.isEmpty() && min.isEmpty())
            return Integer.MIN_VALUE;
        if (min.isEmpty())
            return max.peek();
        if (max.isEmpty())
            return min.peek();
        int minSize = min.size();
        int maxSize = max.size();
        if ((maxSize+minSize) % 2 == 0)
            return (max.peek() + min.peek())/2;
        else if (maxSize > minSize)
            return max.peek();
        else
            return min.peek();
    }
}
展开阅读全文

没有更多推荐了,返回首页