java算法 订阅
《Java算法》是2004年清华大学出版社出版的图书,作者是塞奇威克。本书用Java语言全面实现了当今最重要的计算机算法,并用大量图表和数学公式对算法进行了详尽的描述和分析。 [1] 展开全文
《Java算法》是2004年清华大学出版社出版的图书,作者是塞奇威克。本书用Java语言全面实现了当今最重要的计算机算法,并用大量图表和数学公式对算法进行了详尽的描述和分析。 [1]
信息
出版年
2004-06-01
作    者
塞奇威克
装    帧
平装
出版社
清华大学出版社
页    数
552
Java算法内容简介
全书共分3卷,本书是其中的第1卷(第1至第4部分)。内容包括基本概念(第1部分)、数据结构(第2部分)、排序算法(第3部分)和查找算法(第4部分)。本书概念清楚,内容翔实,新颖,由浅入深地描述了算法。本书可作为高等院校计算机相关专业本科生和研究生的教材和补充读物,也可作为Java爱好。
收起全文
精华内容
下载资源
问答
  • 1000多种java算法大全源码包

    千次下载 热门讨论 2014-04-09 18:41:36
    1000多种java算法大全源码包
  • java算法大全_java经典算法_算法面试题大全含答案

    万次阅读 多人点赞 2019-05-16 09:44:18
  • java算法大全(含源码包)

    千次下载 热门讨论 2011-08-28 16:19:38
    java算法大全,有近100多种常见算法的源代码,是学习JAVA算法的难得资料。
  • java算法大全源码包

    千次下载 热门讨论 2008-08-29 09:08:04
    java算法大全源码包,包含java所有算法
  • JAVA算法:贪心算法典型题目详解(JAVA版本) 题目一:最优装载问题 一条小船用来运输古董到河对岸。假设船的最大载重量为MAXWEIGHT,每件古董的重量为,怎么能够装载最多数量的古董到船上呢? 样例数据: ...

    JAVA算法:贪心算法典型题目详解(JAVA版本)

    题目一:最优装载问题

    一条小船用来运输古董到河对岸。假设船的最大载重量为MAXWEIGHT,每件古董的重量为w_i,怎么能够装载最多数量的古董到船上呢?

    样例数据:

    MAXWEIGHT 为 30

    给定8个古董,重量分别为:[4, 10, 7, 11, 3, 5, 14, 2]

    算法分析

    这个问题是一个典型的可以使用贪心算法解决的问题。

    通过分析题目可以看到,小船的载重量(MAXWEIGHT)是固定的,要求装载的物品数量最多,那么应该优先选择把重量最小的物品装上船,然后不断装载剩余的物品,直到达到小船载重量的要求。

    选择先装载重量最小的物品,这个选择策略就采用了贪心(Greedy)策略,从局部最优达到全局最优,从而产生最优装载问题的最优解。

    算法设计与实现

    package com.bean.algorithm.learning;
    
    import java.util.Arrays;
    
    public class OptimizedLoading {
    
    	public static int MAXWEIGHT = 30;// 小船的载重量
    	public static int AMOUNT = 8;// 古董个数
    
    	/*
    	 * 装载算法(贪心算法)
    	 * */
    	public static int maxLoading(int[] weight) {
    		//计数器,用于记录装载到小船上古董的数量
    		int counter = 0;
    		// 对weight数组进行排序
    		Arrays.sort(weight);
    		int temp = 0; // 记录装载到船上的古董重量
    		for (int i = 0; i < AMOUNT; i++) {
    			temp += weight[i]; // 贪心策略:每次装入最轻者
    			if (temp <= MAXWEIGHT) // 若加入最轻者后还小于载重量,则古董个数+1
    				counter++;
    			else
    				//超重,不能装载
    				break;
    		}
            //返回装载的古董的数量
    		return counter;
    
    	}
    
    	public static void main(String[] args) {
    
    		int ANSWER = 0; // 记录已装载的古董个数
    		int[] weight = { 4, 10, 7, 11, 3, 5, 14, 2 };
    		ANSWER = maxLoading(weight);
    		System.out.println("能装入的古董最大数量为: " + ANSWER);
    	}
    
    }
    

    程序运行结果:

    能装入的古董最大数量为: 5


    题目二:活动安排

    设有n个活动的集合e={1,2,…,n},其中每个活动都要求使用同一资源,如演讲会场等,而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始时间s_i和一个结束时间f_i,且s_i< f_i。如果选择了活动i,则它在半开时间区间[s_i,f_i]内占用资源。若区间[s_i,f_i]与区间[s_j,f_j]不相交,则称活动 i 与活动 j 是相容的。也就是说,当s_i ≥ f_i或s_j ≥ f_j时,活动 i 与活动 j 相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

    在下面所给出的解活动安排问题的贪心算法gpeedyselector中,各活动的起始时间和结束时间存储于数组s和f{中且按结束时间的非减序:.f_1 ≤ f_2 ≤ … ≤ f_n排列。如果所给出的活动未按此序排列,我们可以用o(nlogn)的时间将它重排。

    package com.bean.algorithm.beginner;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ActivitiesDemo {
    
    	public static List<Integer> arrangeActivity(int[] start, int[] end) {
    		int total = start.length;
    		int endFlag = end[0];
    		List<Integer> results = new ArrayList<>();
    		results.add(0);
    		for (int i = 0; i < total; i++) {
    			if (start[i] > endFlag) {
    				results.add(i);
    				endFlag = end[i];
    			}
    		}
    		return results;
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int[] start = { 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
    		int[] end = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
    		List<Integer> results = arrangeActivity(start, end);
    		for (int i = 0; i < results.size(); i++) {
    			int index = results.get(i);
    			System.out.println("开始时间:" + start[index] + ",结束时间:" + end[index]);
    		}
    	}
    
    }
    

     程序运行结果:

    开始时间:1,结束时间:4
    开始时间:5,结束时间:7
    开始时间:8,结束时间:11
    开始时间:12,结束时间:14


    题目三:剪绳子

    给定一根长度为n的绳子,请把绳子剪成m段,每段绳子记为k[0],k[1]……k[m]。请问k[0]*k[1]……*k[m]可能的最大乘积是多少?例如:当绳子长度为8时,我们把它剪成长度分别为2,3,3段,此时最大乘积为18.

    算法分析

    从问题的某一个初始解出发逐步逼近给定的目标,以尽可能快的地求得更好的解。当达到某算法中的某一步不能再继续前进时,算法停止,这就是贪婪算法。

    在剪绳子中,如果绳子的长度大于5,则每次剪出的长度为3的绳子。如果剩下的长度仍然大于5,则接着剪出一段长度为3的绳子,重复这个步骤,直到剩下的长度小于5.时间和空间复杂度都为O(1)。
     

    算法设计

    可以参考我的另外一篇博文:https://blog.csdn.net/seagal890/article/details/89607705

    package com.bean.algorithm.basic;
    
    
    public class CutForMaxProduct4 {
    
    	// Greedy solution for Max Product Problem
    	public static int maxProd(int length) {
    		if (length < 2)
    			return 0;
    		if (length == 2)
    			return 1;
    		if (length == 3)
    			return 2;
    		int timesOf3 = length / 3;    //剪长度为3的绳子段
    		if ((length - timesOf3 * 3) == 1) // 当长度为4的时候不能去用3剪
    			timesOf3 -= 1;      
    		int timesOf2= (length - timesOf3* 3) / 2;     // 这时应该把绳子剪成长度为2的两段:2*2>1*3
    		return ((int)(Math.pow(3, timesOf3))*((int)Math.pow(2, timesOf2)));
    
    	}
    
    	/* Driver program to test above functions */
    	public static void main(String[] args) {
    		System.out.println("Maximum Product is " + maxProd(10));
    	}
    }
    

    程序运行结果:

     Maximum Product is 36


    题目四:机器人行走

    机器人在一个无限大小的网格上行走,从点 (0, 0) 处开始出发,面向北方。该机器人可以接收以下三种类型的命令:

    -2:向左转 90 度
    -1:向右转 90 度
    1 <= x <= 9:向前移动 x 个单位长度
    在网格上有一些格子被视为障碍物。

    第 i 个障碍物位于网格点  (obstacles[i][0], obstacles[i][1])

    如果机器人试图走到障碍物上方,那么它将停留在障碍物的前一个网格方块上,但仍然可以继续该路线的其余部分。

    返回从原点到机器人的最大欧式距离的平方。

    示例 1:

    输入: commands = [4,-1,3], obstacles = []
    输出: 25
    解释: 机器人将会到达 (3, 4)
    示例 2:

    输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
    输出: 65
    解释: 机器人在左转走到 (1, 8) 之前将被困在 (1, 4) 处

    提示:

    0 <= commands.length <= 10000
    0 <= obstacles.length <= 10000
    -30000 <= obstacle[i][0] <= 30000
    -30000 <= obstacle[i][1] <= 30000
    答案保证小于 2 ^ 31

    算法分析

     

    算法设计

    class Solution {
        public int robotSim(int[] commands, int[][] obstacles) {
            if(commands == null || commands.length == 0)
                return 0;
            Set<String> obstacleSet = new HashSet<>();
            for(int[] o : obstacles)
                obstacleSet.add(o[0] + "," + o[1]);
            int maxVal = 0, direction = 0, x = 0, y = 0;
            int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}};
            for(int command : commands){
                if(command == -1){
                    direction = (direction + 1) % 4;
                }else if(command == -2){
                    direction = (direction - 1) % 4;
                    if(direction < 0)
                        direction += 4;
                }else if(command >= 1 && command <= 9){
                    for(int i=0; i<command; ++i){
                        int xnext = x + directions[direction][0];
                        int ynext = y + directions[direction][1];
                        if(obstacleSet.contains(xnext + "," + ynext))
                            break;
                        x += directions[direction][0];
                        y += directions[direction][1];
                        maxVal = Math.max(maxVal,x*x + y*y);
                    }
                }
            }
            return maxVal;
        }
    }

    另外一种算法设计

    class Solution {
        public int robotSim(int[] commands, int[][] obstacles) {
            int[][] walk = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    		Map<String, Boolean> map = new HashMap<>();
    		for (int i = 0; i < obstacles.length; i++)
    			map.put(obstacles[i][0] + "," + obstacles[i][1], true);
    		int p = 0, q = 0, k = 0;
    		int max = 0;
    		for (int command : commands) {
    			if (command == -1)
    				k = (k + 1) % 4;
    			else if (command == -2)
    				k = (k - 1 + 4) % 4;
    			else {
    				for (int i = 0; i < command; i++) {
    					if (map.containsKey((p + walk[k][0]) + "," + (q + walk[k][1])))
    						break;
    					p += walk[k][0];
    					q += walk[k][1];
    					max = Math.max(max, p * p + q * q);
    				}
    			}
    		}
    		return max;
        }
    }

    题目五:任务调度问题

    给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26种不同种类的任务。任务可以以任意顺序执行,并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务,或者在待命状态。

    然而,两个相同种类的任务之间必须有长度为 n 的冷却时间,因此至少有连续 n 个单位时间内 CPU 在执行不同的任务,或者在待命状态。

    你需要计算完成所有任务所需要的最短时间。

    示例 1:

    输入: tasks = ["A","A","A","B","B","B"], n = 2
    输出: 8
    执行顺序: A -> B -> (待命) -> A -> B -> (待命) -> A -> B.
    注:

    任务的总个数为 [1, 10000]
    n 的取值范围为 [0, 100]

    算法分析

     

    算法设计

    package com.bean.algorithm.learning;
    
    import java.util.Arrays;
    
    public class TaskScheduler {
    
    	public int leastInterval(char[] tasks, int n) {
    		// count char freq, task name doesn't matter, only freq matters
    		int[] freq = new int[26];
    		for (char c : tasks)
    			freq[c - 'A']++;
    		// sort first, so we have max freq at freq[25]
    		Arrays.sort(freq);
    		int time = 0;
    		while (freq[25] > 0) { // while we still have task to do, start from most freq task
    			// GREEDY
    			// each round/row, try to finish n tasks
    			for (int i = 0, p = 25; i <= n; i++) { // n is the cooling down factor, p points to the next task to consume
    				if (p >= 0 && freq[p] > 0) { // if there is still task to do
    					freq[p]--; // do task
    					p--; // move p to next freq task
    					time++; // take one cycle
    				} else if (freq[25] != 0) { // if this is NOT last row, need to fill in idle cycle
    					time++; // take one cycle
    				} // else freq[25] == 0 . no more task to do and last row. we WON'T fill in idle
    					// cycle
    			}
    			// sort again so next round we're going to start from most freq task and consume
    			// n task if possible
    			Arrays.sort(freq);
    		}
    		return time;
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		TaskScheduler taskScheduler=new TaskScheduler();
    		
    		char[] tasks= {'A','A','A','B','B','B'};
    		int n=2;
    		
    		int result=-1;
    		
    		result=taskScheduler.leastInterval(tasks, n);
    		System.out.println("result = "+result);
    		
    		
    	}
    
    }
    

    程序运行结果:

    result = 8


    题目六:重构字符串

    给定一个字符串S,检查是否能重新排布其中的字母,使得两相邻的字符不同。

    若可行,输出任意可行的结果。若不可行,返回空字符串。

    示例 1:

    输入: S = "aab"
    输出: "aba"
    示例 2:

    输入: S = "aaab"
    输出: ""
    注意:

    S 只包含小写字母并且长度在[1, 500]区间内。

    算法分析

    给定一个字符串,挪动给定的字符串中字符的位置,使得返回的字符串需要相邻的两个字符不能相同。

    思路:

    • 首先将给定的字符串按照字符存储在一个int的数组中,数组的下标为字符串中字符-‘a’,所以该数组将相同的字符的个数存储在数组中。
    • 利用maxLength获得数组中元素最大的值,即字符串中重复出现的字符最多的字符个数,如果该个数 * 2 - 1大于字符串的长度,就说明相同的字符太多,其他字符已经不能将相同字符分割开
    • 将字符串中的字符按照奇数偶数放在新建的char数组中。将相同的字符个数小于字符串长度的一半的字符放在奇数下标位置,否则放在偶数下标位置。注意这里需要判断奇数位置是否大于字符串长度

    算法设计

    class Solution {
        public String reorganizeString(String S) {
            int[] arr = new int[26];
            int lenght = S.length();
            if(S.length() == 1) return S;
            char[] ret = new char[lenght];
            int maxLength = 0;
            for(char a: S.toCharArray()) {
                if(maxLength < ++arr[a - 'a'])
                    maxLength = arr[a - 'a'];
            }
            if(maxLength * 2 - 1 > S.length())
                return "";
            int odd = 0, even = 1;
            for(int i = 0; i < 26; i++) {
    
                    while(arr[i] > 0 && arr[i] < lenght / 2 + 1 && even < lenght) {
                        ret[even] = (char)(i + 'a');
                        arr[i] --;
                        even += 2;
                    }
                    while(arr[i] > 0) {
                        ret[odd] = (char)(i + 'a');
                        arr[i] --;
                        odd += 2;
                    }
            }
    
            return new String(ret);   
    
        }
    }

     


     

    展开全文
  • java算法全卷(包括基本算法和图算法)

    千次下载 热门讨论 2007-10-03 16:28:13
    java算法全卷(包括基本算法和图算法)
  • JAVA算法:创建图算法(构建图)

    千次阅读 2019-06-01 22:32:31
    JAVA算法:创建图算法(构建图) 有北京、上海、广州、重庆、武汉、南昌五个城市,它们之间的关系和路径成本如图所示。 现在需要编写一个算法使用邻接矩阵表示上面的图。 算法设计 package ...

    JAVA算法:创建图算法(构建图)

    有北京、上海、广州、重庆、武汉、南昌五个城市,它们之间的关系和路径成本如图所示。

    现在需要编写一个算法使用邻接矩阵表示上面的图。

     

     

     

    算法设计

     

    package com.bean.algorithm.graph3;
    
    public class GraphMatrix {
    
    	static final int MaxNum = 20;
        static final int MaxValue = 65535;
        char[] Vertex = new char[MaxNum];//保存顶点信息,序号或者字母
        int GType;//图的类型(0: 无向图, 1: 有向图)
        int VertexNum;//顶点的数量
        int EdgeNum; //边的数量
        int[][] EdgeWeight = new int[MaxNum][MaxNum];//保存边的权
        int[] isTrav = new int[MaxNum];
    
    }
    

     

    package com.bean.algorithm.graph3;
    
    import java.util.Scanner;
    
    public class GraphMatrixDemo {
    
    	static Scanner input = new Scanner(System.in);
    
    	// 创建图
    	private static void CreateGraph(GraphMatrix GM) {
    		int weight;
    		char EstartV, EndV;// 边的起始顶点
    		System.out.println("输入图中各顶点的信息:");
    		// 输入顶点
    		for (int i = 0; i < GM.VertexNum; i++) {
    			System.out.println("第" + (i + 1) + "个顶点");
    			GM.Vertex[i] = (input.next().toCharArray())[0];
    		}
    		System.out.println("输入构成各边的顶点及权值");
    		for (int j = 0; j < GM.EdgeNum; j++) {
    			System.out.println("第" + (j + 1) + "边");
    			EstartV = input.next().charAt(0);
    			EndV = input.next().charAt(0);
    			weight = input.nextInt();
    			int o, p;
    			for (o = 0; EstartV != GM.Vertex[o]; o++)
    				;// 在已有的顶点中查找开始点
    			for (p = 0; EndV != GM.Vertex[p]; p++)
    				;// 在已有的顶点中查找结束点
    			GM.EdgeWeight[o][p] = weight;
    			if (GM.GType == 0) {
    				GM.EdgeWeight[p][o] = weight;
    			}
    		}
    	}
    
    	// 清空图
    	private static void ClearGraph(GraphMatrix GM) {
    		for (int i = 0; i < GM.VertexNum; i++) {
    			for (int j = 0; j < GM.VertexNum; j++) {
    				GM.EdgeWeight[i][j] = GraphMatrix.MaxValue;
    			}
    		}
    	}
    
    	// 遍历输出图
    	private static void OutGraph(GraphMatrix GM) {
    		for (int i = 0; i < GM.VertexNum; i++) {
    			System.out.printf("\t%c", GM.Vertex[i]);// 第一行输出顶点的信息
    		}
    		System.out.println();
    		for (int i = 0; i < GM.VertexNum; i++) {
    			System.out.printf("%c", GM.Vertex[i]);
    			for (int j = 0; j < GM.VertexNum; j++) {
    				if (GM.EdgeWeight[i][j] == GraphMatrix.MaxValue) {
    					System.out.printf("\tZ");
    				} else {
    					System.out.printf("\t%d", GM.EdgeWeight[i][j]);
    				}
    			}
    			System.out.println();
    		}
    	}
    
    	// 深度优先搜索遍历
    	private static void DeepTraOne(GraphMatrix GM, int n) {// 从第n个结点开始, 深度遍历图
    		GM.isTrav[n] = 1;
    		System.out.print("->" + GM.Vertex[n]);// 输出结点数据
    		// 添加结点的操作
    		for (int i = 0; i < GM.VertexNum; i++) {
    			if (GM.EdgeWeight[n][i] != GraphMatrix.MaxValue && GM.isTrav[n] == 0) {
    				DeepTraOne(GM, i);
    			}
    		}
    	}
    
    	private static void DeepTraGraph(GraphMatrix GM) {
    		for (int i = 0; i < GM.VertexNum; i++) {
    			GM.isTrav[i] = 0;
    		}
    		System.out.println("深度优先遍历结点:");
    		for (int i = 0; i < GM.VertexNum; i++) {
    			if (GM.isTrav[i] == 0) {// 若该点没有遍历
    				DeepTraOne(GM, i);
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		GraphMatrix GM = new GraphMatrix();// 定义保存邻接表结构的图
    		System.out.println("输入生成图的类型:");
    		GM.GType = input.nextInt();// 图的种类。 无向图和有向图
    		System.out.println("输入图的顶点数量:");
    		GM.VertexNum = input.nextInt();// 输入图的顶点数
    		System.out.println("输入图的边数量:");
    		GM.EdgeNum = input.nextInt();// 输入图的边数
    		ClearGraph(GM);// 清空图
    		CreateGraph(GM);// 生成邻接表结构的图
    		System.out.println("该图的邻接矩阵数据如下: ");
    		OutGraph(GM);// 输出邻接矩阵
    		DeepTraGraph(GM);// 深度优先搜索遍历
    	}
    
    }
    

    程序运行结果:

    输入生成图的类型:
    1
    输入图的顶点数量:
    6
    输入图的边数量:
    9
    输入图中各顶点的信息:
    第1个顶点
    北京
    第2个顶点
    上海
    第3个顶点
    广州
    第4个顶点
    重庆
    第5个顶点
    武汉
    第6个顶点
    南昌
    输入构成各边的顶点及权值
    第1边
    北京 上海 11
    第2边
    北京 广州 10
    第3边
    上海 南昌 6
    第4边
    广州 武汉 9
    第5边
    广州 重庆 14
    第6边
    重庆 武汉 20
    第7边
    武汉 南昌 12
    第8边
    武汉 北京 13
    第9边
    南昌 广州 18
    该图的邻接矩阵数据如下: 
        北    上    广    重    武    南
    北    Z    11    10    Z    Z    Z
    上    Z    Z    Z    Z    Z    6
    广    Z    Z    Z    14    9    Z
    重    Z    Z    Z    Z    20    Z
    武    13    Z    Z    Z    Z    12
    南    Z    Z    18    Z    Z    Z
    深度优先遍历结点:
    ->北->上->广->重->武->南

     

    展开全文
  • JAVA 算法 分配算法

    千次阅读 2019-05-07 14:49:02
    收集一些有趣的分配算法思路 https://blog.csdn.net/u010466329/article/details/78672553 https://blog.csdn.net/u010900754/article/details/84452036 ... ...
    展开全文
  • JAVA 算法之穷举法

    千次阅读 2018-03-22 10:11:04
    java算法之穷举法一。什么是穷举法? 在算法中, 穷举算法是最简单的一种算法,其依赖于计算机强大的计算能力,来穷举每一种可能的情况,以达到解决问题的目的 。 穷举法基本思想是逐一列举问题所涉及的所有情形,...
  • JAVA算法:校验数字(Valid Number)JAVA版本 验证给定的字符串是否可以解释为十进制数字。 例如: "0"=>true " 0.1 "=>true "abc"=>false "1 a"=>false "2e10"=>true " -90e3"=>true " 1e"=>...
  • 实战应用Java算法分析与设计(链表、二叉树、哈夫曼树、图、动态规划、HashTable算法) 适合人群:中级 课时数量:38课时 用到技术:Java算法 涉及项目:案例应用实战 咨询qq:1840215592 课程简介: 算法...
  • 生成小学加减口算题JAVA算法

    千次阅读 2016-06-21 06:19:16
    生成小学加减口算题JAVA算法
  • java算法插入排序优化代码

    千次阅读 2014-07-28 09:35:56
    java算法插入排序优化代码 代码下载地址:http://www.zuidaima.com/share/1550463280630784.htm
  • java算法复杂度

    千次阅读 2016-03-05 16:16:08
    同一问题可用不同算法解决,而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法算法复杂度分为时间复杂度和空间复杂度。其作用: 时间复杂度是度量算法执行的时间长短...
  • java 算法学习 --- 常用的算法

    千次阅读 多人点赞 2018-07-23 15:42:35
    编程语言的几种基本算法主要有以下几个: 1、 插入排序(直接插入排序、 希尔排序) 2、 交换排序(冒泡排序、快速排序) 3、 选择排序(直接选择排序、 堆排序) 4、 归并排序 5、 分配排序(箱排序、 基数排序) ...
  • JAVA算法:M个苹果放到N个盘子中的方法(JAVA代码) 题目描述: 把M个同样的苹果放在N个同样的盘子里,允许有的盘子空着不放,问共有多少种不同的分法? 说明1:5,1,1和1,5,1 是同一种放置方法。 说明2:1&...
  • JAVA算法:在给定的数组中查找出现次数最多的元素(JAVA版本) 题目要求:在给定的数组中查找出现次数最多的元素,以及其出现的次数。 例如:在数组{ 2, 3, 1, 2, 2, 5, 6, 8, 2, 3, 2, 4, 2 }中,元素2出现的次数...
  • Java算法分析与设计视频教程

    千次阅读 2013-12-20 09:21:55
    分享一套牛牧老师的《实战应用Java算法分析与设计(链表、二叉树、哈夫曼树、图、动态规划、HashTable算法)》视频教程,通过本课程的学习,学员可以掌握以下技术点:线性结构与顺序表、单向链表、循环链表、栈的基本...
  • java算法视频深度讲解

    千次阅读 2017-03-24 22:18:30
    1.java冒泡排序算法 点击打开链接
  • java算法——分解质因数

    万次阅读 2016-07-28 21:35:19
    //分解质因数 //每个合数都可以写成几个质数相乘的形式。其中每个质数都是这个合数的...import java.util.Scanner; public class Zhiyinshu { public static void main(String[] args) { System.out.println(
  • java算法训练 Interval

    千次阅读 2016-12-03 16:40:35
    //算法训练 Interval package lanqiaobei; import java.util.Scanner; public class Main10 { public static void main(String args[]) { Scanner scanner=new Scanner(System.in); int n=scanner.nextInt()...
  • 排序算法猴子排序java算法代码实现

    千次阅读 2019-01-10 16:29:54
    * @Description: 经典排序算法猴子排序 * @author jiangya * @date 2019年1月10日 下午4:25:36  */ public class MonkeySort { public static void main(String[] args) { List<Integer> arr = new ...
  • Java算法——判断素数

    千次阅读 2007-06-07 21:32:00
    Java算法——判断素数,供自己学习方便和初学者参考! public static boolean isPrimeNumber(int number) { if (number ) { return false; } for (i
  • Java算法,区间计算

    千次阅读 2019-11-02 18:19:33
    高中数学题,用代码解释清楚纯属瞎闹。见笑见笑。...import java.util.List; public class turnOver { public static int per1 = 1000; public static int per2 = 2000; public static do...
  • JAVA算法竞赛输入输出专题

    千次阅读 多人点赞 2018-12-23 01:27:00
    小编由于报名了蓝桥杯Java组,所以日常做题从使用C/C++转变成使用Java。在转变的过程中,肯定会遇到很多大大小小的输入输出问题。小编打算总结下来,当做自己学习的材料,也分享给感兴趣的朋友。 文件名问题 在比赛...
  • Java算法 递归算法计算阶乘

    万次阅读 多人点赞 2012-10-30 18:11:28
    代码: package com.xu.main; import java.util.Scanner; public class P9 { static long fact(int n) { if(n ) { return 1; } else { return n * fact(n - 1); } }
  • java 算法问题,求double集合里,值相加无限接近100的,最少有多少个?
  • Java算法:回文数

    千次阅读 2019-09-08 17:09:58
    import java.util.Scanner; public class HuiWenNumber { public static void main(String[] args) { Scanner sc=new Scanner(System.in); String strValue=sc.nextLine(); int value=Integer.parseInt...
  • 如题: 位置可自由挑换,但是不能重复如:12345,12346,12347,12348,12349这样。 java算法,提供思路也行。
  • Java算法之二分法和排序算法

    千次阅读 2015-07-11 16:38:34
    import java.io.IOException; public class Test { /** * @param args * @throws IOException */ public static void main(String[] args) throws Exception { int []arr={22,3,45,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 169,819
精华内容 67,927
关键字:

java算法

java 订阅