1. 统计素数的个数： ```java

    public class 素数个数统计 { /**

    1.  * 统计n以内的素数的个数
    2.  * 素数： 只能被 1 和自身整除的自然数，0 1 除外
    3.  * 例如：输入 100 输出 25
    4.  * 重点考察： 埃筛法
    5.  */
    8. /**
    9.  * 先用暴力循环
    10.  */
    11. public static int bf(int n) {
    12.     int count = 0;
    13.     for (int i = 2; i < n; i++) {
    14.         count += isPrime(i) ? 1 : 0;
    15.     }
    16.     return count;
    17. }
    19. /**
    20.  * 判断这个数是不是素数
    21.  */
    22. private static boolean isPrime(int k) {
    23.     // 小于根号k 就可以了
    24.     for (int i = 2; i * i <= k; i++) {
    25.         if (k % i == 0) {
    26.             return false;
    27.         }
    28.     }
    29.     return true;
    30. }
    32. /**
    33.  * 埃筛法
    34.  */
    35. public static int eratosthenes(int n) {
    36.     // 初始化的时候全部是false
    37.     boolean[] isPrime = new boolean[n];
    38.     int count = 0;
    39.     for (int i = 2; i < n; i++) {
    40.         // 判断如果是素数的话
    41.         if (!isPrime[i]) {
    42.             count++;
    43.             // i 是合数，那么 i*2 一定是合数， i * 3 一定是合数， （ps : j+=i 目的就是为了产生3i,4i...）

    // for (int j = 2 i; j < n; j += i) { for (int j = i i; j < n; j += i) { isPrime[j] = true; } } } return count; }

    1. public static void main(String[] args) {
    2.     int k = 10000;
    3.     StopWatch stopWatch = new StopWatch();
    4.     stopWatch.start();
    5.     int bf = bf(k);
    6.     System.out.println(bf);
    7.     stopWatch.stop();
    8.     System.out.println(stopWatch.getTime());
    10.     stopWatch.reset();
    12.     stopWatch.start();
    13.     int eratosthenes = eratosthenes(k);
    14.     System.out.println(eratosthenes);
    15.     stopWatch.stop();
    16.     System.out.println(stopWatch.getTime());
    17. }

    }

    1. 链表反转的问题
    2. ```java
    3. package com.study.牛客.算法;
    5. public class 指定区域反转链表 {
    7.     /**
    8.      * 描述
    9.      * 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
    10.      * 例如：
    11.      * 给出的链表为 1\to 2 \to 3 \to 4 \to 5 \to NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
    12.      * 返回 1\to 4\to 3\to 2\to 5\to NULL1→4→3→2→5→NULL.
    13.      * <p>
    14.      * 数据范围： 链表长度 0 < size \le 10000<size≤1000，0 < m \le n \le size0<m≤n≤size，链表中每个节点的值满足 |val| \le 1000∣val∣≤1000
    15.      * 要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)
    16.      * 进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)
    17.      */
    19.     public static void main(String[] args) {
    20.         ListNode l1 = new ListNode(1);
    21.         ListNode l2 = new ListNode(2);
    22.         ListNode l3 = new ListNode(3);
    23.         ListNode l4 = new ListNode(4);
    24.         ListNode l5 = new ListNode(5);
    25.         l1.next = l2;
    26.         l2.next = l3;
    27.         l3.next = l4;
    28.         l4.next = l5;
    29.         Solution2 solution = new Solution2();
    30.         ListNode listNode = solution.reverseBetween(l1, 2, 4);
    31.         System.out.println(listNode);
    34.     }
    37. }
    39. class Solution2 {
    40.     /**
    41.      * 解法一：双指针(两次遍历)
    42.      * 思路步骤：
    43.      * 要反转局部链表，可以将该局部部分当作完整链表进行反转
    44.      * <p>
    45.      * 再将已经反转好的局部链表与其他节点建立连接，重构链表
    46.      * <p>
    47.      * 建议使用虚拟头节点的技巧，可以避免对头节点复杂的分类考虑，简化操作。
    48.      * <p>
    49.      * 反转前后图示：
    50.      */
    51.     public ListNode reverseBetween(ListNode head, int m, int n) {
    52.         //设置虚拟头节点
    53.         ListNode dummyNode = new ListNode(-1);
    54.         dummyNode.next = head;
    55.         // 首先要取到 m n 之间的链表
    56.         ListNode left = dummyNode;
    58.         for (int i = 0; i < m - 1; i++) {
    59.             left = left.next;
    60.         }
    62.         ListNode right = left;
    63.         for (int i = 0; i < n - m + 1; i++) {
    64.             right = right.next;
    65.         }
    67.         // 截取出一个子链表
    68.         ListNode leftNode = left.next;
    69.         ListNode cur = right.next;
    71.         // 切断链接
    72.         left.next = null;
    73.         right.next = null;
    75.         // 反转子链表
    76.         reserveListNode(leftNode);
    78.         // 拼接
    79.         left.next = right;
    80.         leftNode.next = cur;
    81.         return dummyNode.next;
    83.     }
    85.     private void reserveListNode(ListNode sub) {
    86.         ListNode pre = null;
    87.         while (sub != null) {
    88.             ListNode next = sub.next;
    89.             sub.next = pre;
    90.             pre = sub;
    91.             sub = next;
    92.         }
    93.     }
    96. }