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算法大全源码包,1000多种java算法大全源码包
  • Java算法编程题,一共50道,答案完整,可以检测Java的掌握情况
  • Java算法刷题带注释Leetcode,基础算法
  • java算法 面试必备 安卓面试 必备算法
  • java算法大全_java经典算法_算法面试题大全含答案

    万次阅读 多人点赞 2019-05-16 09:44:18
  • java算法大全

    热门讨论 2015-01-21 10:10:43
    · 探索使用C、C++、Java以及Ruby实现的算法解决方案以及开发小贴士。 · 了解算法预期的性能,以及它达到最高性能时所需要的条件。 · 发现不同算法之间相似的设计哲学。 · 学习高级数据结构,来提升算法的性能...
  • Java常用算法汇总

    2018-12-08 19:38:23
    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算法大全源码包 java算法大全,有近100多种常见算法的源代码,是学习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算法竞赛输入输出专题

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

    2020.2.23更新,增加了数组模块


    前言

    小编由于报名了蓝桥杯Java组,所以日常做题从使用C/C++转变成使用Java。在转变的过程中,肯定会遇到很多大大小小的输入输出问题。小编打算总结下来,当做自己学习的材料,也分享给感兴趣的朋友。

    文件名问题

    在比赛提交的代码中,主类必须以public class Main来命名,而且不能带package语句否则会报出编译错误。

    //去掉public或者不使用Main作为类名都会gg,亲测有效orz

    基本的输入和输出

    竞赛入门最经典的问题,莫过于A+B Problem,如果连最基本的输入输出都做不到,学了再多的算法也用不出来。

    import java.util.*;
    public class Main {
    
    	public static void main(String[] args) {
    		Scanner cin = new Scanner(System.in);
    		int a, b;
    		while (cin.hasNext()) {
    			a = cin.nextInt();
    			b = cin.nextInt();
    			System.out.println(a + b);
    		}
    	}
    }
    

    上面代码展示了最基本的输入输出框架,输入类Scanner包含在java.util类包中,首先应该把它导入。

    import java.util.*;
    

    由于java的输入需要预先创建输入类对象,所以我们一般习惯在main函数的第一句先创建这个Scanner类对象,对象命名为cin算是表达对C/C++的热爱和怀念吧hhh
    如果题目数据量比较大的话可以选择第二种初始化方法,运行效率会高上一些。

    Scanner cin = new Scanner(System.in);
    //or
    Scanner cin = new Scanner(new BufferedInputStream(System.in));
    

    由于题目说明“输入包括多组数据,到文件结尾为止”,类比C/C++的格式,我们很容易理解以下的这段java代码

    while (cin.hasNext())  //当输入流中还有数据时
    {
        a = cin.nextInt();
    	b = cin.nextInt();
    }
    

    1.基本数据类型

    这些类型在C/C++中基本上已经用烂了,一般过目一遍就会了。

    int n = cin.nextInt();//读入一个整数
    double d = cin.nextDouble();//读入一个双精度浮点数
    long l = cin.nextLong();//读入一个长整型数
    

    需要注意一点:由于Java的main方法是static类型,所以定义全局变量或者方法的时候就需要加上static关键字!

    2.数组

    关于数组的创建,Java和C/C++也有所不同,它在创建时需要使用new关键字来为其分配存储空间,不过也不会非常麻烦。

    int arr[] = new int[Size];
    //or
    int []arr = new int[Size];
    

    对于二维数组的初始化问题,可以看看我写的另一篇文章:Java 二维数组的初始化

    3.字符&字符串

    Scanner类中并没有提供单个字符char类型的读入方法,但是我们可以先调用next()方法读取只包含一个字符的字符串,然后用charAt(0)返回0号索引处的字符,即可得到读取到单个字符。

    char ch = cin.next().charAt(0);
    

    对于字符串,java中已经封装好了字符串String类,我们也可以用char数组在进行字符串存储。

    String str1 = next(); //相当于C/C++中的scanf("%s",str);或cin>>str;
    String str2 = nextLine();//相当于C/C++中的gets(str2);或者getline(cin,str2);
    
    char s1[] = cin.next().toCharArray();//调用toCharArray()方法将其转化为char类型数组
    char s2[] = cin.nextLine().toCharArray();//类比理解
    

    但是要注意的是,我们不能像C++那样直接用数组下标去访问String类对象中的某号字符。 我们通常利用charAt(int index)方法来访问String类对象中的某号字符,或者不需要调用String类的其他方法的情况下,直接采用char类型数组来存储字符串。

    4.输出

    日常基本的输出:

    System.out.println(); //相当于C++中的cout<<endl;
    System.out.print();   //相当于C++中的cout<<"";
    

    输出到文件中:
    以下情况可能会用到输出到文件中

    • 当数据量过于庞大,java的控制台都无法输出,需要输出到文件中。
    • 用暴力法打表,需要按格式先输入到文件中。
    try {
    	BufferedWriter bw = new BufferedWriter(new FileWriter(new File("E://result.txt")));
    	bw.write(str);//str表示写入文件的内容
    	bw.flush();//立刻将缓存区的数据写入数据流
    	bw.close();//将BufferedWriter流关闭
    } catch (Exception e) {
    	e.printStackTrace();
    }
    

    File(string pathname); 用于初始化文件类,pathname表示文件的路径
    FileWriter(File file); 用于初始化文件写入类FileWriter,file表示文件类对象





    未完待续…

    展开全文
  • Java算法题的常用API一览,适用于准备求职时刷leetcode、lintcode等算法题,或面试白板编程。
  • 小编现在很迷恋刷算法题,就像当初迷恋做数独游戏一样,有种回到高中做数学题的感觉,很爽。 本篇,主要是把自己发表过的算法题做一个总结,一篇概括,所以会持续更新,敬请期待!
  • java 算法学习 --- 常用的算法

    千次阅读 多人点赞 2018-07-23 15:42:35
    编程语言的几种基本算法主要有以下几个: 1、 插入排序(直接插入排序、 希尔排序) 2、 交换排序(冒泡排序、快速排序) 3、 选择排序(直接选择排序、 堆排序) 4、 归并排序 5、 分配排序(箱排序、 基数排序) ...
  • Java算法从入门到精通(一)

    万次阅读 多人点赞 2018-11-05 16:35:34
     时间复杂度为一个算法流程中,在最差的数据情况下,常数操作数量的指标。常用O (读作big O)来表示。具体来说,在常数操作数量的表达式中, 只要高阶项,不要低阶项,也不要高阶项的系数,剩下的部分 如果记为f(N...
  • java算法全卷(包括基本算法和图算法)
  • 经典的Java算法面试题

    千次阅读 2017-10-11 17:35:51
    public class JavaTest { //贪心算法 编写一个方法,计算一个字符串中,第一个不重复 的字符在当前字符串中的索引。 public static String array = "abuacdeaudbdfcefhph"; public static int[] conta
  • DES算法Java实现源代码

    2019-04-08 17:36:47
    DES算法Java实现源代码;网络安全技术及应用;java图形界面实现
  • java算法大全(含源码包)

    千次下载 热门讨论 2011-08-28 16:19:38
    java算法大全,有近100多种常见算法的源代码,是学习JAVA算法的难得资料。
  • Java算法4-- 图像压缩算法执行过程

    千次阅读 2016-09-29 08:37:00
    图像压缩算法执行过程
  • java算法书籍(数据结构与算法分析(Java版)英文版+java算法全卷)
  • Java 算法:最短路径问题

    千次阅读 2019-04-24 16:34:29
    最短路径问题适合于有向图与无向图: 应用: 路径规划:每个顶点就是城市,边就是道路。 工作任务:从一个点起始任务到另一个点任务完成,边就是完成任务的耗费。...例如无权图的广度优先遍历:结果就是求出了一个...
  • Java 算法时间复杂度和空间复杂度

    千次阅读 2017-06-09 14:09:51
    先补充一下概念:Java 内存模型中的可见性、原子性和有序性。 可见性:  可见性是一种复杂的属性,因为可见性中的错误总是会违背我们的直觉。通常,我们无法确保执行读操作的线程能适时地看到其他线程写入的...
  • 网上找了不少定位算法的资源,都不够全面,后来自己结合了网上的一些算法实现,自己写了一个java 的三角质心的算法
  • Java 算法导论 电子书

    2010-06-30 11:28:45
    Java 算法导论 电子书Java 算法导论 电子书Java 算法导论 电子书
  • Java冒泡排序算法

    万次阅读 多人点赞 2018-10-21 07:25:16
    java冒泡排序算法 1.基本思想: 对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组的前面(从小到大排序),把大的元素移动到数组的后面,即交换两个元素的位置,这样较小的元素就像气泡一样从...
  • 一份很好的java 算法大全,java进阶的必备神器。非常经典的一些小算法。搞java的可以备一份
  • java算法大全源码包.rar ,JAVA,算法 java算法大全源码包.rar ,JAVA,算法 java算法大全源码包.rar ,JAVA,算法
  • java算法(推荐)

    2009-04-23 19:14:24
    java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java算法(推荐)java...
  • DFS算法题解两个例子(走迷宫和求排列组合数) 用DFS算法来求解几道题目。典型的问题是走迷宫问题。 走迷宫题目描述 给定一个M*N的矩阵(二维数组),分别用0和1表示通路和障碍物。即 0 表示 通路;1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,151,104
精华内容 460,441
关键字:

java算法

java 订阅