蓝桥杯一些常用基础知识点的总结

最新推荐文章于 2022-03-22 20:27:36 发布

涤生啊

最新推荐文章于 2022-03-22 20:27:36 发布

阅读量576

点赞数

分类专栏：蓝桥杯，算法文章标签： java 算法

本文链接：https://blog.csdn.net/qq_45902401/article/details/117605585

版权

蓝桥杯，算法专栏收录该内容

14 篇文章 6 订阅

订阅专栏

4.预备知识

1.scanner的使用

https://blog.csdn.net/DoneSpeak/article/details/77800632

https://bbs.csdn.net/topics/390855651

2.java栈的使用

https://blog.csdn.net/qq_42124842/article/details/91420306

3.栈和队列

https://www.cnblogs.com/xumz/p/7724934.html

https://www.cnblogs.com/yangyongjie/p/11154100.html

https://www.cnblogs.com/mfrbuaa/p/3871634.html

4.java文件读取操作

https://www.runoob.com/java/java-files-io.html

https://blog.csdn.net/LiBoom/article/details/80885204

system.in()

https://www.nhooo.com/note/qa0zsv.html

5.sort()的使用

public class test2 {
	public static void main(String[] args) {
		Integer[] n = {1,2,3,4,5,6};
		int[] j = new int[n.length];
		//下标从0开始，[ )区间
		//Collections.reverseOrder(),降序，但要是Integer[]类型的
//		 Arrays.sort(n,Collections.reverseOrder());
		 Arrays.sort(n,1,5, Collections.reverseOrder());
		for (int i = 0; i < n.length; i++) {
			System.out.print(n[i]+" ");
		}
	}
}

6.图的表示

https://blog.csdn.net/qq_38410730/article/details/79587747

邻接矩阵

class Graph{
	private int[] vertexts;//存放顶点;
	private int[][] matrix;//邻接数组
	
	public Graph(int[] vertexts, int[][] matrix) {
		super();
		this.vertexts = vertexts;
		this.matrix = matrix;
	}
	
	private void show() {
		for (int[] mm : matrix) {
			System.out.println(Arrays.toString(mm));
		}
	}
	
	
}

前面的邻接矩阵方法实际上是图的一种静态存储方法。建立这种存储结构时需要预先知道图中顶点的个数。如果图结构本身需要在解决问题的过程中动态地产生，则每增加或者删除一个顶点都需要改变邻接矩阵的大小，显然这样做的效率很低。除此之外，邻接矩阵所占用的存储单元数目至于图中的顶点的个数有关，而与边或弧的数目无关，若图是一个稀疏图的话，必然造成存储空间的浪费。邻接表很好地解决了这些问题。

邻接表的存储方式是一种顺序存储与链式存储相结合的存储方式，顺序存储部分用来保存图中的顶点信息，链式存储部分用来保存图中边或弧的信息。具体的做法是，使用一个一维数组保存图中顶点的信息，数组中每个数组元素包含两个域。其存储结构如下：

邻接表

//实现图的邻接表结构
class Edge {//边：作为邻接表中每个结点的边链表的元素，例如结点A和B构成边e1，那么A拥有e1，在A的边链表中，e1的verAdj = B
    int verAdj;//顶点序号
    int weight;//权重
    Edge nextEdge;//如果结点A拥有多条边，边构成链表，例如e1->e2->...->en
}
class Vertex{
    int verName;//顶点序号
    Edge edgeHead;//边链表的头指针
}
public class Graph {
    private Vertex[] vertexs;//存贮所有顶点
    private boolean isDirected;//若为有向图，则isDirected为true
}

7.GCD和LCM

https://www.cnblogs.com/echoing/p/7878954.html

最大公约数(Greatest Common Divisor(GCD))
最小公倍数(Least Common Multiple(LCM))

由于两个数的乘积等于这两个数的最大公约数与最小公倍数的积。即（a，b）×[a，b]=a×b。所以，求两个数的最小公倍数，就可以先求出它们的最大公约数，然后用上述公式求出它们的最小公倍数。

public class 最大公约数 {
	public static void main(String[] args) {
		System.out.println(gcd(10,5));
	}

	private static int gcd(int n1,int n2) {
		if(n1<n2) {
			int tem = n1;
			n1 = n2;
			n2 = tem;
		}
		
		while (n1%n2 > 0) {
			n1 = n1%n2;
			
			if (n1%n2 == 0) {
				return n2;
			}
		}
		return n2;
	}
}

8.二叉树的表示

构建节点

public class Node {
 
	public long data;
	public Node leftChild;
	public Node rightChild;
		
	/*
	 * 构造方法
	 */
	public Node(long data) {
		this.data=data;
	}
}

构建二叉树

public class Trees {
 
	public Node root;
	
	/*
	 * 插入节点
	 */
	
	public void insert(long value) {
		//封装节点
		Node newNode = new Node(value);
		//引用当前节点
		Node current = root;
		//引用父节点
		Node parent;
		//如果root为null，也就是第一插入的时候
		if(root==null) {
			root = newNode;
			return;
		}else {
			while(true) {
				//父节点指向当前节点
			parent = current;
			//如果当前节点指向的节点数据比插入的要大，则新节点往左走
			if(current.data > value) {
				current = current.leftChild;
				
				if(current == null) {
					
					parent.leftChild = newNode;
					return;
				}
            //如果当前节点指向的节点数据比插入的要小，则新节点往右走    
			}else {
				current = current.rightChild;
				if(current==null) {
					parent.rightChild = newNode;
					return;
				}
			}
		}
	}
	
	//寻找节点
	private void find(long value) {
		
	}
	//删除节点
	private void delete() {
		
	}
}

9.树的存贮

https://blog.csdn.net/weixin_44489823/article/details/93171144

10.BigInteger

https://blog.csdn.net/qq_41668547/article/details/87628618

11.DecimalFormat

public class TestNumberFormat{ 
　　public static void main(String[]args){
　　　　double pi = 3.1415927;　//圆周率
　　　　//取一位整数
　　　　System.out.println(new DecimalFormat("0").format(pi));　　　//3
　　　　//取一位整数和两位小数
　　　　System.out.println(new DecimalFormat("0.00").format(pi));　//3.14
　　　　//取两位整数和三位小数，整数不足部分以0填补。
　　　　System.out.println(new DecimalFormat("00.000").format(pi));// 03.142
　　　　//取所有整数部分
　　　　System.out.println(new DecimalFormat("#").format(pi));　　　//3
　　　　//以百分比方式计数，并取两位小数
　　　　System.out.println(new DecimalFormat("#.##%").format(pi));　//314.16%
　　 　 long c =299792458;　　//光速
　　　　//显示为科学计数法，并取五位小数
　　　　System.out.println(new DecimalFormat("#.#####E0").format(c));　//2.99792E8
　　　　//显示为两位整数的科学计数法，并取四位小数
　　　　System.out.println(new DecimalFormat("00.####E0").format(c));　//29.9792E7
　　　　//每三位以逗号进行分隔。
　　　　System.out.println(new DecimalFormat(",###").format(c));　　　//299,792,458
　　　　//将格式嵌入文本
　　　　System.out.println(new DecimalFormat("光速大小为每秒,###米。").format(c));
  
　　}
  
}

12.Comparable接口的实现与使用

https://www.cnblogs.com/xiatom/p/10784850.html

https://www.cnblogs.com/sowhat1412/p/12734137.html

Comparable

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class test {
	public static void main(String[] args) {
		List<Person> list = new ArrayList<Person>();
		list.add(new Person("张三",14));
		list.add(new Person("lisi",12));
		list.add(new Person("wangwu",16));
		Collections.sort(list,Collections.reverseOrder());
		for (Person person : list) {
			System.out.println(person.name);
		}
	}
}

class Person implements Comparable<Person>{
	String name;
	int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	/*接口中通过x.compareTo(y)来比较x和y的大小。若返回负数，意味着x比y小；返回零，意味着x等于y；返回正数，意味着x大于y。
	*/
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return this.age - o.age;
	}
}

Comparator

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class test2 {
	public static void main(String[] args) {
		List<Person> list = new ArrayList<Person>();
		list.add(new Person("张三",14));
		list.add(new Person("lisi",12));
		list.add(new Person("wangwu",16));
		Collections.sort(list);
		for (Person person : list) {
			System.out.println(person.name);
		}
	}
}

class Person2 implements Comparator<Person2>{
	String name;
	int age;
	
	public Person2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	/*
	int compare(T o1, T o2)和上面的x.compareTo(y)类似，定义排序规则后返回正数，零和负数分别代表大于，等于和小于。
	*/
    
	@Override
	public int compare(Person2 o1, Person2 o2) {
		
		return o1.age - o2.age;
	}


}