Java牛客编程刷算法记录--2022-12-7+2023-2-19

最新推荐文章于 2024-06-12 10:00:23 发布
最新推荐文章于 2024-06-12 10:00:23 发布
阅读量519 收藏
点赞数
文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stumiss/article/details/128220255
版权

https://www.nowcoder.com/ta/classic-code 牛客上经典必刷题库

https://www.nowcoder.com/practice/e08819cfdeb34985a8de9c4e6562e724?tpId=46&tqId=29030&rp=1&ru=/ta/classic-code&qru=/ta/classic-code&difficulty=&judgeStatus=&tags=/question-ranking

题目CC1：（知识点：树，难度：较难）
求给定二叉树的最小深度。最小深度是指树的根结点到最近叶子结点的最短路径上结点的数量。

示例1
输入：
{1,2,3,4,5}

返回值：
2

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int run (TreeNode root) {
        // write code here
        if (root == null) {
            return 0;
        }
        int left = run(root.left);
        int right = run(root.right);
        if (left * right > 0){
            return (left > right ? right : left) + 1;
        } else {
            // 理解最小深度出现偏差，对根节点，左右节点两个为空（均返回0），或其中一个为空（则left或right为0，此时要取较大值，为0的值没有叶子节点不予考虑。根节点到最近叶子节点路径上的节点数。这个概念要理解清楚，否则编程出大问题。）
            return (left > right ? left : right) + 1;
        }

    }
}

https://www.nowcoder.com/practice/22f9d7dd89374b6c8289e44237c70447?tpId=46&rp=1&ru=%2Fta%2Fclassic-code&qru=%2Fta%2Fclassic-code&difficulty=&judgeStatus=&tags=&title=&sourceUrl=&gioEnter=menu

题目CC2:(知识点：栈, 难度：较难)
计算逆波兰式（后缀表达式）的值
运算符仅包含"+“,”-“,”*“和”/"，被操作数是整数

保证表达式合法，除法时向下取整。

数据范围：表达式的长度满足： n<10000
进阶：空间复杂度 O(n) ， 时间复杂度 O(n)
例如：
[“20”, “10”, “+”, “30”, “*”] -> ((20 + 10) * 30) -> 900
[“40”, “130”, “50”, “/”, “+”] -> (40 + (130 / 50)) -> 42

示例1
输入：
[“20”,“10”,“+”,“30”,“*”]

返回值：
900

示例2
输入：
[“20”]

返回值：
20

代码：

import java.util.*;


public class Solution {
    /**
     * 
     * @param tokens string字符串一维数组 
     * @return int整型
     */
    public int evalRPN (String[] tokens) {
        // write code here
        Stack<Integer> stack = new Stack<>();
        int num1, num2;
        for (int i = 0; i < tokens.length; i++) {
            switch (tokens[i]) {
                case "+":
                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(num1 + num2);
                    break;
                case "-":
                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(num1 - num2);
                    break;
                case "*":
                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(num1 * num2);
                    break;
                case "/":
                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(num1 + num2);
                    break;
                default:
                    stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();
    }
}

https://www.nowcoder.com/practice/bfc691e0100441cdb8ec153f32540be2?tpId=46&rp=1&ru=%2Fta%2Fclassic-code&qru=%2Fta%2Fclassic-code&difficulty=&judgeStatus=&tags=&title=&sourceUrl=&gioEnter=menu

题目CC3:(知识点：穷举，难度：困难)
对于给定的n个位于同一二维平面上的点，求最多能有多少个点位于同一直线上
示例1
输入：
[(0,0),(0,1)]

返回值：
2

示例2
输入：
[(2,3),(3,3),(-5,3)]

返回值：
3

代码：

import java.util.*;

/*
 * public class Point {
 *   int x;
 *   int y;
 * }
 */

public class Solution {
    /**
     * 
     * @param points Point类一维数组 
     * @return int整型
     */
    public int maxPoints (Point[] points) {
        // write code here
        if (points == null || points.length == 0) {
            return 0;
        }
        if (points.length <= 2) {
            return points.length;
        }
        //上面考虑特殊情况。下面就是通用情况考虑
        int max = 0;  // max存储最大值sum
        for (int i = 0; i < points.length; i++) {
            for (int j = i + 1; j < points.length; j++) {
                // 两点形成一条直线，穷尽两个点的举例， 但会存在重复的直线,这里存在这个重复计算的问题，理论上可以优化。
                //points[i] 和 points[j] 构成一条直线，重新遍历所有点，有多少点在该直线上，并将数据存在sum中。
                int sum = 0;
                if (points[i].x == points[j].x) {
                    // 考虑直线斜率无穷大的情况，所有点横坐标相同。
                    for (int k = 0; k < points.length; k++) {
                        if (points[k].x == points[i].x) {
                            sum++;
                        }
                    }
                } else {
                    // 如何判断点在一条有斜率的直线上？？？
                    // y = kx + b // k, b体现直线的特征（不适用垂直于x轴的直线）
                    // 在程序中直接求k值（除不尽为小数）会存在精度损失的情况，所以必须采用某种表达式判断点是否在直线上。假设两个个点(x1,y1),(x2,y2),判断第三个点(x3,y3)(不同于前面两个点)是否在(x1,y1),(x2,y2)构成的直线上？？我们知道(y2-y1)/(x2-x1) = (y3 - y2)/(x3 -x2)成立则第三个点肯定在直线上，对这个表达式变换一下：(y2-y1)*(x3-x2) = (y3-y2)*(x2-x1),程序中判断这个表达式就不会存在精度问题。本题中横纵坐标均是整型。若(x3,y3)为（x1,y1）,(x2,y2)中的一个点，表达式依然成立
                    for (int m = 0; m < points.length; m++) {
                        if ((points[j].y - points[i].y) * (points[m].x - points[j].x) == (points[m].y - points[j].y) * (points[j].x - points[i].x)){
                            sum++;
                        }
                    }

                }

                // 遍历所有的每条直线产生的sum值。
                if (sum > max) {
                    max = sum;
                }

            }
        }
        return max;
    }
}

总结：穷举类型的题目在于用程序模拟求解的过程。本题要求最多有多少个点在一条直线上。所以考虑穷举所有的直线，并求每条直线上的点的个数，即可求得本题的解。

https://www.nowcoder.com/practice/d75c232a0405427098a8d1627930bea6?tpId=46&rp=1&ru=%2Fta%2Fclassic-code&qru=%2Fta%2Fclassic-code&difficulty=&judgeStatus=&tags=&title=&sourceUrl=&gioEnter=menu

题目CC4:(知识点：链表，排序，难度：较难)
在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。
示例1
输入：
{30,20,40}

返回值：
{20,30,40}

本题思路：采用插入排序，但插入排序的时间复杂度为O(n^2),但本题采用插入排序，可以通过牛客网的全部测试用例。对于单链表而言，肯定采用插入排序更好。快排时间复杂度可以达到O(nlog2).对于排序，各种方法还需要好好复习，加以体会。

代码：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode sortList (ListNode head) {
        // write code here
        if (head == null || head.next == null) {
            return head;
        }
        //插入排序
        ListNode p = head.next;//遍历剩下的链表元素
        head.next = null;  //用于构建插入排序链表，寻找合适位置并插入
        while (p != null) {
            ListNode r = p.next; //保存p的后续，以免链断了。
            if (p.val < head.val) { //考虑特殊情况，首结点，p作为首节点,//这里若引入头结点就不用考虑特殊情况，头结点不存储任何数据，只存储指向链表首结点的指针。单链表插入操作必须考虑前驱节点。
                p.next = head;
                head = p;
                p = r;
                
            } else {
                ListNode q = head;
            
                //后面比较除head节点之外的节点
                while (q.next != null && p.val >= q.next.val) {
                    q = q.next;
                }
                //找到合适位置并插入，p的值比q的下一个值小则p插入到q的后面， 或者遍历到最后q.next=null,则q插入到q的后面.  这里是单链表的插入操作，我竟然都忘记了，要维护两个指针，而我只写了q.next = p.
                p.next = q.next;
                q.next = p; 
                p = r;
            }

            

        }
        return head;
    }
}

本题第二种思路：为满足时间为O(nlogn),采用归并排序。冒泡排序、插入排序、选择排序这三种算法的时间复杂度都为O(n^2) ，只适合小规模的数据。两种时间复杂度为nlogn的排序算法——归并排序（Merge Sort）和快速排序（Quick Sort），他们都用到了分治思想，非常巧妙。参考网址：https://zhuanlan.zhihu.com/p/95080265
归并排序算法时间复杂度分析，参考网址：https://zhuanlan.zhihu.com/p/341225128
像这种排序问题的时空复杂度分析，还是要作比较深入的理解分析，对于自己的算法编程肯定大有益处。
使用快慢指针拆分两个链表，对两个链表分别递归排序，最终将排好序的两个链表归并排序成一个有序的链表，归并 排序需要额外的空间O(n)

代码：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode sortList (ListNode head) {
        // write code here
        if (head == null) {
            return null;
        }
        if (head.next == null) {
            return head;
        }

        ListNode preSlow = head;  // 慢指针指向元素的前一个元素
        ListNode slow = head; // 慢指针
        ListNode fast = head; // 快指针
        while (slow != null && fast != null && fast.next != null) {
            preSlow = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        // 循环结束后，slow指向链表中间的元素（元素个数为奇数），中间两个元素的后一个(元素个数为偶数)
        ListNode listA = head;  //指向前一个半链
        ListNode listB = slow;  //指向后一个半链。
        preSlow.next = null;  //将两个链断开。
        listA = sortList(listA);  // 对前一个半链递归分解合并排序
        listB = sortList(listB);  // 对后一个半链递归分解合并排序
        return merge(listA, listB); // 将有序的listA 和有序的listB合并排序
    }

    private ListNode merge(ListNode listA, ListNode listB) {
        ListNode dummy = new ListNode(0); // 作为临时链表的头节点，不存储实际内容
        ListNode nodeA = listA;
        ListNode nodeB = listB;
        ListNode nodeR = dummy;  // 指向临时链表的尾结点。

        while (nodeA != null && nodeB != null) {
            if (nodeA.val < nodeB.val) {
                nodeR.next = nodeA;
                nodeA = nodeA.next;
            } else {
                nodeR.next = nodeB;
                nodeB = nodeB.next;
            }
            //每次插入一个，维护nodeR指针指向尾结点。
            nodeR = nodeR.next;
        }

        if (nodeA != null) {
            // nodeA节点后面有剩余元素，则一并拼接为一条链，不需要逐个添加。
            nodeR.next = nodeA;
        }
        if (nodeB != null) {
            nodeR.next = nodeB;
        }
        return dummy.next;

    }
}

https://www.nowcoder.com/practice/152bc6c5b14149e49bf5d8c46f53152b?tpId=46&rp=1&ru=%2Fta%2Fclassic-code&qru=%2Fta%2Fclassic-code&difficulty=&judgeStatus=&tags=&title=&sourceUrl=&gioEnter=menu

题目CC5:(知识点：链表，排序，难度：较难)
使用插入排序对链表进行排序。
示例1
输入：
{30,20,40}

返回值：
{20,30,40}

代码：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode insertionSortList (ListNode head) {
        // write code here
        if (head == null || head.next == null) {
            return head;
        }
        // 至少两个节点
        ListNode p = head.next;  // 遍历p链表的每个元素，在有序链表head中寻找插入位置并插入。
        head.next = null; //初始化head链表，只有一个链表有序，后面扩充该有序表。

        

        while(p != null) {
            ListNode q = head; // q用来遍历有序链表
            ListNode r = p.next; // p插入有序表中会修改p.next,所以这里要保存。
            if (p.val < q.val) {
                //考虑特殊情况，插入位置为首结点前面。
                p.next = q;
                head = p;
                p = r;
            } else {
                while (q.next != null && p.val >= q.next.val) {
                    q = q.next;
                }
                p.next = q.next;
                q.next = p;
                p = r;
            }
        }
        return head;
    }
}

题目CC6：(知识点：二叉树，难度：中等)
用递归的方法对给定的二叉树进行后序遍历。
例如：
给定的二叉树为{1,#,2,3},

返回[3,2,1].

本题思路：后序遍历，针对每一个子树始终左子树、右子树、根递归遍历。

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型ArrayList
     */
    public ArrayList<Integer> postorderTraversal (TreeNode root) {
        // write code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) {
            return list;
        }
        ArrayList<Integer> leftList = new ArrayList<Integer>();
        ArrayList<Integer> rightList = new ArrayList<Integer>();
        
        leftList = postorderTraversal(root.left);
        
        rightList = postorderTraversal(root.right);
        
        list.addAll(leftList);
        list.addAll(rightList);
        list.add(root.val);
        return list;
    }
}

题目CC7：(知识点：栈，树，难度：简单)
求给定的二叉树的前序遍历。
例如：
给定的二叉树为{1,#,2,3},

返回：[1,2,3].

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型ArrayList
     */
    public ArrayList<Integer> preorderTraversal (TreeNode root) {
        // write code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) {
            return list;
        }

        list.add(root.val);

        ArrayList<Integer> leftList = new ArrayList<Integer>();
        ArrayList<Integer> rightList = new ArrayList<Integer>();
        
        leftList = preorderTraversal(root.left);
        
        rightList = preorderTraversal(root.right);
        
        list.addAll(leftList);
        list.addAll(rightList);
        
        return list;
    }
}

题目CC8:重排链表(知识点：链表，难度：中等)
将给定的单链表L:L0–>L1–>…–>Ln-1–>Ln
重新排序为：L0–Ln–>L1–>Ln-1–>L2–>Ln-2->…
要求使用原地算法，不能只改变节点内部的值，需要对实际的节点进行交换。

数据范围：链表长度 0≤n≤20000 ，链表中每个节点的值满足 0≤val≤1000

要求：空间复杂度 O(n) 并在链表上进行操作而不新建链表，时间复杂度 O(n)
进阶：空间复杂度 O(1) ， 时间复杂度 O(n)

示例1
输入：
{1,2,3,4}

返回值：
{1,4,2,3}

说明：
给定head链表1->2->3->4, 重新排列为 1->4->2->3,会取head链表里面的值打印输出 1

示例2
输入：
{1,2,3,4,5}

返回值：
{1,5,2,4,3}

说明：
给定head链表1->2->3->4->5, 重新排列为 1->5>2->4->3,会取head链表里面的值打印输出

示例3
输入：
{}

返回值：
{}

本题思路一：时间复杂度O(N):N是链表的节点数量，遍历链表，重组链表,空间复杂度O(1)：使用常数级空间指针。
1.使用快慢指针，快指针一次走两步，慢指针一次走一步，当快指针走到终点时，慢指针指向中点，若节点个数为偶数，则慢指针指向中间两个节点中的左端节点。
2.通过第一步拆分两个链表，对后一半链表逆序，用头插法
3.遍历逆序后的链表插入到第一个链表的对应位置。
代码：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public void reorderList(ListNode head) {
        if (head == null || head.next == null || head.next.next == null) {
            return;
        }
        // 用快慢指针寻找中间节点，将链表分为两个
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode newHead = slow.next;
        slow.next = null;

        // 第二个链表反转，这里考察单链表反转
        newHead = reverseList(newHead);

        // 链表节点依次连接
        while(newHead != null) {
            ListNode temp = newHead.next;
            newHead.next = head.next;
            head.next = newHead;
            head = newHead.next;
            newHead = temp;
        }
    }

    private ListNode reverseList(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode tail = head;
        head = head.next;
        tail.next = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = tail;
            tail = head;
            head = temp;
        }
        return tail;
    }
}

总结1：考察快慢指针，链表逆序（头插法），单链表插入操作等。

本题思路二：将链表放到一个ArrayList中，利用前后双指针，依次按题目要求插入链表。时间复杂度O(N),空间复杂度O(N)
代码：

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public void reorderList(ListNode head) {
        if (head == null || head.next == null || head.next.next == null) {
            return;
        }
        // 用快慢指针寻找中间节点，将链表分为两个
        List<ListNode> list = new ArrayList<>();
        while (head != null) {
            list.add(head);
            head = head.next;
        }
        // 设置两个指针
        int i = 0;  //前指针
        int j = list.size() - 1; //后指针，增加索引好寻找最后一个元素，以便从后往前遍历
        while (i < j) {
            list.get(i).next = list.get(j);
            i++;
            if (i == j) { // 链表节点只有两个时才会出现这种情况
                break;
            }
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null;
    }
}

总结2：这里关键是给单链表的每个元素增加了下标索引，使用ArrayList增加了O(N)的空间。

题目CC9：（知识点：链表，哈希，双指针，难度：中等）
给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。

数据范围： 0<=n<=10000，1<=结点值<=10000
要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2},{3,4,5}时，对应的环形链表如下图所示：
在这里插入图片描述

可以看到环的入口结点的结点值为3，所以返回结点值为3的结点。
输入描述：
输入分为2段，第一段是入环前的链表部分，第二段是链表环的部分，后台会根据第二段是否为空将这两段组装成一个无环或者有环单链表
返回值描述：
返回链表的环的入口结点即可，我们后台程序会打印这个结点对应的结点值；若没有，则返回对应编程语言的空结点即可。

示例1
输入：
{1,2},{3,4,5}

返回值：
3

说明：
返回环形链表入口结点，我们后台程序会打印该环形链表入口结点对应的结点值，即3

示例2
输入：
{1},{}

返回值：
“null”

说明：
没有环，返回对应编程语言的空结点，后台程序会打印"null"

示例3
输入：
{},{2}
复制
返回值：
2

说明：
环的部分只有一个结点，所以返回该环形链表入口结点，后台程序打印该结点对应的结点值，即2

本题思路一：hash法，使用HashSet存储已经遍历过的节点，当第一次出现重复的节点时，即为入口节点。时间复杂度：O(N),需要将链表的所有节点遍历一次；空间复杂度：需要额外的O(N)空间HashSet存储节点。
代码：

import java.util.*;
/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        HashSet<ListNode> set = new HashSet<>();
        if (pHead == null) {
            return null;
        }
        while (pHead != null) {
            // 当set中包含节点时，说明第一次出现重复的节点，即环的入口节点。
            if (set.contains(pHead)) {
                return pHead;
            }
            // set中加入未重复的节点
            set.add(pHead);
            pHead = pHead.next;
        }

        return null;
    }
}

本题思路二：快慢指针很容易判断是否有环，进入环中，二者间的相对距离每次减1，最终会相遇。假设从头节点到环的入口节点的前一个节点一共有a个，环中的节点有b个，设fast指针走过的节点数为f，slow指针走过的节点数为s，则：
(1) f=2s
(2) f=s+nb (f走的节点数一定与s走的节点数相差整数圈即nb)
由此得到s=nb.两指针相遇时满指针走了nb步。已知指针走到环的入口节点需要走a+kb步(k为整数)，而slow指针走了nb步，则其只要走a步即可到环的入口节点，这时将fast指针赋值为头节点，也移动a步后则fast和slow指针在环的入口节点相遇（编程的具体实现思想）。
时间复杂度：O(n)，n为链表节点数，以满指针为基准，遍历次数约为2次
空间复杂度：O(1)，只使用了两个指针变量，空间复杂度为常数。
代码：

import java.util.*;
/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if (pHead == null) return null;
        // 定义快慢指针
        ListNode slow = pHead;
        ListNode fast = pHead;
        while (fast != null && fast.next != null) {
            // 快指针是慢指针的两倍速度
            fast = fast.next.next;
            slow = slow.next;
            // 记录快慢指针第一次相遇的节点
            if (slow == fast) break;
        }
        // 若快指针指向null,则环不存在
        if (fast == null || fast.next == null) return null;
        // 将快指针重新指向头节点
        fast = pHead;
        // 与第一次相遇的节点相同速度出发    这里是这道题的核心点
        while (fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}

题目CC10 判断链表中是否有环
知识点：链表、哈希、双指针（快慢指针）
描述
判断给定的链表中是否有环。如果有环则返回true，否则返回false。
数据范围：链表长度 0 \le n \le 100000≤n≤10000，链表中任意节点的值满足 |val| <= 100000∣val∣<=100000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。
例如输入{3,2,0,-4},1时，对应的链表结构如下图所示：
在这里插入图片描述
可以看出环的入口结点为从头结点开始的第1个结点（注：头结点为第0个结点），所以输出true。
示例1
输入：{3,2,0,-4},1
返回值：true
说明：第一部分{3,2,0,-4}代表一个链表，第二部分的1表示，-4到位置1（注：头结点为位置0），即-4->2存在一个链接，组成传入的head为一个带环的链表，返回true
示例2
输入：{1},-1
返回值：false
说明：第一部分{1}代表一个链表，-1代表无环，组成传入head为一个无环的单链表，返回false
示例3
输入：{-1,-7,7,-4,19,6,-9,-5,-2,-5},6
返回值：true

此题与CC9题相关为其一部分，解题简单。
代码如下：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            // 若有环，则快慢指针终会相遇
            if (fast == slow) break;
        }
        // 无环
        if (fast == null || fast.next == null) return false;

        // 有环
        return true;

    }
}
stumiss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
牛客编程题---年会抽奖
weixin_43224539的博客
07-07 1586
题目描述: 今年公司年会的奖品特别给力，但获奖的规矩却很奇葩： 1. 首先，所有人员都将一张写有自己名字的字条放入抽奖箱中； 2. 待所有字条加入完毕，每人从箱中取一个字条； 3. 如果抽到的字条上写的就是自己的名字，那么“恭喜你，中奖了！” 现在告诉你参加晚会的人数，请你计算有多少概率会出现无人获奖？ 输入描述 输入包含多组数据，每组数据包含一个正整数n（2≤n≤20）。 输出...
产品经理刷leetcode-AlgorithmExercises:我的算法练习和笔记
06-30
产品经理刷leetcode Daily progress TO DO List 代码练习 算法图解 剑指offer Leetcode 简单计算机基础 JAVA 基础 C C++指针表达 计算机网络 网络基本概念（定义、分类、组成、体系结构等） 数据通信基础理论 物理层...
牛客-重排链表
weixin_41803339的博客
01-18 267
题目 将给定的单链表 L 0 →L 1→…→L n−1→L n 重新排序为： L 0→L n→L 1 →L n−1→L 2 →L n−2 →… 要求使用原地算法，不能只改变节点内部的值，需要对实际的节点进行交换。 数据范围：链表长度 0≤n≤20000 ，链表中每个节点的值满足 0≤val≤1000 要求：空间复杂度 O(n) 并在链表上进行操作而不新建链表，时间复杂度 O(n) 进阶：空间复杂度 O(1) ， 时间复杂度 O(n) 思路 找到中点，然后断开，将后面的链表反转，然后插入到前面的链表中。 代码
牛客编程题--必刷101之贪心算法
qq_36317312的博客
07-09 1462
贪⼼算法可以认为是动态规划算法的⼀个特例
牛客编程题--必刷101之模拟
qq_36317312的博客
07-13 1001
所谓的模拟题，运用的“模拟算法”，其实并没有什么完全准确的定义。模拟算法，用一句老话说，就是“照着葫芦画瓢”；官方化的诠释则是：根据题目表述进行筛选提取关键要素，按需求书写代码解决实际问题。模拟这个算法其实并不难，主要是逻辑上的麻烦，但正常刷题时我们都不把模拟的逻辑思维理清就直接做，如果这题没有太水的话，是非常容易错的。...
牛客编程题--必刷101之递归回溯篇
qq_36317312的博客
06-16 920
文章目录补充知识回溯算法经典问题之全排列1、没有重复项数字的全排列回溯 + 递归 补充知识 该补充知识内容是参考laluladong作者的算法文档 回溯算法 回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。 解决⼀个回溯问题，实际上就是⼀个决 策树的遍历过程 你只需要思考 3 个问题： 1、路径：也就是已经做出的选择。 2、选择列表：也就是你当前
牛客编程题--必刷101之字符串(高效刷题，举一反三)
qq_36317312的博客
06-30 1549
文章目录1、 字符串变形 1、 字符串变形 题目描述：对于一个长度为 n 字符串，我们需要对它做一些变形。 首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。 比如"Hello World"变形后就变成了"wORLD hELLO"。 输入：“This is a sample”,16 返回值： “SAMPLE A IS tHIS” ......
牛客编程题--必刷101之双指针篇
qq_36317312的博客
07-05 837
文章目录补充知识双指针左右指针快慢指针1、合并两个有序的数组 补充知识 双指针 双指针从广义上来说，是指用两个变量在线性结构上遍历而解决的问题。狭义上说， 对于数组，指两个变量在数组上相向移动解决的问题，也称为「左右指针」问题； 对于链表，指两个变量在链表上同向移动解决的问题，也称为「快慢指针」问题； 左右指针 首先判断是用左右指针还是快慢指针，这个可以根据数据结构来进行选择，如果给出的是一个数组，那么可以考虑用左右指针。左右指针在数组中实际是指两个索引值，⼀般初始化为 left = 0, right
牛客编程题--必刷101之二分查找篇
qq_36317312的博客
05-08 2415
文章目录17 二分查找-I18 二维数组中的查找19 寻找峰值20 数组中的逆序对 17 二分查找-I 题目描述：请实现无重复数字的升序数组的二分查找 要求：给定一个 元素升序的、无重复数字的整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标（下标从 0 开始），否则返回 -1 输入：[-1,0,3,4,6,10,13,14],13 返回值：6 说明：13 出现在nums中并且下标为 6 输入：[],3 返回值：-1 说明：nums为空，
牛客算法集合-类型划分和难度划分
wsmbnyzwn的博客
09-08 513
收集本人做的所有算法题，由简单到难，根据不同的题型进行划分，主要用java做的哦
java基础编程题day12--每日两题
weixin_48654011的博客
05-17 274
二进制插入_牛客题霸_牛客网 目录 二进制插入_牛客题霸_牛客网 查找组成一个偶数最接近的两个素数_牛客题霸_牛客网 二进制插入_牛客题霸_牛客网 给定两个32位整数n和m，同时给定i和j，将m的二进制数位插入到n的二进制的第j到第i位,保证n的第j到第i位均为零，且m的二进制位数小于等于i-j+1，其中二进制的位数从0开始由低到高。 测试样例： 1024，19，2，6 返回：1100 理解：拿测试用例画张图来给大家理解一下（主要看红色框框的图） 思路： 其实就是将m左移j位，
牛客面试算法top101（JAVA和C++）
04-30
牛客面试算法top101（JAVA和C++）是指牛客网提供的面试算法题库中的top101道题，涵盖了JAVA和C++两种编程语言。这些题目涵盖了算法刷题的基本知识和技巧，是面试算法的基础知识。 描述解读 牛客面试算法top101...
learning-note:我关于编程的学习笔记
04-01
我关于程序的学习笔记个人学习仓库，重新整理了之前的笔记库包含： JavaMySQL的算法数据结构leetcode，牛客等网站练习题读书笔记类别开源框架学习笔记测试
leetcode二维数组-programming_exercises:leetcode、nowcoder刷题之路
07-07
包含常见的编程网站的练习习题（leetcode、牛客等）----待完成中... 也同时包含复习面试的编程练习 该src/main/java目录下，以文件夹命名，表示的是不同的来源 每个文件均可单独运行 其他IDEA克隆项目时，注意配置...
leetcode中国-TheLastStand:争取代码实习，好的项目经验需要扎实的基础
06-29
leetcode中国 TheLastStand Fight For Code Internship，Good Project Experience ...两个网课，都是十分好的网课，应该够了，牛客网上的也可以再嚼一嚼，这样秋招笔试，基本不慌了，刷两个月 Java部分： J
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 485
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 396
【代码】力扣LCP 08.剧情触发时间。
day31||第八章 贪心算法 part01● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和
xburner01的博客
06-09 252
思路没问题，代码仔细想想吧。尽可能把大饼干给大胃口的人，先排序是关键。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 671
LeetCode 算法：轮转数组c++
牛客竞赛算法入门班怎么样
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值