实时搜索: java有哪些算法

java有哪些算法

365条评论 1943人喜欢 2689次阅读 622人点赞
新入坑菜鸟,麻烦大神们帮我解释下:
public static void merge(int[]a ,int lower, int mid,int upper){

int[] temp=new int[upper-lower+1];
int i=lower;
int j=mid+1;
int k=0;
while(i<=mid&&j<=upper){
if(a[i]<a[j]){
temp[k++]=a[i++];

}els...

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++代码格式的,你可以参考一下思路

  • 13岁女孩怎样变白

    Aj11黑红low气垫这的小点是是什么?: 这不是气垫吧。。。就是鞋面的纹理 ...

    591条评论 2045人喜欢 2670次阅读 631人点赞
  • gs4和gs5哪个好

    aj11黑红低帮有女款吗:   aj11黑红低帮有女款,一般AJ出品新鞋都会有女款的。  GS是GIRL STYLE的缩写。表示女款。通常为35-40码之间,长度小于男码,有些GS款的鞋子的科技配置也会比男款差(特别是篮球鞋,因为女生打篮球不如...

    468条评论 5575人喜欢 3167次阅读 328人点赞
  • etc客服电话是多少

    为什么那些女明星那么有钱还要个个找有钱的: 价值取向不一样,日本的演艺女明星基本不嫁有钱人,她们也只把演艺事业当做自己的职业,一般只找对自己好的,能相守一辈子的 ...

    846条评论 5170人喜欢 5949次阅读 327人点赞
  • htcm9如何

    现在有许多演艺圈明星拥有外国国籍,却在国内捞金,对此,你怎么看?: 这些人大部分都是为了生活,因此这样能够赚钱,因为本身外国人就是可以吸引观众们的注意力,他们背后肯定也是有团队的。 ...

    574条评论 4890人喜欢 2232次阅读 722人点赞