如何用java代码实现在一个已排列好的数组中找出小于等于给定x的位数下标（用二分查找做）？

Posted 2023-04-13

参考技术A

import java.util.Arrays;

import java.util.Random;

public class Test 

public int[] getRandom(int len) 

int[] nums = new int[len <= 0 ? 10 : len];

Random random = new Random();

for (int i = 0; i < nums.length; i++) 

nums[i] = random.nextInt(100);

return nums;

public Integer getIndex(int[] nums, int value, int startIndex, int endIndex) 

if (startIndex == endIndex) 

return startIndex;

int index = (startIndex + endIndex) / 2;

if (nums[index] == value) 

return index;

 else if (startIndex + 1 == endIndex && nums[endIndex] > value) 

return endIndex;

 else if (nums[index] > value) 

return getIndex(nums, value, startIndex, index);

 else 

return getIndex(nums, value, index, endIndex);

public static void main(String[] args) 

Test test = new Test();

int value = 50;

int len = 10;

int[] nums = test.getRandom(len);

Arrays.sort(nums);

Integer index = test.getIndex(nums, value, 0, nums.length - 1);

System.out.println(Arrays.toString(nums));

System.out.println(value);

System.out.println(index);

如何用Java实现树形结构啊？

请教各位大虾，如何用Java语言实现树形结构啊？类似：
一级菜单01
二级菜单0101
二级菜单0102
...
一级菜单02
二级菜单0201
二级菜单0202
...

最好能看到源代码，万分感谢！

package tree;

import java.util.LinkedList;
import java.util.List;

/**
* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历
*
* 参考资料0:数据结构(C语言版)严蔚敏
*
* 参考资料1：http://zhidao.baidu.com/question/81938912.html
*
* 参考资料2：http://cslibrary.stanford.edu/110/BinaryTrees.html#java
*
* @author [e-mail] @date: 2011-5-17
*
*/
public class BinTreeTraverse2

private int[] array = 1, 2, 3, 4, 5, 6, 7, 8, 9 ;
private static List<Node> nodeList = null;

/**
* 内部类：节点
*
* @author [e-mail] @date: 2011-5-17
*
*/
private static class Node
Node leftChild;
Node rightChild;
int data;

Node(int newData)
leftChild = null;
rightChild = null;
data = newData;



public void createBinTree()
nodeList = new LinkedList<Node>();
// 将一个数组的值依次转换为Node节点
for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++)
nodeList.add(new Node(array[nodeIndex]));

// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++)
// 左孩子
nodeList.get(parentIndex).leftChild = nodeList
.get(parentIndex * 2 + 1);
// 右孩子
nodeList.get(parentIndex).rightChild = nodeList
.get(parentIndex * 2 + 2);

// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
int lastParentIndex = array.length / 2 - 1;
// 左孩子
nodeList.get(lastParentIndex).leftChild = nodeList
.get(lastParentIndex * 2 + 1);
// 右孩子,如果数组的长度为奇数才建立右孩子
if (array.length % 2 == 1)
nodeList.get(lastParentIndex).rightChild = nodeList
.get(lastParentIndex * 2 + 2);



/**
* 先序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void preOrderTraverse(Node node)
if (node == null)
return;
System.out.print(node.data + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);


/**
* 中序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void inOrderTraverse(Node node)
if (node == null)
return;
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);


/**
* 后序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void postOrderTraverse(Node node)
if (node == null)
return;
postOrderTraverse(node.leftChild);
postOrderTraverse(node.rightChild);
System.out.print(node.data + " ");


public static void main(String[] args)
BinTreeTraverse2 binTree = new BinTreeTraverse2();
binTree.createBinTree();
// nodeList中第0个索引处的值即为根节点
Node root = nodeList.get(0);

System.out.println("先序遍历：");
preOrderTraverse(root);
System.out.println();

System.out.println("中序遍历：");
inOrderTraverse(root);
System.out.println();

System.out.println("后序遍历：");
postOrderTraverse(root);


参考技术A 定义一个简单的菜单类 这里是简单的示例 你可以自行扩展package entity;import java.util.ArrayList;
import java.util.List;/**
* 菜单类
* @author Administrator
*
*/
public class Menu
/**
* 菜单标题
*/
private String title;
/**
* 子菜单的集合
*/
private List<Menu> childs;

/**
* 父菜单
*/
private Menu parent;

/**
* 构造函数 初始化标题和子菜单集合
*/
public Menu(String title)
this();
this.title=title;

/**
* 构造函数 创建一个虚拟的父菜单(零级菜单) 所有的一级菜单都归属于一个虚拟的零级菜单
*
*/
public Menu()
this.childs = new ArrayList<Menu>();

/**
* 获取子菜单
* @return
*/
public List<Menu> getChilds()
return childs;

/**
* 获取标题
* @return
*/
public String getTitle()
return title;

/**
* 获取父菜单
* @return
*/
public Menu getParent()
return parent;

/**
* 添加子菜单并返回该子菜单对象
* @param child
* @return
*/
public Menu addChild(Menu child)
this.childs.add(child);
return child;

/**
* 设置父菜单
* @param parent
*/
public void setParent(Menu parent)
this.parent = parent;

/**
* 设置标题
* @param title
*/
public void setTitle(String title)
this.title = title;

测试package entity;
/**
* 测试类
* @author Administrator
*
*/
public class Test /**
* @param args
*/
public static void main(String[] args)
/**
* 创建一个虚拟的父菜单 用于存放一级菜单 menu01 和 menu02
*/
Menu root = new Menu();
/**
* 创建两个一级菜单
*/
Menu menu01 = new Menu("一级菜单01");
Menu menu02 = new Menu("一级菜单02");
/**
* 加入虚拟菜单
*/
root.addChild(menu01);
root.addChild(menu02);
/**
* 为两个一级菜单分别添加两个子菜单 并返回该子菜单 需要进一步处理的时候 才接收返回的对象 否则只要调用方法
*/
Menu menu0101 = menu01.addChild(new Menu("二级菜单0101"));
menu01.addChild(new Menu("二级菜单0102"));
menu02.addChild(new Menu("二级菜单0201"));
Menu menu0202 = menu02.addChild(new Menu("二级菜单0202"));
/**
* 添加三级菜单
*/
menu0101.addChild(new Menu("三级菜单010101"));
menu0202.addChild(new Menu("三级菜单020201"));
/**
* 打印树形结构
*/
showMenu(root);
/**
* 递归遍历某个菜单下的菜单树
*
* @param menu
* 根菜单
*/
private static void showMenu(Menu menu)
for (Menu child : menu.getChilds())
showMenu(child, 0);

private static void showMenu(Menu menu, int tabNum)
for (int i = 0; i < tabNum; i++)
System.out.print("\t");
System.out.println(menu.getTitle());
for (Menu child : menu.getChilds())
// 递归调用
showMenu(child, tabNum + 1);

控制台输出结果 一级菜单01 二级菜单0101
三级菜单010101
二级菜单0102一级菜单02
二级菜单0201
二级菜单0202
三级菜单020201 参考技术B 楼主是不是在学Java se的，如果是的话，我记得在awt还是Swing中有一章是专门介绍树的好像Java类库中有专门的一个Tree类是完成这种功能的。
简单树
public static void main (String [] args)
Display display = new Display ();
Shell shell = new Shell (display);
shell.setLayout(new FillLayout());

final Tree tree = new Tree (shell, SWT.BORDER);

for (int i=0; i<4; i++)
TreeItem iItem = new TreeItem (tree, 0);
iItem.setText ("TreeItem (0) -" + i);
for (int j=0; j<4; j++)
TreeItem jItem = new TreeItem (iItem, 0);
jItem.setText ("TreeItem (1) -" + j);
for (int k=0; k<4; k++)
TreeItem kItem = new TreeItem (jItem, 0);
kItem.setText ("TreeItem (2) -" + k);
for (int l=0; l<4; l++)
TreeItem lItem = new TreeItem (kItem, 0);
lItem.setText ("TreeItem (3) -" + l);




shell.setSize (200, 200);
shell.open ();
while (!shell.isDisposed())
if (!display.readAndDispatch ()) display.sleep ();

display.dispose ();

楼主参考一下吧！ 参考技术C /**
* 树形结构 ext 脚本递归算法
* */
private String builderPrivileges(String index, List<PrivilegesEntity> list,
HttpServletRequest request)
StringBuffer role = new StringBuffer();
role.append("[ ");
int listSize = list.size();
boolean bs = false;
for (int i = 0; i < listSize; i++)
PrivilegesEntity xtgl_cxdy = list.get(i);
//
if (xtgl_cxdy.getPARENTID().equals(index))
role.append(" ");
bs = true;
role.append("id:\'").append(xtgl_cxdy.getCXID()).append("\',")
.append("text:\'").append(xtgl_cxdy.getNAME());
role.append("\'").append(",leaf:true,href:\'").append(
request.getContextPath());
role.append("/").append(
"menupage.action?menu.MENUID=" + xtgl_cxdy.getCXID())
.append("\',hrefTarget:\'main\'");
if (xtgl_cxdy.getISLEAF().equals("0"))
role.append(",leaf:false,children:");
role.append(builderPrivileges(xtgl_cxdy.getCXID(), list,
request));

role.append("").append(",");


if (!bs)
return "[]";

return role.substring(0, role.length() - 1) + " ] ";

参考技术D 美工做的,html就行代码