Author1thy的博客

代码：package com.wangyq.datastructrue.calculator;import java.lang.reflect.Method;import java.math.BigDecimal;import java.util.*;class Test { public static void main(String[] args) { //要计算的公式 //认为公式为正确的不需要校验 String equation

压缩：1.将文件中读到的字节进行整理，统计各个字节出现次数2.将次数与值添加到List中，并进行排序3.根据List生成哈夫曼树4.根据哈夫曼树生成哈夫曼编码5.对应哈夫曼编码生成新的bytes，并将bytes和哈夫曼编码一同输出到压缩文件中解压：1.先读取数据和哈夫曼编码2.反转哈夫曼编码（key，value互换）3.对应反转后的哈夫曼编码恢复原来文件3.输出恢复好的文件注意：当生成的压缩后编码最后一位中时0开头时，转换byte会数据丢失，所以特殊处理，将bytes的第一位存储丢失的

思路：正常回溯算法，通过贪心算法优先走剩余可走位置少的，因为可能之后再也走不到了代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;/** * 回溯算法，贪心算法实现马踏棋盘问题 */public class TheHorseStepBoard { static final int[] dx = {-2, -1, 1, 2, 2, 1, -1, -2}; // x方向的增量 stat

思路：A通过B到C的距离可能比直接从A到B的距离更短，挨个比较更新到距离表中代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;public class FloydAlgorithm { private static int MAX = 1000; public static void main(String[] args) { //构建图 int[][]

思路：从起始点出发，广度遍历，记录到该点距离最短的顶点，记录下来，再广度遍历剩余的顶点，直到确定所有顶点都为最短时结束代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;public class Dijkstra { private static int MAX = 1000; public static void main(String[] args) { //构建图

代码：package com.wangyq.datastructrue.search;import java.util.Arrays;public class FibonacciSearch { public static void main(String[] args) { int[] ints = {1, 6, 18, 19, 37, 50, 61, 69, 76, 81, 83, 99, 108, 113, 114, 121, 124, 156, 180, 197};

思路：依次取最短路径，如果可以两个顶点美豆都联通则连接该路径直到所有顶点全都链接代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;public class Kruskal { public static void main(String[] args) { //构建图 int[][] ints = new int[7][7]; for (int[]

思路：1.先确认一个点查找他连接的最短路径的顶点，然后记录下该顶点，然后查到这两个顶点连接最短路径的顶点，不能出现回路，然后在判断这个三个依次累计，直到所有顶点全部连接代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;/** * 普利姆算法- 修路问题 ，最小生成树 */public class PrimAlgorithm { public static void main(String

代码：package com.wangyq.datastructrue.arithmetic;import java.util.*;/** * 贪心算法-广播站 */public class GreedyAlgorithm { public static void main(String[] args) { //存储一共要覆盖哪些城市 List<String> areaList = new ArrayList<>();

代码：package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;public class KMP { public static void main(String[] args) { String str = "abcabaabaabcacb"; String matchStr = "abaabcac"; int index = kmp(str, matchStr)

代码:package com.wangyq.datastructrue.arithmetic;public class DynamicPlanning { public static void main(String[] args) { //初始化参数 //物品重量 int[] weight = {1, 2, 5, 3}; //物品价值 int[] value = {1, 2, 4, 5}; //

代码:package com.wangyq.datastructrue.arithmetic;import java.util.Arrays;import java.util.Stack;/** * 分治算法-汉罗塔 */public class DivideAndConquer { public static void main(String[] args) { //定义一个汉罗塔 TowerofHanoi towerofHanoi = new T

代码：package com.wangyq.datastructrue.tree;class BalancedBinaryTreeTest { public static void main(String[] args) { int[] ints = {1, 65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 234, 56, 13, 4, 7, 7, 8, 123, 12, 456, 567, 231, 41, 234, 6874,

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class MeagerSort { public static void main(String[] args) { //待排序数组 int[] ints = {65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 6874, 51, 321, 84, 651, 23, 6

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class HeapSort { public static void main(String[] args) { int[] ints = {65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 6874, 51, 321, 84, 651, 23, 68, 56, 52, 416, 1,

代码：package com.wangyq.datastructrue.tree;public class BinaryTree { public static void main(String[] args) { //定义6个节点 Node node1 = new Node(1, "小李"); Node node2 = new Node(2, "小赵"); Node node3 = new Node(3, "小钱");

代码：package com.wangyq.datastructrue.search;import java.util.Arrays;public class InterpolationSearch { public static void main(String[] args) { int[] ints = {1, 6, 18, 19, 37, 50, 61, 69, 76, 81, 83, 99, 108, 113, 114, 121, 124, 156, 180, 1

代码：package com.wangyq.datastructrue.search;import java.util.Arrays;public class Binarysearch { public static void main(String[] args) { int[] ints = {1, 6, 18, 19, 37, 50, 61, 69, 76, 81, 83, 99, 108, 113, 114, 121, 124, 156, 180, 197};

代码:package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Cardinal { public static void main(String[] args) { //定义排序前数组，随机数100个 int[] ints = new int[20]; for (int i = 0; i < 20; i++) { int

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Shell { public static void main(String[] args) { //定义排序前数组，随机数100个 int[] ints = new int[20]; for (int i = 0; i < 20; i++) { ints[i

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Speediness { public static void main(String[] args) { //定义排序前数组，随机数100个 int[] ints = new int[100]; for (int i = 0; i < 100; i++) {

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Insertion { public static void main(String[] args) { int[] ints = {5, 34, 7, 834, 75, 23, 345, 78908, 2, 3}; System.out.println("排序前：" + Arrays.toString(

代码：package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Bubbling { public static void main(String[] args) { int[] ints = {0,34, 7, 834, 75, 23, 345, 78908, 2, 3}; System.out.println("排序前：" + Arrays.toString(in

package com.wangyq.datastructrue.sort;import java.util.Arrays;public class Bubbling { public static void main(String[] args) { int[] ints = {0,34, 7, 834, 75, 23, 345, 78908, 2, 3}; System.out.println("排序前：" + Arrays.toString(ints))

代码：package com.wangyq.datastructrue.calculator;import java.util.ArrayDeque;import java.util.Queue;import java.util.Stack;/** * 10以内整数加减乘除 */public class Calculator { public static void main(String[] args) { //要计算的公式 //认为公式为正确的

问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果经过±90度、±180度旋转，和对角线对称变换的摆法看成一类，共有42类。计算机发明后，有多种计算机语言可以编程解决此问题。代码：package com.wangyq.datastructrue.backtracking;/** * 八皇后问题