FutureFlyme的博客

直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的有序的表中，从而得到一个新的、记录数增1的有序表。 当前元素的前面元素均为有序，要插入时，从当前元素的左边开始往前找（从后往前找），比当前元素大的元素均往右移一个位置，最后把当前元素放在它应该呆的位置就行了 java代码实现：package Insertion;public class Insertion {

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。1、用两个栈实现package test04;import java.util.ArrayList;import java.util.Stack;/* * 注意从第一层开始，每一层的节点都是先进入相应的栈,在出栈,最后按照出栈的顺序,add到每一层的

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。 分成两大类： 1、有右子树的，那么下个结点就是右子树最左边的点；（eg：D，B，E，A，C，G） 2、没有右子树的，也可以分成两类，a)是父节点左孩子（eg：N，I，L） ，那么父节点就是下一个节点 ； b)是父节点的右孩子（eg：H，J，K，M）找他的

import java.util.ArrayList;import java.util.*;/*public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val;

剑指offer上有一道题目：请实现两个函数，分别用来序列化和反序列化二叉树。 首先要明白题意，二叉树的序列化就是说把二叉树保存到文件中，当然这里保存的是字符串。反序列化就是说把刚才序列化的文件把转化成和原来一模一样的二叉树。（话不多说直接上代码）/*public class TreeNode { int val = 0; TreeNode left = null; Tre

题目：输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序。package test05;import java.util.ArrayList;public class test01 { public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) { Arra

Java中的堆是JVM所管理的最大的一块内存空间，主要用于存放各种类的实例对象在Java中堆被划分成两个不同的区域：新生代(Yong),老年代(Old)。新生代(Yong)又被划分成三个区域：Eden，From Survivor,To Survivor这样划分的目的是为了使JVM能更好的管理内存中的对象，包括内存的分配以及回收。 堆的内存模型大致为： 堆大小=新生代+老年代GC类型分为Sca

找两个字符串的最长公共子串，这个子串要求在两个原字符串中是连续的。其实这又是一个序贯决策问题，可以用动态规划来求解。我们采用一个二维矩阵来记录中间的结果。这个二维矩阵怎么构造呢？直接举个例子吧：”bab”和”caba”(当然我们现在一眼就可以看出来最长公共子串是”ba”或”ab”) 　　 b　　a　　bc　　0　　0　　0a　　0　　1　　0b　　1　　0　　2a　　0　　2　　0package

最大子序列是要找出由数组成的一维数组中和最大的连续子序列。比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。你已经看出来了，找最大子序列的方法很简单，只要前i项的和还没有小于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列，同时我们要记下各个子序列的和，最后找到和最大的子序列。 pu

package test01;//最长公共子序列问题public class LCS { public static void main(String[] args) { char[] ch1={1,2,4,5,6,2}; char[] ch2={2,5,6,9,2,10,11,43}; //maxLen[i][j]表示 ch1左边起i个字

计数排序假设n个输入元素中的每一个都是介于0到k之间的整数，此处k为某个整数。public static int[] Sort1(int [] A,int k){//k表示数组A中的最大值 int [] C=new int[k+1];//临时数组C int [] B=new int[A.length];//B存放结果 //首先是通过一个数组C[i]计

有一组单词，请编写一个程序，在数组中找出由数组中字符串组成的最长的串A，即A是由其它单词组成的(可重复)最长的单词。 给定一个string数组str，同时给定数组的大小n。请返回最长单词的长度，保证题意所述的最长单词存在。 测试样例： [“a”,”b”,”c”,”ab”,”bc”,”abc”],6 返回3 [“a”,”b”,”ab”,”abc”],4 返回2import java.uti

现在有n位工程师和6项工作(编号为0至5)，现在给出每个人能够胜任的工作序号表(用一个字符串表示，比如：045，表示某位工程师能够胜任0号，4号，5号工作)。现在需要进行工作安排，每位工程师只能被安排到自己能够胜任的工作当中去，两位工程师不能安排到同一项工作当中去。如果两种工作安排中有一个人被安排在的工作序号不一样就被视为不同的工作安排，现在需要计算出有多少种不同工作安排计划。 输入描述: 输

package test04;import java.util.*;//定义节点结构class Node { int data; Node next = null; Node(int data) { this.data = data; }}public class test03 { public static void main(Str

package test04;//元素n的划分,即存在某些数,n1,n2,n3,n4.....使得n1+n2+...=n//比如6的划分共有11种,Count(6,4)=9/*6 5+1 4+2 4+1+1 3+3 3+2+1 3+1+1+1 2+2+2 2+2+1+1 2+1+1+1+1 1+1+1+1+1+1 */publ

选择排序的思想：选出最小的一个和第一个位置交换，选出其次小的和第二个位置交换 ……直到从第N个和第N-1个元素中选出最小的放在第N-1个位置，简单的说就是每次排序都是从未排序的数组中选择最小的，放到已经排序的数组的最后； Java代码实现：package selection;public class selection { public static int[] selection1(i

冒泡排序的核心思想是：从第一个元素开始，往后比较，遇到比自己小的元素就交换位置，交换的次数最多，自然也是性能最差的。 排序过程： 假设数组长度为n。 1．比较数组中前后相邻的两个数据，如果前面数据大于后面的数据，就将两个数据交换。 2．这样对数组的第0个数据到第n-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第n-1个位置。 3．此时n=n-1，重复前面两步，直到排序完成。 Ja

冒泡排序的效率不高，适合小量数据的排序，当数据较多的时候，建议使用其他排序算法，在另一篇博客中我已经介绍了冒泡排序冒泡排序，这篇博客将对冒泡排序进一步优化。 例如，有这样一个数组，int arr[]={13,10,7,9,3,23,43,52,61,71};可以看到这个数组有一个明显的特点：前五个数字无序，后五个数字有序，且都比前五个数字大，这样我们就可以最多进行5次排序就可以把整个数组的顺序确定

思想：先把一个待排序的数组分解成两个，再把两个分解成4个。。。。然后再合并排序。package ArrayPackage;import java.util.Arrays;public class MergeSort1 { public static void main(String[] args) { int[] nums = { 2, 7, 6, 9, 0, 5, 4

首先定义一个节点的数据结构package ListNode;//定义一个节点数据结构，包括指针和数据public class Node { public Node next=null; public int data; public Node(int data){ this.data=data; } public void display(

KMP改进主要是对next数组进行改进 如图当s[3]与p[3]不匹配时，根据next[3]=1，所以继续把s[3]与p[1]进行比较，即把模式串右移j-k=3-1=2位，此时s[3]与p[1]还是不等。其实仔细想一想，这是必然的，为什么呢？ 因为当j=3时，p[j]=p[next[j]]即p[3]=p[1],问题就出在这里，当s[i]!=p[j],又因为p[j]=p[next[j]],

关于KMP算法，网上很多资源，就不介绍了，建议不懂的看看数据结构这本书，很详细，或者参看下面说说java实现，（整个算法流程加代码实现花了快一天时间） 首先看看一般的算法，也就是网上说的暴力（蛮力）算法，它的时间复杂度为O(n*m) m为模式串的长度，n为主串的长度package test03;public class test05 { public static int volient

快速排序是采用分治和递归的经典算法之一，每次找一个基数，比它大的放右边，比它小的放左边。 public static void mysort1(int[] a,int begin,int end){ if(begin<end){//递归的临界条件 int low=begin; int high=end; i

package test02;public class Test01 { public static void main(String[] args) { int[] a = { 3, 4,1, 3, 22, 11, 33, 90, 1,2,12,90, 89}; int max = getMax(a, 0, a.length - 1); i

Sunday算法是Daniel M.Sunday于1990年提出的字符串模式匹配。其核心思想是：在匹配过程中，模式串发现不匹配时，算法能跳过尽可能多的字符以进行下一步的匹配，从而提高了匹配效率。相比于另外几个著名的字符串匹配算法，KMP以及BM算法而言，Sunday算法不仅理解起来比较容易，而且往往能有更好的速度。 首先i,j两个指针指示的位置（也就是从头开始匹配），当发现失配的时候就判断子串

全排列是一个很简单的数学问题，但是要把它用程序实现，确实要费点思路。思考了一个小时，才用递归实现了它。代码很简单，但是要思考每一步的流程，确实要花费一点时间，再一次证明分治和递归的强大。package test03;import java.util.Arrays;public class test08 { public static void main(String[] args) {

1、利用HashSet的性质，元素不重复package test03;import java.util.Arrays;import java.util.HashSet;public class test09 { private static HashSet<String>set=new HashSet<String>(); public static void main(Str

今天面试，面试官问了我一个这样的问题，比如ab..dd….scd…df这样一个字符串，把它翻转成df…scd….dd..ab,让我在稿纸上coding出来，当时思路极为混乱，现在coding出来以作记录。import java.util.Scanner;import java.util.Stack;public class test { public static void main(St