首页 > 其他分享 >[左神面试指南] 链表[下]篇

[左神面试指南] 链表[下]篇

时间：2023-11-09 13:55:05浏览次数：31  
标签：head ListNode int 左神 next 链表 面试 tail public

CDxxx 两个单链表相交的一系列问题⭐

  • 剑指offer 链表篇 JZ52 两个链表的第一个公共结点

  • 剑指offer 链表篇 JZ23 链表中环的入口结点

public Node getIntersectNode(Node head1, Node head2) {
    if (head1 == null || head2 == null) 
        return null;
    Node loop1 = getLoopNode(head1); // 判断是否有环
    Node loop2 = getLoopNode(head2); // 判断是否有环
    if (loop1 == null && loop2 == null) // 都没有环，判断是否相交
        return noLoop(head1, head2);
    if (loop1 != null && loop2 != null)  // 都有环，判断是否相交
        return bothLoop(head1, loop1, head2, loop2);
    return null;
}

CD119 将单链表的每 K 个节点之间逆序

/* 模拟 */
public class CD119_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head, int K)
    {
        ListNode fakeHead = new ListNode(-1), pre = fakeHead, tail = head, temp, front;
        int cnt = 1;
        fakeHead.next = head;
        while (tail != null)
        {
            if (cnt == K)
            {
                temp = tail.next;
                tail.next = null;
                front = pre.next;
                reverseList(pre.next);
                pre.next.next = temp;
                pre.next = tail;

                pre = front;
                tail = temp;
                cnt = 1;
            }
            cnt++;
            if (tail != null)
                tail = tail.next;
        }
        return fakeHead.next;
    }

    public static void reverseList(ListNode head)
    {
        ListNode tail = head.next, temp;
        head.next = null;
        while (tail != null)
        {
            temp = tail.next;
            tail.next = head;
            head = tail;
            tail = temp;
        }
    }

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, K;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        K = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0], K);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

/* 栈 */
public class CD119_2
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head, int K)
    {
        ListNode fakeHead = new ListNode(-1), pre = fakeHead, tail = head, temp;
        fakeHead.next = head;
        int cnt = 1;
        while (tail != null)
        {
            if (cnt == K)
            {
                temp = tail.next;
                ListNode[] listNodes = reverseList(pre.next, tail);
                pre.next = listNodes[0];
                listNodes[1].next = temp;

                pre = listNodes[1];
                tail = temp;
                cnt = 1;
            }
            cnt++;
            if (tail != null)
                tail = tail.next;
        }
        return fakeHead.next;
    }

    public static ListNode[] reverseList(ListNode head, ListNode tail)
    {
        ListNode res = null, temp = null;
        Stack<ListNode> stack = new Stack<>();
        while (head != tail)
        {
            stack.add(head);
            head = head.next;
        }
        stack.add(tail);
        while (!stack.isEmpty())
        {
            ListNode popNode = stack.pop();
            if (res == null)
                res = temp = popNode;
            else
            {
                temp.next = popNode;
                temp = temp.next;
            }
        }
        return new ListNode[]{res, temp};
    }

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, K;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        K = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0], K);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD137 删除无序单链表中值重复出现的节点

/* 模拟(超时,看思路即可) */
public class CD137_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head)
    {
        ListNode node = head, cur, pre;
        while (node != null)
        {
            pre = node;
            cur = node.next;
            while (cur != null)
            {
                if (cur.val == node.val)
                {
                    pre.next = cur.next;
                    cur.next = null;
                    cur = pre.next;
                    continue;
                }
                cur = cur.next;
                pre = pre.next;
            }
            node = node.next;
        }
        return head;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0]);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

/* 哈希 */
public class CD137_2
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head)
    {
        ListNode fakeHead = new ListNode(-1), tail = fakeHead;
        HashMap<Integer, ListNode> map = new HashMap<>();
        while (head != null)
        {
            if (!map.containsKey(head.val))
            {
                map.put(head.val, head);
                tail.next = head;
                tail = tail.next;
            }
            head = head.next;
        }
        tail.next = null;
        return fakeHead.next;
    }

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0]);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD138 在单链表中删除指定值的节点

/* 模拟 */
public class CD138_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head, int NUM)
    {
        ListNode fakeHead = new ListNode(-1), cur = head, pre = fakeHead;
        fakeHead.next = head;
        while (cur != null)
        {
            if (cur.val == NUM)
            {
                pre.next = cur.next;
                cur.next = null;
                cur = pre.next;
                continue;
            }
            pre = pre.next;
            cur = cur.next;
        }
        return fakeHead.next;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, NUM;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        NUM = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0], NUM);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD156 将搜索二叉树转换成双向链表⭐

/* 队列 */
public class CD156_1
{
    public static class DoubleListNode
    {
        public int val;
        public DoubleListNode prev = null;
        public DoubleListNode next = null;

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

    public static class TreeNode
    {
        public int val;
        public TreeNode left = null;
        public TreeNode right = null;

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

        public static TreeNode createTree(int[][] nums)
        {
            TreeNode[] tree = new TreeNode[nums.length + 1];
            Arrays.setAll(tree, TreeNode::new);
            for (int i = 0; i < nums.length; i++)
            {
                if (nums[i][1] != 0)
                    tree[nums[i][0]].left = tree[nums[i][1]];
                if (nums[i][2] != 0)
                    tree[nums[i][0]].right = tree[nums[i][2]];
            }
            return tree[nums[0][0]];
        }
    }

    public static DoubleListNode solution(TreeNode root)
    {
        Queue<TreeNode> que = new LinkedList<>();
        DoubleListNode fakeHead = new DoubleListNode(-1), tail = fakeHead;
        inOrder(root, que);
        while (!que.isEmpty())
        {
            TreeNode pollNode = que.poll();
            DoubleListNode temp = new DoubleListNode(pollNode.val);
            tail.next = temp;
            temp.prev = tail;
            tail = temp;
        }
        fakeHead.next.prev = null;
        return fakeHead.next;
    }

    public static void inOrder(TreeNode root, Queue<TreeNode> que)
    {
        if (root == null) return;
        inOrder(root.left, que);
        que.add(root);
        inOrder(root.right, que);
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[][] arr = new int[N][3];
        for (int i = 0; i < N; i++)
            for (int j = 0; j < 3; j++)
                arr[i][j] = in.nextInt();
        DoubleListNode res = solution(TreeNode.createTree(arr));
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

/* ⭐递归⭐ */
public class CD156_2
{
    public static class DoubleListNode
    {
        public int val;
        public DoubleListNode prev = null;
        public DoubleListNode next = null;

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

    public static class TreeNode
    {
        public int val;
        public TreeNode left = null;
        public TreeNode right = null;

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

        public static TreeNode createTree(int[][] nums)
        {
            TreeNode[] tree = new TreeNode[nums.length + 1];
            Arrays.setAll(tree, TreeNode::new);
            for (int i = 0; i < nums.length; i++)
            {
                if (nums[i][1] != 0)
                    tree[nums[i][0]].left = tree[nums[i][1]];
                if (nums[i][2] != 0)
                    tree[nums[i][0]].right = tree[nums[i][2]];
            }
            return tree[nums[0][0]];
        }
    }

    public static DoubleListNode solution(TreeNode root)
    {
        return inOrder(root)[0];
    }

    public static DoubleListNode[] inOrder(TreeNode root)
    {
        if (root == null) return new DoubleListNode[]{null, null};
        DoubleListNode temp = new DoubleListNode(root.val);
        DoubleListNode left[] = inOrder(root.left);
        DoubleListNode right[] = inOrder(root.right);
        if (left[1] != null)
            left[1].next = temp;
        temp.prev = left[1];
        if (right[0] != null)
            right[0].prev = temp;
        temp.next = right[0];
        return new DoubleListNode[]{left[0] == null ? temp : left[0], right[1] == null ? temp : right[1]};
    }

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[][] arr = new int[N][3];
        for (int i = 0; i < N; i++)
            for (int j = 0; j < 3; j++)
                arr[i][j] = in.nextInt();
        DoubleListNode res = solution(TreeNode.createTree(arr));
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD139 单链表的选择排序

/* 模拟 */
public class CD139_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head)
    {
        ListNode fakeHead = new ListNode(-1), pre, cur, temp, tempPre;
        fakeHead.next = head;
        head = fakeHead;
        int mmin;
        while (head != null)
        {
            tempPre = pre = head;
            temp = cur = head.next;
            mmin = Integer.MAX_VALUE;
            while (cur != null)
            {
                if (cur.val < mmin)
                {
                    mmin = cur.val;
                    temp = cur;
                    tempPre = pre;
                }
                cur = cur.next;
                pre = pre.next;
            }
            if (temp != null)
            {
                tempPre.next = temp.next;
                temp.next = head.next;
                head.next = temp;
            }
            head = head.next;
        }
        return fakeHead.next;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0]);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD157 一种怪异的节点删除方式

/* 模拟 */
public class CD157_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static void solution(ListNode head)
    {
        while (head != null && head.next != null)
        {
            head.val = head.next.val;
            if (head.next.next == null)
                head.next = null;
            head = head.next;
        }
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, M;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        M = in.nextInt();
        ListNode res = ListNode.createSingleList(l)[0], temp = res;
        while (--M > 0)
            temp = temp.next;
        solution(temp);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD158 向有序的环形单链表中插入新节点

/* 模拟 */
public class CD158_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            tail.next = head.next;
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head, int NUM)
    {
        ListNode cur = head.next, pre = head, tail = head;
        while (tail.next != head)
            tail = tail.next;
        if (NUM <= head.val)
        {
            ListNode newNode = new ListNode(NUM);
            newNode.next = head;
            tail.next = newNode;
            head = newNode;
        }
        else if (NUM >= tail.val)
        {
            ListNode newNode = new ListNode(NUM);
            tail.next = newNode;
            newNode.next = head;
        }
        else
        {
            while (cur != null)
            {
                if (pre.val <= NUM && NUM <= cur.val)
                {
                    ListNode newNode = new ListNode(NUM);
                    pre.next = newNode;
                    newNode.next = cur;
                    break;
                }
                pre = pre.next;
                cur = cur.next;
            }

        }
        return head;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, NUM;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        NUM = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0], NUM), head = res;
        while (res.next != head)
        {
            out.print(res.val + " ");
            res = res.next;
        }
        out.println(res.val);
        out.flush();
    }
}

CD159 合并两个有序的单链表

/* 归并 */
public class CD159_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head1, ListNode head2)
    {
        ListNode fakeHead = new ListNode(-1), cur = fakeHead;
        while (head1 != null && head2 != null)
        {
            if (head1.val <= head2.val)
            {
                cur.next = head1;
                cur = cur.next;
                head1 = head1.next;
            }
            else
            {
                cur.next = head2;
                cur = cur.next;
                head2 = head2.next;
            }
        }
        cur.next = (head1 == null ? head2 : head1);
        return fakeHead.next;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N, M;
        N = in.nextInt();
        int[] l1 = new int[N];
        for (int i = 0; i < N; i++)
            l1[i] = in.nextInt();
        M = in.nextInt();
        int[] l2 = new int[M];
        for (int i = 0; i < M; i++)
            l2[i] = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l1)[0], ListNode.createSingleList(l2)[0]);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

CD160 按照左右半区的方式重新组合单链表

/* 模拟 */
public class CD160_1
{
    public static class ListNode
    {
        public int val;
        public ListNode next = null;

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

        public static ListNode[] createSingleList(int[] nums)
        {
            ListNode head = new ListNode(-1), tail = head;
            for (int num : nums)
            {
                tail.next = new ListNode(num);
                tail = tail.next;
            }
            return new ListNode[]{head.next, tail};
        }
    }

    public static ListNode solution(ListNode head)
    {
        ListNode fakeHead = new ListNode(-1), pre = fakeHead, fast = head, slow = head, tail = fakeHead;
        fakeHead.next = head;
        boolean flag = true;
        while (fast != null && fast.next != null)
        {
            pre = pre.next;
            slow = slow.next;
            fast = fast.next.next;
        }
        pre.next = null;
        while (head != null && slow != null)
        {
            if (flag)
            {
                tail.next = head;
                tail = tail.next;
                head = head.next;
            }
            else
            {
                tail.next = slow;
                tail = tail.next;
                slow = slow.next;
            }
            flag = !flag;
        }
        tail.next = (head == null) ? slow : head;
        return fakeHead.next;
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int N;
        N = in.nextInt();
        int[] l = new int[N];
        for (int i = 0; i < N; i++)
            l[i] = in.nextInt();
        ListNode res = solution(ListNode.createSingleList(l)[0]);
        while (res != null)
        {
            out.print(res.val + (res.next == null ? "" : " "));
            res = res.next;
        }
        out.flush();
    }
}

标签：head,ListNode,int,左神,next,链表,面试,tail,public
From： https://www.cnblogs.com/VividBinGo/p/17819564.html

相关文章

  • 03-链表
    3.链表3.1单向链表和双向链表单项：有一个next，双向：last，next3.2删除链表的倒数第n个结点1.题目https://leetcode.cn/problems/SLwz0R/给定一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。输入：head=[1,2,3,4,5],n=2输出：[1,2,3,5]输入：head=[1],n=1......
  • 第二节：队列详解 和 面试题剖析
    一.        二.        三.         !作       者:Yaopengfei(姚鹏飞)博客地址:http://www.cnblogs.com/yaopengfei/声     明1:如有错误，欢迎讨论，请勿谩骂^_^。声     明2:原创博客请在转载......
  • 分享2023全新GO工程师面试总攻略，助力快速斩获offer
    点击下崽：分享2023全新GO工程师面试总攻略，助力快速斩获offer  提取码：k8c8GO（Golang）是一种快速、高效、牢靠、平安的编程言语，被普遍应用于后端开发、云计算、人工智能等范畴。在GO工程师面试中，面试官通常会调查我们的编程才能、系统设计才能、算法和数据构造等方面的学问。本文将引......
  • 每天5道Java面试题(第5天)
    1. 如何将字符串反转？先把字符串转换成StringBuilder或者stringBuffer然后再用reverse()方法即可。2. String类的常用方法都有那些？indexOf()：返回指定字符的索引。charAt()：返回指定索引处的字符。replace()：字符串替换。trim()：去除字符串两端空白。split()：分割字符串，返回一个分......
  • [左神面试指南] 链表[上]篇
    CD48打印两个有序链表的公共部分/*归并*/publicclassCD48_1{publicstaticclassListNode{publicintval;publicListNodenext=null;publicListNode(intval){this.val=val;}pub......
  • 2008秋-计算机软件基础-单链表练习（1）
    /*--------------------------------------------------------设有一个单链表，头结点为head，为递增有序，写一个完整程序，将其改为递减有序。----------------------------------------------------------*/#include<stdio.h>#include<stdlib.h>//定义结点structnodetype......
  • 2008秋-计算机软件基础-单链表完整示例
    /*---------------------------------------------------------Title:CompletedSimpleLinkedListAuthor:EmanLeeDate:Oct22,2008Fuction:OperationonLinkedStoredLinearList.Thisisacompletedsimplesample.Itisrelatedto......
  • 2008秋季-线性表的链式存储（仅单链表）
    /*---------------------------------------------------------Title:单链表Date:September1,2008Fuction:单链表的初始化，创建，插入，删除，查找结点。参考PPT讲稿或者教材2.2.4节.(p56-63)----------------------------------------------------------*/#inclu......
  • 面试官：你会如何设计QQ中的网络协议？
    引言在设计QQ这道面试题时，我们需要避免进入面试误区。这意味着我们不应该盲目地开展头脑风暴，提出一些不切实际的想法，因为这些想法可能无法经受面试官的深入追问。因此，我们需要站在前人的基础上，思考如何解决这类面试题。我们可以设计一个实际可行的QQ系统，而不是离题太远。设计细......
  • Java面试题（高频、有答案，全网最强）
    这是一套全网最强的Java面试题，吊打网上所有Java面试题。此套面试题的威力：看过这套题的朋友、同事、粉丝参加了面试后说，他们面试被问到的问题大部分（85%以上）都在这套题里，面试通过率高达90%。这是粉丝的真实评价（聊天截图）：有人说这套题题目太多了，我说：着急的可以看频率为两颗星及以上的题......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99