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();
};
}