java是如何实现算法

‘壹’ 用java实现一个算法

import java.lang.Math;
import java.util.Random;

/**
* 冒泡排序
* 该程序先随机生成一个长度为10,并且数值在10-210之间的数组
* 然后通过冒泡的方法对生成的数组进行排序并从控制台输出。
*
*/
public class SortTest {
/**
* 升序标志
*/
public static final int SHENGXU=1;
/**
* 降序标志
*/
public static final int JIANGXU=2;
/**
* 主函数
* @param args
*/
public static void main(String args[]) {
SortTest.execSort(JIANGXU);
}

/**
* 交换值，交换数组的两个值
* @param array 操作的数组
* @param i 第一个
* @param j 第二个
*/
private static void jiaohuan(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}

/**
*
* @param method
* 1为升序，2为降序
*/
public static void execSort(int method) {
int[] array = null;
array = initArray(10, 210, 10);
int[] orderarray = maopao(array,method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}

/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];

for (int i = 0; i < size; i++) {
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}

/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] maopao(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
jiaohuan(array,i,j);
}else if (method==1)
if (array[i] > array[j])
jiaohuan(array,i,j);
}
}
return array;
}
}

‘贰’ java实现几种常见排序算法

下面给你介绍四种常用排序算法：

1、冒泡排序

特点：效率低，实现简单

思想（从小到大排）：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。

‘叁’ java程序中，实现一种算法

相同点：都是JVM加载类后且在构造函数执行之前执行，在类中可定义多个，一般在代码块中对一些static变量进行赋值。

不同点：静态代码块在非静态代码块之前执行。静态代码块只在第一次new时执行一次，之后不在执行。而非静态代码块每new一次就执行一次。

‘肆’ java如何实现下面算法

//大概看了一下,发现所需人力没说明什么用,在本题中处于什么条件
//只说思路要去买饭,懒得写code

//1.定义一个Task属性开始时间结束时间人力

//2.将5个任务放到一个集合中tasks=List<Task>

//3.循环输出,第一次拿Task1的endTime与下一个Task的startTime比较,如果小则count计数+1
//并将Task1的endTime=(下一个Task的endTime)
//这写一下吧
DateendTime=null;
intcount=0;

for(Tasktask:tasks){//第一种情况第一个任务他参与,第二种情况他从第二个任务参与
endTime=task.EndTime;
for(Tasktask:tasks){
if(endTime<task.StartTime){
count++;
endTime=task.EndTime;
}
}
}
count即为最大任务数;

//可能有更优方式,懒得想了;

‘伍’ java怎么实现下面的算法

顺序表的逆置：
获取顺序表的头和尾两个index ：first、last，定义for循环、两个临时的index，a和b
a = first + i; b = last - i;
用变量分别获取a和b两个节点的值，然后交换
直到全部交换完成或只剩一个元素时退出循环。
删除值相同的多余元素：
1、定义一个类，类中定义一个顺序表变量，定义添加方法，如果顺序表中已有该值则不添加

‘陆’ java如何实现填充算法

四向连通递归填充算法：
void BoundaryFill4(int x, int y, long FilledColor, long BoundaryColor)
{
long CurrentColor;
CurrentColor = GetPixelColor(x,y);
if (CurrentColor != BoundaryColor && CurrentColor != FilledColor)
{
SetColor(FilledColor);
SetPixel (x,y);
BoundaryFill4(x+1, y, FilledColor, BoundaryColor);
BoundaryFill4(x-1, y, FilledColor, BoundaryColor);
BoundaryFill4(x, y+1, FilledColor, BoundaryColor);
BoundaryFill4(x, y-1, FilledColor, BoundaryColor);
}
}
该算法的优点是非常简单，缺点是需要大量栈空间来存储相邻的点。

‘柒’ 怎样用java 实现计算器的 算法

package com.t.core.util;

/**
* 数学计算工具类
*
* @author Administrator
*
*/
publicclassMathUtil {
// ----------------三角运算----------------------
/**
* 弧度转化为角度
*
* @param degress
* @return
*/
publicstaticdouble toDegress(double degress) {

return Math.toDegrees(degress);
};

/**
* 角度转化为弧度
*
* @param radians
* @return
*/
publicstaticdouble toRadians(double radians) {

return Math.toRadians(radians);
};

/**
* 反余弦
*
* @param acos
* @return角度范围在0.0到pi之间
*/
publicstaticdouble aCos(double acos) {

return Math.acos(acos);
};

/**
* 反正弦
*
* @param asin
* @return角度范围在-pi/2到pi/2之间
*/
publicstaticdouble aSin(double asin) {

return Math.asin(asin);
};

/**
* 反正切
*
* @param atan
* @return角度范围在-pi/2到pi/2之间
*/
publicstaticdouble aTan(double atan) {

return Math.atan(atan);
};

/**
* 三角余弦
*
* @param cos
* @return
*/
publicstaticdouble cos(double cos) {

return Math.cos(cos);
};

/**
* 双曲余弦
*
* @param cosh
* @return
*/
publicstaticdouble cosH(double cosh) {

return Math.cosh(cosh);
};

/**
* 正弦
*
* @param sin
* @return
*/
publicstaticdouble sin(double sin) {

return Math.sin(sin);
};

/**
* 双曲正弦
*
* @param sinh
* @return
*/
publicstaticdouble sinH(double sinh) {

return Math.sinh(sinh);
};

/**
* 三角正切
*
* @param tan
* @return
*/
publicstaticdouble tan(double tan) {

return Math.tan(tan);
};

/**
* 双曲正切
*
* @param tanh
* @return
*/
publicstaticdouble tanH(double tanh) {

return Math.tanh(tanh);
};

/**
* 将矩形坐标(x,y)转换成极坐标(r,thet)
*
* @param x
* @param y
* @return
*/
publicstaticdouble aTan2(double x, double y) {

return Math.atan2(x,y);
};

// ----------------取整运算------------------
/**
* 取整，返回小于目标数的最大整数（地板函数）
*
* @param number
* @return
*/
publicstaticdouble floor(double number) {

return Math.floor(number);
};

/**
* 取整，返回大于目标数的最小整数（天花板函数）
*
* @param number
* @return
*/
publicstaticdouble ceil(double number) {

return Math.ceil(number);
};

/**
* 四舍五入取整
*
* @param number
* @return
*/
publicstaticdouble round(double number) {

return Math.round(number);
};

publicstaticfloat round(float number) {

return Math.round(number);
};

/**
* 平方根
*
* @param number
* @return
*/
publicstaticdouble sqrt(double number) {

return Math.sqrt(number);
};

/**
* 立方根
*
* @param number
* @return
*/
publicstaticdouble cbrt(double number) {

return Math.cbrt(number);
};

/**
* 欧拉数e的n次幂
*
* @param number
* @return
*/
publicstaticdouble exp(double number) {

return Math.exp(number);
};

/**
* sqrt(x2+y2)，没有中间溢出或下溢
*
* @param number
* @param number2
* @return
*/
publicstaticdouble hypot(double number, double number2) {

return Math.hypot(number,number2);
};

/**
* 按照IEEE754标准规定，对两个参数进行余数运算
*
* @param number
* @param number2
* @return
*/
publicstaticdouble IEEEremainder(double number, double number2) {

return Math.IEEEremainder(number,number2);
};

/**
* 乘方
*
* @param number
* @param number2
* @return
*/
publicstaticdouble pow(double number, double number2) {

return Math.pow(number,number2);
};

/**
* 自然对数
*
* @param number
* @return
*/
publicstaticdouble log(double number) {

return Math.log(number);
};

/**
* 底数为10的对数
*
* @param number
* @return
*/
publicstaticdouble log10(double number) {

return Math.log10(number);
};

/**
* 参数与1之和的自然对数
*
* @param number
* @return
*/
publicstaticdouble log1p(double number) {

return Math.log1p(number);
};

// ------------符号相关运算------------------
/**
* 绝对值
*
* @param number
* @return
*/
publicstaticdouble abs(double number) {

return Math.abs(number);
};

publicstaticint abs(int number) {

return Math.abs(number);
};

publicstaticfloat abs(float number) {

return Math.abs(number);
};

publicstaticlong abs(long number) {

return Math.abs(number);
};

/**
* 符号赋值
*
* @param magnitude
* @param sign
* @return带有第二个浮点数符号的第一个浮点参数
*/
publicstaticdouble Sign(double magnitude, double sign) {

return Math.Sign(magnitude,sign);
};

publicstaticfloat Sign(float magnitude, float sign) {

return Math.Sign(magnitude,sign);
};

/**
* 符号函数
*
* @param number
* @return number等于0，返回0；number大于0，返回1；number小于0，返回-1
*/
publicstaticfloat Sign(float number) {

return Math.signum(number);
};

publicstaticdouble Sign(double number) {

return Math.signum(number);
};

/**
* 找出最大值
*
* @param number
* @param number2
* @return
*/
publicstaticdouble max(double number, double number2) {

return Math.max(number,number2);
};

publicstaticint max(int number, int number2) {

return Math.max(number,number2);
};

publicstaticfloat max(float number, float number2) {

return Math.max(number,number2);
};

publicstaticlong max(long number, long number2) {

return Math.max(number,number2);
};

/**
* 计算最小值
*
* @param number
* @param number2
* @return
*/
publicstaticlong min(long number, long number2) {

return Math.min(number,number2);
};

publicstaticint min(int number, int number2) {

return Math.min(number,number2);
};

publicstaticfloat min(float number, float number2) {

return Math.min(number,number2);
};

publicstaticdouble min(double number, double number2) {

return Math.min(number,number2);
};

/**
*
* @param start
* @param direction
* @return第一个参数和第二个参数之间与第一个参数相邻的浮点数
*/
publicstaticdouble nextAfter(double start, double direction) {

return Math.nextAfter(start,direction);
};

publicstaticfloat nextAfter(float start, float direction) {

return Math.nextAfter(start,direction);
};

/**
*
* @param number
* @return比目标数略大的浮点数
*/
publicstaticfloat nextUp(float number) {

return Math.nextUp(number);
};

publicstaticdouble nextUp(double number) {

return Math.nextUp(number);
};

/**
* 随机数
*
* @return
*/
publicstaticdouble random() {

return Math.random();
};
}