Android小白

public class Main { public static void main(String[] args) { int[] array = {3,2,4,1,5}; int[] temp = new int[array.length]; radixSort(array); System.out.println(Arrays.toString(array)); } //基数排序 public stat

骑士周游问题又叫马踏棋盘问题1.未优化前（没有策略）public class Main { //定义棋盘的行数和列数 static int X = 8; static int Y = 8; //定义棋盘上的某个点是否被访问过 static boolean[] isVisited; //记录是否周游结束 static boolean isFinished = false; public static void main(String[]

学习资料迪杰斯特拉计算的是单源最短路径，而弗洛伊德计算的是多源最短路径代码public class Main { //不能设置为Integer.MAX_VALUE，否则两个Integer.MAX_VALUE相加会溢出导致出现负权 public static int MaxValue = 10000; public static int[][] path; public static void main(String[] args) { //创建顶点和边

推荐资料推荐学习文章代码public class Main { //不能设置为Integer.MAX_VALUE，否则两个Integer.MAX_VALUE相加会溢出导致出现负权 public static int MaxValue = 10000; public static void main(String[] args) { //创建顶点和边 char[] data = {'A','B','C','D','E','F','G'};

Kruskal算法有两个要求：①对图的所有边按照权值大小进行排序。②将边添加到最小生成树中时，怎么样判断是否形成了回路。①很好解决，采用排序算法进行排序即可。②处理方式是:记录顶点在"最小生成树"中的终点，顶点的终点是"在最小生成树中与它连通的最大顶点"。然后每次需要将一条边添加到最小生存树时判断该边的两个顶点的终点是否重合，重合的话则会构成回路。如何判断回路？将所有顶点按照从小到大的顺序排列好之后，某个顶点的终点就是"与它连通的最大顶点"。我们加入的边的两个顶点不能都指向同一个终点，否则构成回

问题①胜利乡有7个村庄(A, B,C,D,E,F,G)，现在需要修路把7个村庄连通②各个村庄的距离用边线表示(权)，比如A-B距离5公里③问:如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?代码重点理解createMinTree中的三层for循环public class Main { public static void main(String[] args) { char[] data = {'A','B','C','D','E','F','G'};

例题假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。如何选择最少的广播台，让所有的地区都可以接收到信号代码public class Main { public static void main(String[] args) { /** * 1.首先创建总的广播台和电视台 */ //创建一个总的 能装得下所有的广播台和电视台 HashMap<String, HashSet<Strin

推荐学习文章推荐文章代码public class Main { public static void main(String[] args) { // int i = violenceMatch("我是 我是最 我是最帅的", "我是最帅的"); System.out.println(Arrays.toString(getNext("aabaaf"))); System.out.println(KMP(getNext("aabaaf

1.动态规划算法动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。(即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解)2.背包问题（01背包）有一个背包，容量为4磅，现有如下物品①要求达到的目标为装入的背包的总价值最大，并且重量不超出②要求装入的物品不能重复①只有二维数组的版本public class Main {

1.应用分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题…直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，二分查找，傅立叶变换(快速傅立叶变换)，汉诺塔问题2.汉诺塔问题public static void main(String[] args) { int[] arr = {1,1,2,2,33};

1.递归实现①不考虑相同数/** * 二分查找，不考虑有相同数的情况（递归） * @param arr * @param left * @param right * @param findVal * @return */public static int binarySearch(int[] arr,int left,int right,int findVal){ if (left > right || arr[0] > findVal || arr[arr.leng

代码public class Main { //用集合存储各个顶点 static ArrayList<String> vertexList; //用二维数组存储各个边（邻接矩阵） static int[][] edges; //保存边的数目 static int numOfEdges = 0; //表示此顶点有没有被访问到 static boolean[] isVisited; public static void ma

代码public class Main { //用集合存储各个顶点 static ArrayList<String> vertexList; //用二维数组存储各个边（邻接矩阵） static int[][] edges; //保存边的数目 static int numOfEdges = 0; //表示此顶点有没有被访问到 static boolean[] isVisited; public static void ma

代码public class Main { //用集合存储各个顶点 static ArrayList<String> vertexList; //用二维数组存储各个边（邻接矩阵） static int[][] edges; //保存边的数目 static int numOfEdges = 0; public static void main(String[] args) { String[] vertexs = {"A"

代码public class Main { public static void main(String[] args) { int[] arr = {10,11,6,9,7,8}; AVLTree binarySortTree = new AVLTree(); for (int i = 0;i < arr.length;i++){ binarySortTree.add(new Node(arr[i]));

代码public class Main { public static void main(String[] args) { int[] arr = {7,3,10,12,5,1,9,2}; BinarySortTree binarySortTree = new BinarySortTree(); for (int i = 0;i < arr.length;i++){ binarySortTree.add(new Nod

代码public class Main { public static void main(String[] args) { String srcFile = "e://des.zip"; String desFile = "e://222.jpg"; //zipFile(srcFile,desFile); unZipFile(srcFile,desFile); } static Map<Byte,String&

代码public class Main { public static void main(String[] args) { String datas = "i like like like java do you like a java"; //首先编码 得到字节数组 byte[] bytes = huffmanZip(datas.getBytes()); System.out.println(Arrays.toString(by

代码public class Main { public static void main(String[] args) { int[] arr = {9,8,7}; Node huffmanTree = createHuffmanTree(arr); huffmanTree.preList(huffmanTree);// List<Node> nodeList = new ArrayList<Node>()

代码public class Main { public static void main(String[] args) { int[] arr = {9,8,7,6,5,4,3,2,1}; sort(arr); System.out.println(Arrays.toString(arr)); } public static void sort(int[] arr){ //完全二叉树 以数组方式存放 则第一个非叶

1.概念n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索")例如为10的这个节点，它的前驱节点为3，后继节点为1.2.中序线索化代码public class Main { public static void main(String[] args) { HeroNode root = new HeroNode(1, "tom" ); HeroNode node

代码public class Main { public static void main(String[] args) { int[] arr = {1,2,3,4,5,6,7}; /** * 1 * 2 3 * 4 5 6 7 * * 前序遍历 应该是 *

手动创建一个二叉树 如图代码public class Main { public static void main(String[] args) { //手动创建树 HeroNode heroNode1 = new HeroNode(1,"宋江"); HeroNode heroNode2 = new HeroNode(2,"吴用"); HeroNode heroNode3 = new HeroNode(3,"卢俊义");

代码我觉得哈希表主要是散列函数的应用以及链表的综合使用。而散列函数是我们规定的public class Main { public static void main(String[] args) { Employer zhangsan = new Employer(1,"张三"); Employer lisi = new Employer(7,"李四"); Employer wangwu = new Employer(5,"王五");

推荐博客代码public class Main { public static void main(String[] args) { int arr2[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}; System.out.println(fibonacciSearch(arr2,6)); } //得到斐波那契数列 public static int[] getFibonacci(i

介绍插值查找算法类似于二分查找，不同的是插值查找每次从**自适应mid**处开始查找。也就是int mid = left +(right - left)* (findVal - arr[left])/ (arr[right]-arr[left])代码public static void main(String[] args) { int arr2[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; System.out.

不考虑相同元素代码//没有考虑数相同的情况public static int binarySearch(int[] arr,int left,int right,int findVal){ //当遍历完整个数组还没有找到的时候，返回-1 if (left > right){ return -1; }else { int mid = (left + right) / 2; if (arr[mid] > fin

代码public class Main { public static void main(String[] args) { int arr[] = {998, 7, 1, 2, 9, 3, 936, 5, 4, 6, 0}; radixSort(arr); } public static void radixSort(int[] arr){ //用二维数组定义一下每个桶 int[][] bucket = new in

代码public class Main { public static void main(String[] args) { int arr[] = {998, 7, 1, 2, 9, 3, 936, 5, 4, 6, 0}; mergeSort(arr,0,arr.length - 1,new int[arr.length]); System.out.println(Arrays.toString(arr)); } public s

学习文章：这一篇快速排序其实是冒泡排序的升级版代码public class Main { public static void main(String[] args) { int arr[] = {998, 7, 1, 2, 9, 3, 936, 5, 4, 6, 0}; quickSort(arr,0,arr.length - 1); } public static void quickSort(int[] arr, int l, int r

希尔排序相当于在正式进行简单插入排序前，对数列进行了一些整体性的调整1.交换式希尔排序public class Main { public static void main(String[] args) { int arr[] = {8,9,1,7,2,3,5,4,6,0}; shellSort(arr); } public static void shellSort(int[] arr){ int temp = 0;

插入排序基本思想插入排序(Insertion Sorting）的基本思想是:把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的大小依次与有序表元素的大小进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。最终的有序表即为排好序的数组。代码public class Main { public static void main(String[] args) { int ar

代码public class Main { public static void main(String[] args) { int arr[] = {3,9,-1,10,-2}; selectSort(arr); } public static void selectSort(int[] arr){ int min = 0;//最小数是多少 int minIndex = 0;//最小数的下标是多少

普通冒泡排序public class Main { //准备数组 static int arr[] = {3,9,-1,10,-2}; public static void main(String[] args) { bubbleSort(arr); } //冒泡排序 public static void bubbleSort(int[] arr){ int temp = 0; for (int i = 0

问题描述八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即:任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。代码public class Main { static int maxSize = 8; static int[] array = new int[maxSize]; static int count = 0; public

代码public class Main { public static void main(String[] args) { //创建迷宫 int[][] maze = new int[7][8];//七行八列的迷宫 //给迷宫的墙设置为1 for (int i = 0;i < 8;i++){ maze[0][i] = 1; maze[6][i] = 1; }

首先要明确步骤1.初始化两个栈:运算符栈s1和储存中间结果的栈s22.从左至右扫描中缀表达式3.遇到操作数时，将其压s24.遇到运算符时，比较其与s1栈顶运算符的优先级4.1.如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈s14.2.若优先级比s1栈顶运算符的高，也将运算符压入s14.3.若优先级比s1栈顶运算符的低，则将s1栈顶的运算符弹出并压入到s2中，再次转到4.1与s1中新的栈顶运算符相比较5.遇到括号时:5.1如果是左括号“(”，则直接压入s15.2如果是

1.前缀表达式求值（用的不多）从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素和次顶元素)，并将结果入栈重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果2.中缀表达式中缀表达式求值其实就是这一篇博客记载的就是我们人常用的，但是机器不好识别的。因此常需要将中缀表达式转化为后缀表达式3.后缀表达式求值从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素和

代码public class Main { public static void main(String[] args) { int result = calExpression("100+2*4-6/3"); System.out.println(result); } public static int calExpression(String expression){ //数栈 符号栈 ArrayStack

数组实现public class Main { public static void main(String[] args) { ArrayStack arrayStack = new ArrayStack(3); arrayStack.push(2); arrayStack.push(1); arrayStack.push(3); arrayStack.showStack(); arrayStac