大神们帮帮我~ Java编程:数组中有20个数，把数组看成首尾相连的环，找出哪四个相邻数的和为最大

给你代码：

凌云ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18980820575（备注：SSL证书合作）期待与您的合作！

import java.util.*;

public class Test

{

public static void main(String... args)

{

Random r=new Random();

int[] a=new int[20];

for(int i=0;ia.length;i++)

{

a[i]=r.nextInt(100);

}

System.out.println("数组："+Arrays.toString(a));

System.out.print("索引：\t");

int index=getIndex(a);

for(int i=0;i4;i++)

{

int ind=index+i;

ind=ind=a.length?ind-a.length:ind;

System.out.print(ind+"\t");

}

System.out.println();

System.out.println("和："+getSum(a,index));

}

static int getIndex(int[] arr) throws IllegalArgumentException

{

if(arr.length4) throw new IllegalArgumentException();

int maxSum=0;

int index=0;

for(int i=0;iarr.length;i++)

{

int sum=getSum(arr,i);

if(summaxSum){ maxSum=sum; index=i;}

}

return index;

}

static int getSum(int[] arr,int index) throws IllegalArgumentException

{

if(arr.length4) throw new IllegalArgumentException();

int sum=0;

for(int i=0;i4;i++)

{

int ind=index+i;

ind=ind=arr.length?ind-arr.length:ind;

sum+=arr[ind];

}

return sum;

}

}

c++或java实现，判断有向图中是否存在环路，并输出所有环路

有向图是个什么东西？ 一张图片么？

package test;

import java.util.*;

public class GectorGraph {

private Point root;

private ListListString circlePath;

public GectorGraph(String pointName) {

root=new Point(pointName);

}

public GectorGraph(Point point) {

root=point;

}

public boolean hasCirclePath(){

findCirclePath();

return circlePath.size()0;

}

public void findCirclePath(){

ListPoint CirclePoints=findCirclePoint();

if(circlePath==null){circlePath=new ArrayListListString();}

for(Point tempPoint:CirclePoints){

ListString pointPath=new ArrayListString();

findPointPath(tempPoint,root,pointPath);

pointPath.add(root.pointName);

circlePath.add(pointPath);

}

}

public boolean findPointPath(Point target,Point currentPoint,ListString pointPath){

if(currentPoint.equals(target)){return true;}

if(!currentPoint.hasNext()){return false;}

ListPoint pointList= currentPoint.getNextPointList();

for(Point tempPoint:pointList){

if(tempPoint.equals(root)){continue;}

if(findPointPath(target,tempPoint,pointPath)){

pointPath.add(tempPoint.pointName);

return true;

}

}

return false;

}

private ListPoint findCirclePoint(){

if(!root.hasNext()){return null;}

ListPoint circlePoints=new ArrayListPoint();

findCirclePoint(root,root,circlePoints);

return circlePoints;

}

private void findCirclePoint(Point root,Point currentPoint,ListPoint circlePoints){

if(!currentPoint.hasNext()){return;}

ListPoint pointList= currentPoint.getNextPointList();

for(Point tempPoint:pointList){

if(tempPoint.equals(root)){circlePoints.add(currentPoint);}

else{findCirclePoint(root,tempPoint,circlePoints);}

}

}

public void showPath(){

if(circlePath==null){System.out.println("Error");}

for(ListString tempList:circlePath){

StringBuffer pathString=new StringBuffer();

int tempListIndex=tempList.size()-1;

for(;tempListIndex-1;tempListIndex--){

pathString.append(tempList.get(tempListIndex));

if(tempListIndex!=0){pathString.append("-");}

}

System.out.println(pathString.toString());

}

}

public static void main(String[] args) {

Point root=new Point("root");

ListPoint p3=new ArrayListPoint();

for(int i=0;i3;i++){

p3.add(new Point("3/1/"+i));

}

ListPoint p4=new ArrayListPoint();

for(int i=0;i3;i++){

p4.add(new Point("3/2/"+i));

}

ListPoint p2=new ArrayListPoint();

for(int i=0;i2;i++){

p2.add(new Point("2/"+i));

}

p3.add(0,root);

p3.get(2).addNextPoint(root);

p4.get(0).addNextPoint(root);

p2.get(0).addNextPointList(p3);

p2.get(1).addNextPointList(p4);

root.addNextPointList(p2);

GectorGraph gg=new GectorGraph(root);

if(gg.hasCirclePath()){

gg.showPath();

}

}

}

class Point{

public String pointName;

private ListPoint nextPointList;

public Point(String pointName) {

this.pointName=pointName;

}

public void addNextPoint(Point p){

if(nextPointList==null){nextPointList=new ArrayListPoint();}

nextPointList.add(p);

}

public void addNextPointList(ListPoint pList){

if(nextPointList==null){nextPointList=new ArrayListPoint();}

nextPointList.addAll(pList);

}

public boolean hasNext(){

return nextPointList!=null!nextPointList.isEmpty();

}

public ListPoint getNextPointList() {

return nextPointList;

}

public void setNextPointList(ListPoint nextPointList) {

this.nextPointList = nextPointList;

}

}

呵呵，java写的，这个有点搅，求高手给个思路。

4啊4->'>求一段java程序，求图是否存在环。该图是有向图。要求该方法输入边的序对集合，比如3->4啊4->

一个顶点a在一个环上，那么存在以它为终点的边, 假设这些边的起点集合为PreA, 考察点a能否到达点PreA中的点，如果到达就找到了一个环，否则点a不在环上。

遍历图中的顶点进行上述操作即可。

Java判断单链表是否有环的两种实现方法

方法一：首先从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就从头节点重新遍历新节点之前的所有节点，用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID，则说明该节点被遍历过两次，链表有环；如果之前的所有节点当中不存在相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

例如这样的链表：A-B-C-D-B-C-D， 当遍历到节点D的时候，我们需要比较的是之前的节点A、B、C，不存在相同节点。这时候要遍历的下一个新节点是B，B之前的节点A、B、C、D中恰好也存在B，因此B出现了两次，判断出链表有环。

假设从链表头节点到入环点的距离是D，链表的环长是S。D+S是链表总节点数。那么算法的时间复杂度是0+1+2+3+….+(D+S-1) = (D+S-1)*(D+S)/2 ， 可以简单地理解成 O(N*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)。

方法二：首先创建一个以节点ID为键的HashSet集合，用来存储曾经遍历过的节点。然后同样是从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就用新节点和HashSet集合当中存储的节点作比较，如果发现HashSet当中存在相同节点ID，则说明链表有环，如果HashSet当中不存在相同的节点ID，就把这个新节点ID存入HashSet，之后进入下一节点，继续重复刚才的操作。

这个方法在流程上和方法一类似，本质的区别是使用了HashSet作为额外的缓存。

假设从链表头节点到入环点的距离是D，链表的环长是S。而每一次HashSet查找元素的时间复杂度是O(1), 所以总体的时间复杂度是1*(D+S)=D+S，可以简单理解为O(N)。而算法的空间复杂度还是D+S-1，可以简单地理解成O(N)。

方法三：首先创建两个指针1和2（在Java里就是两个对象引用），同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。

例如链表A-B-C-D-B-C-D，两个指针最初都指向节点A，进入第一轮循环，指针1移动到了节点B，指针2移动到了C。第二轮循环，指针1移动到了节点C，指针2移动到了节点B。第三轮循环，指针1移动到了节点D，指针2移动到了节点D，此时两指针指向同一节点，判断出链表有环。

此方法也可以用一个更生动的例子来形容：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。

标题名称：java代码找出所有环 java代码找出所有环形图
网页地址：http://myzitong.com/article/hppeoc.html