zjcoming

package algorithm.HanoiTower;public class HanoiTower { public static void main(String[] args) { hanoiTower(3,'A','B','C'); } /** * 分治，递归处理汉诺塔问题 * @param n 圆盘的个数 * @param a A柱子 * @param b B柱子 * @param c C柱子

文章目录【1】代码：①Node节点②BST binarySortTree二叉排序树：③ 测试代码：【2】测试结果：【1】代码：①Node节点package algorithm.tree.binarySortTree_BST;public class Node { int val; Node left; Node right; public Node(int val) { this.val = val; } @Override

文章目录【1】堆排序基本介绍【2】堆排序重难点①如何由一个无序序列建成一个堆？②如何在输出堆顶元素后，调整剩余元素成为一个新的堆【3】代码：【4】测试结果：【1】堆排序基本介绍升序采用大顶堆、降序采用小顶堆【2】堆排序重难点①如何由一个无序序列建成一个堆？②如何在输出堆顶元素后，调整剩余元素成为一个新的堆【3】代码：package algorithm.sort.heapSort;import java.util.Arrays;/** * 大根堆，升序排序 */publ

文章目录【0】建立线索二叉树和遍历线索二叉树基本上是一样的【1】代码：一、`TreeNode`节点：二、`BinaryTree`二叉树三、线索二叉树【2】测试【0】建立线索二叉树和遍历线索二叉树基本上是一样的建立如图二叉树：黑色的箭头表示线索！！！【1】代码：一、TreeNode节点：public class TreeNode { int no; String name; TreeNode left; TreeNode right; //用0表示指向左

【1】正确序列：应该为2-4-3-1【2】代码：树节点：public class TreeNode { int no; String name; TreeNode left; TreeNode right; public TreeNode(int no, String name) { this.no = no; this.name = name; } @Override public St.

【1】正确序列：应该为2-1-3-4【2】代码：树节点：public class TreeNode { int no; String name; TreeNode left; TreeNode right; public TreeNode(int no, String name) { this.no = no; this.name = name; } @Override public S..

【1】正确序列：应该为1-2-3-4【2】代码：树节点：public class TreeNode { int no; String name; TreeNode left; TreeNode right; public TreeNode(int no, String name) { this.no = no; this.name = name; } @Override public St.

【1】HashTable原理【2】说明通过数组加链表的方式实现只实现了添加和打印方法，其余方法类似【3】代码： package algorithm.hashTable;/** * 使用数组加链表的方式实现 */public class MyHashTable { public static void main(String[] args) { Hash hashTable = new Hash(5); Element e1 = new

【1】引子当数组为【0,1,2,3,4,5......100】时，查找100使用二分查找需要查多少次呢？要经过多次的查找才能查找到100，对于这种分布均匀的数组，能不能改善一下查找的次数呢？—— 插值查找算法。对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快.关键字分布不均匀的情况下，该方法不一定比折半查找要好这样算出的mid值，考虑了真实数值的大小，将要查找的数在整个数组中的占比算了出来。自适应算法。/** 插值查找 * 自适应算法 * @

二分查找算法（递归方式）： /** * 二分查找法（递归） * * @param arr * @param val */ public static int binary(int[] arr, int left, int right, int val) { if (right < left) return -1; int mid = (left + right) / 2;

桶排序的升级版本:/** 基数排序 * 桶排序升级版 * * @param arr */ public static void radix(int[] arr) { //定义10个桶,每个桶的大小都能装满整个数组 int[][] bucket = new int[10][arr.length]; //每一次取数的时候arr的下表 int index = 0; //base表示

参考：https://www.cnblogs.com/chengxiao/p/6194356.htmlpublic static void sort(int[] arr){ int []temp = new int[arr.length]; mergeSort(arr,0,arr.length-1,temp); } public static void mergeSort(int[] arr,int left,int right,int[] temp){

【1】方式一①创建一个临时变量temp保存当前pivot的值②r左移遇到小于temp的直接赋值给l，然后l右移，遇到大于temp的直接赋值给r③知道r==l，将temp的值写到这个位置上代码实现：public static void quick1(int[] arr, int left, int right) { if (left >= right) return; //保存中轴值 int temp = arr[lef

交换法：（耗时）/** * 交换法 * gap 表示步长 同时也表示 划分的组数 * m表示数组大小 * n = m/gap 表示每组有多少个数 * m/n 表示有多少个组 m/(m/gap) = gap * * @param arr */ public static void shell(int[] arr) { int temp = 0; int j = 0; fo

算法代码：public static void insertSort(int[] arr){ int temp; for (int i = 1; i < arr.length; i++) { temp = arr[i]; for (int j = 0; j < i; j++) { //如果这个数是有序数组中最大的一个,直接放到最后一个 if (temp

public static void selectSort(int[] arr) { int min; int minIndex; for (int i = 0; i < arr.length - 1; i++) { min = arr[i]; minIndex = i; for (int j = i + 1; j < arr.length; j++) {

文章目录【1】没有经过优化的冒泡排序：【2】优化后的冒泡排序：【3】测试结果：优化后：（30次）优化前：（45次）打印函数：//打印 public static void prin(int[] arr){ System.out.println("数组如下："+ Arrays.toString(arr)); }【1】没有经过优化的冒泡排序：public static void baseSort(int[] arr){ //两层循环嵌套

【1】代码：package algorithm.queen;import java.io.OptionalDataException;public class Queen { private static final int max = 8; //用一维数组储存每一次成功的皇后位置 /** * arr的下标表示第几行，里面储存的数据是第几列 */ private static int[] arr = new int[max]; //计.

递归的方式解决迷宫问题：package algorithm.maze;public class Maze { public static void main(String[] args) { int[][] map = initMaze(); getPath(map, 1, 1); //打印 System.out.println("找的的路为："); for (int[] item : map) {

实现一个最简单的计算器，规定：只有+、-、*、/，没有小括号数字只能是0-9之间的数字，不能有两位数。

/** * * @param first 环形链表的第一个 * @param num 数几个删除 */ public static void josepfu(ListNode first,int num){ //定义一个ArrayList接收 List<Integer> list = new ArrayList<Integer>(); //定义指针指向first的前一个节点

public static ListNode mergeTwoLists(ListNode l1, ListNode l2) { //新链表的头结点 ListNode headNew = new ListNode(); //指向l1当前节点的指针和指向l2当前节点的指针 ListNode cur1 = l1; ListNode cur2 = l2; //指向新链表的尾结点(临时)（当有一个链表合并完后，就不再指向

这几天做了下反转链表。leetcode上的206题。感觉他那个题有问题。搞了几个小时也AC不了。后来发现是题目描述有问题。题目说头结点，头结点其实是不带数据的。但206题其实是带数据的头结点，可以直接通过print打印head.val的值，发现是1。那么接下来通过两种思路来解题。方法一：双指针public static ListNode reverseList(ListNode head){ ListNode cur = head; ListNode pre =..

文章目录【1】稀疏数组概述【2】转换思想【3】代码实现：【1】稀疏数组概述疏数组是一种压缩后的数组，为什么要进行压缩存储呢？原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据却少之又少压缩存储可以节省存储空间以避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率【2】转换思想转换为n行3列的数组第一行保存原始数组的行列数以及有用的数值数量第二行就保存第一个有效数据的行列数及具体数值以此类推。。。。。。。。。。。。【3】代码实

在复习的时候写了这个专栏，有3个目的：①记录（记录自己得学习进度）②复习（将思想和相关的代码记录下来方便复习）③分享（分享给处于同一阶段的人）