版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_39776901/article/details/83216746
开始各种笔试了，从明天起会高频不定期的更新各种题，java的，flag在这里立起来！一起加油！
1、分解质因数
import java.util.Scanner;
/*
* 分解质因数
*/
public class Prime_Factorization {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
prime_factorization(n);
in.close();
}
public static void prime_factorization(int n) {
if (n < 2) {
throw new RuntimeException("参数错误");
}
for(int i = 2;i * i < n;i++) {
while(n % i == 0) {
System.out.print(i + " ");
n /= i;
}
}
if(n != 1) {
System.out.println(" " + n);
}
}
}
2、输出1~n之间的所有素数
import java.util.Scanner;
/*
* 输出1~n之间的所有素数
*/
public class Print_Prime {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
print_prime(n);
in.close();
}
public static void print_prime(int n) {
if(n < 2) {
return;
}
System.out.print(2 + " ");
//直接看奇数
for(int i = 3; i < n;i += 2) {
int j;
for(j = 2;j < Math.sqrt(i);j++) {
if(i % j == 0) {
break;
}
}
if(j == (int)Math.sqrt(i) + 1) {
System.out.print(i + " ");
}
}
}
}
3、快速排序
/*
* 快速排序
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {11,55,3,4,7,99,5};
new QuickSort().quickSort(arr,0,arr.length - 1);
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + " ");
}
}
public void quickSort(int[] arr,int L,int R) {
int i = L;
int j = R;
int pivot = arr[(L + R) >> 1];
while(i <= j) {
while(arr[i] < pivot) {
i++;
}
while(arr[j] > pivot) {
j--;
}
if(i <= j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
if(j > L) {
quickSort(arr, L, j);
}
if (i < R) {
quickSort(arr, i, R);
}
}
}
4、插入排序
/*
* 插入排序
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {11,55,3,4,7,99,5};
new InsertSort().insertSort(arr);
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + " ");
}
}
public void insertSort(int[] arr) {
for(int i = 1;i < arr.length;i++) {
int value = arr[i];
int j;
for(j = i - 1;j >= 0;j--) {
if (value < arr[j]) {
arr[j + 1] = arr[j];
}else if(value >= arr[j]) {
break;
}
}
arr[j + 1] = value;
}
//第二种写法，其实一样
// for(int i = 1;i < arr.length;i++) {
// int value = arr[i];
// int j = i - 1;
// while(j >= 0 && arr[j] > value) {
// arr[j + 1] = arr[j];
// j--;
// }
// arr[++j] = value;
// }
}
}
5、选择排序
/*
* 选择排序
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {11,55,3,4,7,99,5};
new SelectSort().selectSort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public void selectSort(int[] arr) {
for(int i = 0;i < arr.length - 1;i++) {
int minIndex = i;
for(int j = i + 1;j < arr.length;j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j;
}
}
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
6、冒泡排序
/*
* 冒泡排序
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {11,55,3,4,7,99,5};
new BubbleSort().bubbleSort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public void bubbleSort(int[] arr) {
for(int i = 0;i < arr.length - 1;i++) {
for(int j = 0;j < arr.length - i - 1;j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
7、二分查找（递归与非递归）
/*
* 二分查找（递归与非递归）
*/
public class BinarySearch{
public static void main(String[] args) {
//注意二分查找针对的是有序数列
int[] arr = {3,4,5,7,11,55,99};
int n1 = new BinarySearch().binarySearch1(arr,55);
int n2 = new BinarySearch().binarySearch2(arr,0,arr.length,99);
System.out.println(n1);
System.out.println(n2);
}
/*
* 非递归
*/
public int binarySearch1(int[] arr,int k) {
int i = 0;
int j = arr.length - 1;
//注意这里一定要是<=
while(i <= j) {
int mid = (i + j) >> 1;
if (arr[mid] == k) {
return mid;
}else if (arr[mid] < k) {
i = mid + 1;
}else {
j = mid - 1;
}
}
return -1;
}
/*
* 递归
*/
public int binarySearch2(int[] arr,int left,int right,int k) {
//注意终止条件
if (left > right) {
return -1;
}
int mid = (left + right) >> 1;
if(arr[mid] == k) {
return mid;
}else if(arr[mid] < k) {
return binarySearch2(arr, mid + 1, right, k);
}else {
return binarySearch2(arr, left, mid - 1, k);
}
}
}
8、堆排序
public class HeapSort {
public static void main(String[] args) {
int[] arr = {11,55,3,4,7,99,5};
heapSort(arr);
}
public static void heapSort(int[] arr) {
//建立初始堆
//(arr.length-1)/2最后一个非叶子节点
for(int i = (arr.length - 1) / 2;i >= 0;i--) {
heapOne(arr,arr.length,i);
}
int n = arr.length;
while(n > 0) {
System.out.print(arr[0] + " ");
arr[0] = arr[n - 1];
n--;
heapOne(arr, n, 0);
}
}
//n：堆中的有效数据 k：待筛选节点，让k节点落到底层
public static void heapOne(int[] arr,int n,int k) {
int k1 = 2 * k + 1;//左孩子
int k2 = 2 * k + 2;//右孩子
if(k1 >= n && k2 >= n) {//已经是叶子节点
return;
}
int a1 = Integer.MAX_VALUE;
int a2 = Integer.MAX_VALUE;
if(k1 < n) {
a1 = arr[k1];//左孩子值
}
if(k2 < n) {
a2 = arr[k2];//右孩子值
}
//已经符合堆的要求
if (arr[k] <= a1 && arr[k] <= a2) {
return;
}
//找到左右孩子中最小的，和它交换
if (a1 < a2) {
int temp = arr[k];
arr[k] = arr[k1];
arr[k1] = temp;
heapOne(arr, n, k1);//继续筛选子树
}else {
int temp = arr[k];
arr[k] = arr[k2];
arr[k2] = temp;
heapOne(arr, n, k2);//继续筛选子树
}
}
}
9、反转单链表
/*
* 反转单链表
*/
class Node{
int value;
Node next;
public Node(int data) {
this.value = data;
}
}
public class ReverseSignleList {
public static void main(String[] args) {
Node node = new Node(5);
node.next = new Node(4);
node.next.next = new Node(3);
node.next.next.next = new Node(2);
node.next.next.next.next = new Node(1);
Node head = reverse(node);
while(head != null) {
System.out.print(head.value + " ");
head = head.next;
}
}
public static Node reverse(Node head) {
Node cur = null;
Node next = null;
while(head != null) {
next = head.next;
head.next = cur;
cur = head;
head = next;
}
return cur;
}
}
10、反转双向链表
/*
* 反转双向链表
*/
class DoubleNode{
int value;
DoubleNode pre;
DoubleNode next;
public DoubleNode(int data) {
this.value = data;
}
}
public class ReverseDoubleList {
public static void main(String[] args) {
DoubleNode node = new DoubleNode(5);
node.next = new DoubleNode(4);
node.pre = null;
node.next.next = new DoubleNode(3);
node.next.pre = node;
node.next.next.next = new DoubleNode(2);
node.next.next.pre = node.next;
node.next.next.next.next = new DoubleNode(1);
node.next.next.next.pre = node.next.next;
node.next.next.next.next.next = null;
DoubleNode head = reverse(node);
DoubleNode tail = null;
while(head != null) {
System.out.print(head.value + " ");
tail = head;
head = head.next;
}
System.out.println();
while(tail != null) {
System.out.print(tail.value + " ");
tail = tail.pre;
}
}
public static DoubleNode reverse(DoubleNode head) {
DoubleNode pre = null;
DoubleNode next = null;
while(head != null) {
next = head.next;
head.next = pre;
head.pre = next;
pre = head;
head = next;
}
return pre;
}
}
11、用一个栈实现另一个栈的排序
/*
* 用一个栈实现另一个栈的排序
*/
import java.util.Stack;
public class SortStackByStack {
Stack<Integer> stackData = null;
Stack<Integer> stackHelp = null;
public SortStackByStack() {
stackData = new Stack<>();
stackHelp = new Stack<>();
stackData.push(3);
stackData.push(4);
stackData.push(5);
stackData.push(2);
stackData.push(6);
stackData.push(7);
}
public static void main(String[] args) {
SortStackByStack s = new SortStackByStack();
s.sortStackByStack();
while(!s.stackData.isEmpty()) {
System.out.print(s.stackData.pop() + " ");
}
}
public void sortStackByStack() {
while(!stackData.isEmpty()) {
int cur = stackData.pop();
if (stackHelp.isEmpty() || cur >= stackHelp.peek()) {
stackHelp.push(cur);
}else {
while(!stackHelp.isEmpty() && stackHelp.peek() > cur) {
stackData.push(stackHelp.pop());
}
stackHelp.push(cur);
}
}
while(!stackHelp.isEmpty()) {
stackData.push(stackHelp.pop());
}
}
}
12、设计一个具有getMin()功能的栈（两种方式）
/*
* 用两种方式设计一个具有getMin功能的栈
*/
import java.util.Stack;
public class StackWithGetMin {
public static void main(String[] args) {
MyStack1 stack1 = new MyStack1();
stack1.push(5);
stack1.push(6);
stack1.push(2);
stack1.push(3);
stack1.push(7);
stack1.push(1);
System.out.println("当前最小值：" + stack1.getMin());
System.out.println("弹出：" + stack1.pop());
System.out.println("当前最小值" + stack1.getMin());
MyStack1 stack2 = new MyStack1();
stack2.push(5);
stack2.push(6);
stack2.push(2);
stack2.push(3);
stack2.push(7);
stack2.push(1);
System.out.println("当前最小值：" + stack2.getMin());
System.out.println("弹出：" + stack2.pop());
System.out.println("当前最小值" + stack2.getMin());
}
}
class MyStack1{
Stack<Integer> stackData = null;
Stack<Integer> stackMin = null;
public MyStack1() {
stackData = new Stack<>();
stackMin = new Stack<>();
}
public void push(int data) {
if (stackMin.isEmpty()) {
stackMin.push(data);
}else if (data < stackMin.peek()) {
stackMin.push(data);
}
stackData.push(data);
}
public int pop() {
if (stackData.isEmpty()) {
throw new RuntimeException("栈为空");
}
int value = stackData.pop();
if (value == stackMin.peek()) {
stackMin.pop();
}
return value;
}
public int getMin() {
return stackMin.peek();
}
}
class MyStack2{
Stack<Integer> stackData = null;
Stack<Integer> stackMin = null;
public MyStack2() {
stackData = new Stack<>();
stackMin = new Stack<>();
}
public void push(int data) {
if (stackMin.isEmpty()) {
stackMin.push(data);
}else if (data < stackMin.peek()) {
stackMin.push(data);
}else if(data > stackMin.peek()) {
stackMin.push(stackMin.peek());
}
stackData.push(data);
}
public int pop() {
if (stackData.isEmpty()) {
throw new RuntimeException();
}
stackMin.pop();
return stackData.pop();
}
public int getMin() {
return stackMin.peek();
}
}
13、单例设计模式
/*
* 单例设计模式：保证一个类仅有一个实例，并提供一个访问他的全局访问点
* （1）单例类只能有一个实例
* 这是最基本的，真正做到整个系统中唯一并不容易，通常还要考虑反射破坏，序列化/反序列化，对象垃圾回收等问题
* （2）单例类必须自己创建自己的唯一实例
* 通常给实例构造函数protected或private权限
* （3）单例类必须给所有其他对象提供这一实例
* 通常定义静态方法getInstance()返回
*
* 优点：
* 1、提供了唯一实例的受控访问，避免对资源的多重占用
* 2、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
* 3、缩小名空间，避免全局变量污染空间，但比类操作更灵活
* 缺点：
* 1、由于单例模式没有抽象层，因此单例类的扩展有很大的困难
* 2、单例类的职责过重，在一定程度上违背了“单一职责原则”
*/
//饿汉式（简单可用）
//优点：没有加锁，执行效率会提高
//缺点：没有Lazy初始化，可能有时候不需要使用，浪费内存
class SignleTon{
private static SignleTon instance = null;
private SignleTon() {}
public static SignleTon getInstance() {
if (instance == null) {
instance = new SignleTon();
}
return instance;
}
}
public class Signleton {
private static Signleton instance = new Signleton();
private Signleton() {}
public static Signleton getInstance() {
return instance;
}
}
//懒汉式（线程不安全）
class Signleton1{
private static Signleton1 instance = null;
private Signleton1() {}
public static Signleton1 getInstance() {
if (instance == null) {
instance = new Signleton1();
}
return instance;
}
}
//同步方法的懒汉式（效率低）
class Signleton2{
private static Signleton2 instance = null;
private Signleton2() {}
public static synchronized Signleton2 getInstance() {
if (instance == null) {
instance = new Signleton2();
}
return instance;
}
}
//双重校验锁（可用，但还是会有问题，如指令重排序）
class Signleton3{
private static Signleton3 instance = null;
private Signleton3() {}
public static Signleton3 getInstance() {
if (instance == null) {
synchronized (Signleton3.class) {
if (instance == null) {
instance = new Signleton3();
}
}
}
return instance;
}
}
//静态内部类
class Signleton4{
private static class SignletonHolder{
private static final Signleton4 INSTANCE = new Signleton4();
}
private Signleton4() {}
public static final Signleton4 getInstance() {
return SignletonHolder.INSTANCE;
}
}