java有哪些算法

java 最短路径算法 如何实现有向 任意两点的最短路径: 　　Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

　　Dijkstra一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表方式
　　用OPEN,CLOSE表的方式，其采用的是贪心法的算法策略，大概过程如下：
　　1.声明两个集合，open和close，open用于存储未遍历的节点，close用来存储已遍历的节点
　　2.初始阶段，将初始节点放入close，其他所有节点放入open
　　3.以初始节点为中心向外一层层遍历，获取离指定节点最近的子节点放入close并从新计算路径，直至close包含所有子节点

　　代码实例如下：
　　Node对象用于封装节点信息，包括名字和子节点
　　[java] view plain copy
　　public class Node {
　　private String name;
　　private Map<Node,Integer> child=new HashMap<Node,Integer>();
　　public Node(String name){
　　this.name=name;
　　}
　　public String getName() {
　　return name;
　　}
　　public void setName(String name) {
　　this.name = name;
　　}
　　public Map<Node, Integer> getChild() {
　　return child;
　　}
　　public void setChild(Map<Node, Integer> child) {
　　this.child = child;
　　}
　　}

　　MapBuilder用于初始化数据源，返回图的起始节点
　　[java] view plain copy
　　public class MapBuilder {
　　public Node build(Set<Node> open, Set<Node> close){
　　Node nodeA=new Node("A");
　　Node nodeB=new Node("B");
　　Node nodeC=new Node("C");
　　Node nodeD=new Node("D");
　　Node nodeE=new Node("E");
　　Node nodeF=new Node("F");
　　Node nodeG=new Node("G");
　　Node nodeH=new Node("H");
　　nodeA.getChild().put(nodeB, 1);
　　nodeA.getChild().put(nodeC, 1);
　　nodeA.getChild().put(nodeD, 4);
　　nodeA.getChild().put(nodeG, 5);
　　nodeA.getChild().put(nodeF, 2);
　　nodeB.getChild().put(nodeA, 1);
　　nodeB.getChild().put(nodeF, 2);
　　nodeB.getChild().put(nodeH, 4);
　　nodeC.getChild().put(nodeA, 1);
　　nodeC.getChild().put(nodeG, 3);
　　nodeD.getChild().put(nodeA, 4);
　　nodeD.getChild().put(nodeE, 1);
　　nodeE.getChild().put(nodeD, 1);
　　nodeE.getChild().put(nodeF, 1);
　　nodeF.getChild().put(nodeE, 1);
　　nodeF.getChild().put(nodeB, 2);
　　nodeF.getChild().put(nodeA, 2);
　　nodeG.getChild().put(nodeC, 3);
　　nodeG.getChild().put(nodeA, 5);
　　nodeG.getChild().put(nodeH, 1);
　　nodeH.getChild().put(nodeB, 4);
　　nodeH.getChild().put(nodeG, 1);
　　open.add(nodeB);
　　open.add(nodeC);
　　open.add(nodeD);
　　open.add(nodeE);
　　open.add(nodeF);
　　open.add(nodeG);
　　open.add(nodeH);
　　close.add(nodeA);
　　return nodeA;
　　}
　　}
　　图的结构如下图所示：

　　Dijkstra对象用于计算起始节点到所有其他节点的最短路径
　　[java] view plain copy
　　public class Dijkstra {
　　Set<Node> open=new HashSet<Node>();
　　Set<Node> close=new HashSet<Node>();
　　Map<String,Integer> path=new HashMap<String,Integer>();//封装路径距离
　　Map<String,String> pathInfo=new HashMap<String,String>();//封装路径信息
　　public Node init(){
　　//初始路径,因没有A->E这条路径,所以path(E)设置为Integer.MAX_VALUE
　　path.put("B", 1);
　　pathInfo.put("B", "A->B");
　　path.put("C", 1);
　　pathInfo.put("C", "A->C");
　　path.put("D", 4);
　　pathInfo.put("D", "A->D");
　　path.put("E", Integer.MAX_VALUE);
　　pathInfo.put("E", "A");
　　path.put("F", 2);
　　pathInfo.put("F", "A->F");
　　path.put("G", 5);
　　pathInfo.put("G", "A->G");
　　path.put("H", Integer.MAX_VALUE);
　　pathInfo.put("H", "A");
　　//将初始节点放入close,其他节点放入open
　　Node start=new MapBuilder().build(open,close);
　　return start;
　　}
　　public void computePath(Node start){
　　Node nearest=getShortestPath(start);//取距离start节点最近的子节点,放入close
　　if(nearest==null){
　　return;
　　}
　　close.add(nearest);
　　open.remove(nearest);
　　Map<Node,Integer> childs=nearest.getChild();
　　for(Node child:childs.keySet()){
　　if(open.contains(child)){//如果子节点在open中
　　Integer newCompute=path.get(nearest.getName())+childs.get(child);
　　if(path.get(child.getName())>newCompute){//之前设置的距离大于新计算出来的距离
　　path.put(child.getName(), newCompute);
　　pathInfo.put(child.getName(), pathInfo.get(nearest.getName())+"->"+child.getName());
　　}
　　}
　　}
　　computePath(start);//重复执行自己,确保所有子节点被遍历
　　computePath(nearest);//向外一层层递归,直至所有顶点被遍历
　　}
　　public void printPathInfo(){
　　Set<Map.Entry<String, String>> pathInfos=pathInfo.entrySet();
　　for(Map.Entry<String, String> pathInfo:pathInfos){
　　System.out.println(pathInfo.getKey()+":"+pathInfo.getValue());
　　}
　　}
　　/**
　　* 获取与node最近的子节点
　　*/
　　private Node getShortestPath(Node node){
　　Node res=null;
　　int minDis=Integer.MAX_VALUE;
　　Map<Node,Integer> childs=node.getChild();
　　for(Node child:childs.keySet()){
　　if(open.contains(child)){
　　int distance=childs.get(child);
　　if(distance<minDis){
　　minDis=distance;
　　res=child;
　　}
　　}
　　}
　　return res;
　　}
　　}

　　Main用于测试Dijkstra对象
　　[java] view plain copy
　　public class Main {
　　public static void main(String[] args) {
　　Dijkstra test=new Dijkstra();
　　Node start=test.init();
　　test.computePath(start);
　　test.printPathInfo();
　　}
　　}

JAVA归并排序算法，有两行代码看不懂: 以var a = [4,2,6,3,1,9,5,7,8,0];为例子。

1.希尔排序。 希尔排序是在插入排序上面做的升级。是先跟距离较远的进行比较的一些方法。
function shellsort(arr){ var i,k,j,len=arr.length,gap = Math.ceil(len/2),temp; while(gap>0){ for (var k = 0; k < gap; k++) { var tagArr = []; tagArr.push(arr[k]) for (i = k+gap; i < len; i=i+gap) { temp = arr[i]; tagArr.push(temp); for (j=i-gap; j >-1; j=j-gap) { if(arr[j]>temp){ arr[j+gap] = arr[j]; }else{ break; } } arr[j+gap] = temp; } console.log(tagArr,"gap:"+gap);//输出当前进行插入排序的数组。 console.log(arr);//输出此轮排序后的数组。 } gap = parseInt(gap/2); } return arr; }
过程输出：

[4, 9] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] "gap:5" [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] "gap:2" [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] "gap:2" [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] "gap:1" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
由输出可以看到。第一轮间隔为5。依次对这些间隔的数组插入排序。
间隔为5：

[4, 9] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] "gap:5" [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] "gap:2" [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] "gap:2" [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] "gap:1" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
间隔为2：

[4, 2, 6, 3, 0, 9, 5, 7, 8, 1] 4 6 0 5 8 2 3 9 7 1
排序后：
[0, 1, 4, 2, 5, 3, 6, 7, 8, 9]

间隔为1：
排序后：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。

2.快速排序。把一个数组以数组中的某个值为标记。比这个值小的放到数组的左边，比这个值得大的放到数组的右边。然后再递归 对左边和右边的数组进行同样的操作。直到排序完成。通常以数组的第一个值为标记。
代码:

function quickSort(arr){ var len = arr.length,leftArr=[],rightArr=[],tag; if(len<2){ return arr; } tag = arr[0]; for(i=1;i<len;i++){ if(arr[i]<=tag){ leftArr.push(arr[i]) }else{ rightArr.push(arr[i]); } } return quickSort(leftArr).concat(tag,quickSort(rightArr)); }
3.归并排序。把一系列排好序的子序列合并成一个大的完整有序序列。从最小的单位开始合并。然后再逐步合并合并好的有序数组。最终实现归并排序。
合并两个有序数组的方法：

function subSort(arr1,arr2){ var len1 = arr1.length,len2 = arr2.length,i=0,j=0,arr3=[],bArr1 = arr1.slice(),bArr2 = arr2.slice(); while(bArr1.length!=0 || bArr2.length!=0){ if(bArr1.length == 0){ arr3 = arr3.concat(bArr2); bArr2.length = 0; }else if(bArr2.length == 0){ arr3 = arr3.concat(bArr1); bArr1.length = 0; }else{ if(bArr1[0]<=bArr2[0]){ arr3.push(bArr1[0]); bArr1.shift(); }else{ arr3.push(bArr2[0]); bArr2.shift(); } } } return arr3; }
归并排序：

function mergeSort(arr){ var len= arr.length,arrleft=[],arrright =[],gap=1,maxgap=len-1,gapArr=[],glen,n; while(gap<maxgap){ gap = Math.pow(2,n); if(gap<=maxgap){ gapArr.push(gap); } n++; } glen = gapArr.length; for (var i = 0; i < glen; i++) { gap = gapArr[i]; for (var j = 0; j < len; j=j+gap*2) { arrleft = arr.slice(j, j+gap); arrright = arr.slice(j+gap,j+gap*2); console.log("left:"+arrleft,"right:"+arrright); arr = arr.slice(0,j).concat(subSort(arrleft,arrright),arr.slice(j+gap*2)); } } return arr; }
排序[4,2,6,3,1,9,5,7,8,0]输出：

left:4 right:2 left:6 right:3 left:1 right:9 left:5 right:7 left:8 right:0 left:2,4 right:3,6 left:1,9 right:5,7 left:0,8 right: left:2,3,4,6 right:1,5,7,9 left:0,8 right: left:1,2,3,4,5,6,7,9 right:0,8
看出来从最小的单位入手。
第一轮先依次合并相邻元素：4,2; 6,3; 1,9; 5,7; 8,0
合并完成之后变成： [2,4,3,6,1,9,5,7,0,8]
第二轮以2个元素为一个单位进行合并：[2,4],[3,6]; [1,9],[5,7]; [0,8],[];
合并完成之后变成：[2,3,4,6,1,5,7,9,0,8]
第三轮以4个元素为一个单位进行合并：[2,3,4,6],[1,5,7,9]; [0,8],[]
合并完成之后变成： [1,2,3,4,5,6,7,9,0,8];
第四轮以8个元素为一个单位进行合并： [1,2,3,4,5,6,7,9],[0,8];
合并完成。 [0,1,2,3,4,5,6,7,8,9];

java中哪种查找算法最有效率:

这个问题不能一概而论

如果有一种算法优于其他算法，那么其他算法就不存在了不是？

所以，要看在什么情况下，那么有这么几个方面

背景数量级和匹配数量级，就是说你要在多少数据中查找多少数据。

背景数据差异度，背景数据如果包罗万象，或者都是数字，那么选择的算法区别就大了

背景数据整理程度。很多人在选择查找算法时不考虑这个，但是这在实际应用中很有异议，比如数据都排序过和没有排序过，可想而知算法的选择有很大的不同。

匹配方式，是用“等于” 这种方式匹配，还是用like这种方式匹配，也对算法有很大影响。

括号匹配算法 java找出有多少种移除方案: 括号匹配算法 java找出有多少种移除方案
mport java.util.Scanner;
import java.util.Stack;

/**
* @author Owner
*
*/
public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

int n= sc.nextInt();//3条测试数据数据

Stack<Character> stack = null;

while(n!=0){

//从控制台读入一个测试字符串[]() [(])
String str = sc.next();
//如果该输入字符串为奇数，说明不匹配
if(str.length() % 2 == 1){
System.out.println("No");
}else{
//说明字符是偶数
stack = new Stack<Character>();

//遍历第一条测试字符串[]() [(])
for(int i=0;i<str.length();i++){
if(stack.isEmpty()){
//如果栈是空的
stack.push(str.charAt(i));
}else if(stack.peek() == '[' && str.charAt(i) == ']' || stack.peek() == '(' && str.charAt(i) == ')'){
//说明此时栈中字符不是空的,并且符合，
stack.pop();
}else{

stack.push(str.charAt(i));
}
}

if(stack.isEmpty()){
//如果栈是空的，说明括号匹配
System.out.println("Yes");
}else{
//说明栈不为空，括号不匹配
System.out.println("No");
}
}

n--;
}

}
}

java 中的排序算法 有什么作用 我在编程的时候很少 用到啊 它们主要用在哪些方面: 排序用到的地方很多,列表按某种规则排序

java的递归算法，求大神: public class Test{
static public double totalEarnings(double principal, double interest, int years){
if(years<1) return principal;
double earning=principal*interest;
System.out.format("principal:%.3f, earning:%.3f\n",principal,earning);
principal+=earning;
return totalEarnings(principal,interest, years-1);
}
public static void main(String[] args) throws Exception {
System.out.format("total:%.3f\n",totalEarnings(50000,0.046,5));
}
}principal:50000.000, earning:2300.000
principal:52300.000, earning:2405.800
principal:54705.800, earning:2516.467
principal:57222.267, earning:2632.224
principal:59854.491, earning:2753.307
total:62607.798

匈牙利算法 java: #include<stdio.h>
#include<string.h>
bool g[201][201];
int n,m,ans;
bool b[201];
int link[201];
bool init()
{
int _x,_y;
memset(g,0,sizeof(g));
memset(link,0,sizeof(link));
ans=0;
if(scanf("%d%d",&n,&m)==EOF)return false;
for(int i=1;i<=n;i++)
{
scanf("%d",&_x);
for(int j=0;j<_x;j++)
{
scanf("%d",&_y);
g[ i ][_y]=true;
}
}
return true;
}
bool find(int a)
{
for(int i=1;i<=m;i++)
{
if(g[a][ i ]==1&&!b[ i ])
{
b[ i ]=true;
if(link[ i ]==0||find(link[ i ]))
{
link[ i ]=a;
return true;
}
}
}
return false;
}
int main()
{
while(init())
{
for(int i=1;i<=n;i++)
{
memset(b,0,sizeof(b));
if(find(i))ans++;
}
printf("%d\n",ans);
}
}
Pascal:
Program matching;
Const
max = 1000;
Var
map : array [1..max, 1..max] of boolean; {邻接矩阵}
match: array [1..max] of integer; {记录当前连接方式}
chk : array [1..max] of boolean; {记录是否遍历过，防止死循环}
m, n, i, t1, t2, ans,k: integer;
Function dfs(p: integer): boolean;
var
i, t: integer;
begin
for i:=1 to k do
if map[p, i] and not chk[ i ] then
begin
chk[ i ] := true;
if (match[ i ] = 0) or dfs(match[ i ]) then {没有被连过 或 寻找到增广路}
begin
match[ i ] := p;
exit(true);
end;{if}
end;{for}
exit(false);
end;{function}
begin{main}
readln(n, m); {N 为二分图左侧点数 M为可连接的边总数}
fillchar(map, sizeof(map), 0);
k:=0;
for i:=1 to m do{initalize}
begin
readln(t1, t2);
map[t1, t2] := true;
if k<t2 then k:=t2;
end;{for}
fillchar(match, sizeof(match), 0);
ans := 0;
for i:=1 to n do
begin
fillchar(chk, sizeof(chk), 0);
if dfs(i) then inc(ans);
end;
writeln(ans);
for i:=1 to 1000 do
if match[ i ] <> 0 then
writeln(match[ i ], '-->', i);
end.

有大侠知道java或是js或是css中怎么将单通道灰度图片与三通道灰度图片吗？有没有什么相关的算法啊？: int ImageStretchByHistogram(IplImage *src1,IplImage *dst1)
/*************************************************
Function: 通过直方图变换进行图像增强，将图像灰度的域值拉伸到0-255
src1: 单通道灰度图像
dst1: 同样大小的单通道灰度图像
*************************************************/
{
assert(src1->width==dst1->width);
double p[256],p1[256],num[256];

memset(p,0,sizeof(p));
memset(p1,0,sizeof(p1));
memset(num,0,sizeof(num));
int height=src1->height;
int width=src1->width;
long wMulh = height * width;

//statistics
for(int x=0;x<src1->width;x++)
{
for(int y=0;y<src1-> height;y++){
uchar v=((uchar*)(src1->imageData + src1->widthStep*y))[x];
num[v]++;
}
}
//calculate probability
for(int i=0;i<256;i++)
{
p[i]=num[i]/wMulh;
}

//p1[i]=sum(p[j]); j<=i;
for(int i=0;i<256;i++)
{
for(int k=0;k<=i;k++)
p1[i]+=p[k];
}

// histogram transformation
for(int x=0;x<src1->width;x++)
{
for(int y=0;y<src1-> height;y++){
uchar v=((uchar*)(src1->imageData + src1->widthStep*y))[x];
((uchar*)(dst1->imageData + dst1->widthStep*y))[x]= p1[v]*255+0.5;
}
}
return 0;
}

void CCVMFCView::OnImageAdjustContrast()
{
if(workImg->nChannels>1)
OnColorToGray();
Invalidate();
dst=cvCreateImage(cvGetSize(workImg),workImg->depth,workImg->nChannels);
ImageStretchByHistogram(workImg,dst);
m_dibFlag=imageReplace(dst,&workImg);
Invalidate();
}

这个是C++代码格式的，你可以参考一下思路