- 一、链表反转
- 1.迭代法
- 2.递归法
- 二、统计 n 以内 的 素数个数
- 1.暴力算法（直接循环无脑开找）
- 2.埃筛法（重点）
//链表反转：1.迭代法
private static linkNode getFZ0(linkNode linkNode){
//前一个
linkNode prev=null;//前一个节点
linkNode next;//下个节点
linkNode curr=linkNode;//当前的这个
while (curr!=null){
next=curr.next;//下个节点
curr.next=prev;//把当前这个的下个节点指向前一个
prev=curr;//对于后面的来说，前一个其实就是这个
curr=next;//为了迭代，需要把本个循环里的主体换成下一个
}
//返回最后那个节点
return prev;
}
}
2.递归法
//链表反转：2.递归
private static linkNode getFZ1(linkNode linkNode){
//无需反转的情况
if(linkNode==null||linkNode.next==null){
return linkNode;
}
//为了使用递归，我们需要找到最后一个节点，然后从最后一个节点来开始
linkNode newlinkNode = getFZ1(linkNode.next);// 一次一次的递归，直到找到最后一个节点
linkNode.next.next=linkNode;//递归处理的话，下一个的下一个 是自己，这样的话就把指针的方向180度转换了
linkNode.next=null; //把两个里面的下一个制成null
return newlinkNode;
}
源码实验 ( 需要以打断点的形式来看！！！)：
package com.example.rabbitmq;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.rabbitmq.mapper.UserMapper;
import com.example.rabbitmq.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.math.BigDecimal;
import java.util.Map;
import java.util.UUID;
@SpringBootTest
class SuanfaApplicationTests {
//模拟链表
static class linkNode{
private Integer v;
private linkNode next;
public linkNode(Integer v, linkNode next) {
this.v = v;
this.next = next;
}
}
//链表反转：1.迭代法
private static linkNode getFZ0(linkNode linkNode){
//前一个
linkNode prev=null;//前一个节点
linkNode next;//下个节点
linkNode curr=linkNode;//当前的这个
while (curr!=null){
next=curr.next;//下个节点
curr.next=prev;//把当前这个的下个节点指向前一个
prev=curr;//对于后面的来说，前一个其实就是这个
curr=next;//为了迭代，需要把本个循环里的主体换成下一个
}
//返回最后那个节点
return prev;
}
//链表反转：2.递归
private static linkNode getFZ1(linkNode linkNode){
//为了使用递归，我们需要从最后一个节点来开始
if(linkNode==null||linkNode.next==null){
return linkNode;
}
linkNode newlinkNode = getFZ1(linkNode.next);// 一次一次的递归，直到找到最后一个节点
linkNode.next.next=linkNode;//递归处理的话，下一个的下一个 是自己，这样的话就把指针的方向180度转换了
linkNode.next=null; //把两个里面的下一个制成null
return newlinkNode;
}
@Test
public void sf0(){
linkNode linkNode5 = new linkNode(5, null);
linkNode linkNode4 = new linkNode(4, linkNode5);
linkNode linkNode3 = new linkNode(3, linkNode4);
linkNode linkNode2 = new linkNode(2, linkNode3);
linkNode linkNode1 = new linkNode(1, linkNode2);
//迭代法处理链表反转
// linkNode fz0 = getFZ0(linkNode1);
// System.out.println(fz0.toString());
//递归
linkNode fz1 = getFZ1(linkNode1);
System.out.println(fz1.toString());
}
}
断点查看到的反转结果：
素数：只能被1或者自身整除的自然数，0、1除外
1.暴力算法（直接循环无脑开找） //1. 暴力算法
public static String getCount(int n){
//计数器
int c=0;
//遍历
for (int i = 2; i < n; i++) {
c+=checkSS_YH(i)?1:0;
}
return n+"以内的素数个数为："+c;
}
//判断传入的是否为素数
private static boolean checkSS(int x){
for (int i = 2; i
2.埃筛法（重点）
- 利用合数的概念（非素数），素数 * n 必然是合数，因此何以从2开始遍历，将会所有的合数做上标记.
public static String eratosthenes(int n){
boolean[] isPrime=new boolean[n];
int ans=0;
for (int i=2;i
源码实验：
package com.example.rabbitmq;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SuanfaApplicationTests2 {
//1. 暴力算法
public static String getCount(int n){
//计数器
int c=0;
//遍历
for (int i = 2; i < n; i++) {
c+=checkSS(i)?1:0;
}
return n+"以内的素数个数为："+c;
}
//判断传入的是否为素数
private static boolean checkSS(int x){
for (int i = 2; i
返回结果：
