前序遍历java_如何用java实现二叉树

㈠ java如何理解preOrder()的实现

这个不是很难理解哈，就是使用递归来遍历树，LZ请看：
首先，这个preOrder这个方法是用来遍历树的，貌似说了个废话，它需要一个
BinaryNode<E> p的参数，这个参数就是树上的一个节点。
首先，假如当前p是A，那么判断p是否为null，也就是是否有这个节点，如果有，那么打印p.data，应该是p的信息。
然后再次调用这个preOrder遍历树的方法preOrder（p.left）；preOrder（p.right），但这此传入的节点已经不是A了，而是p.left和p.right，也就是B和C，然后依然跟上面一样，先判断是否有该节点，如果有就打印节点信息，然后再次调用该方法传入自己的左右孩子节点，一次递归循环，自己的左右孩子为null的时候，当然不会走if语句里面的内容，递归也就自然结束了
希望可以帮到LZ

㈡跪求详解~java中foreach方法来遍历数组的详解，主要问题是for（a:b）这里的问题不太懂！！！

增强for(part1:part2){part3};

part2中是一个数组对象,或者是带有泛性的集合.
part1定义了一个局部变量,这个局部变量的类型与part2中的对象元素的类型是一致的.
part3当然还是循环体.

foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。

foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。

foreach的语句格式：

for(元素类型t 元素变量x : 遍历对象obj){

引用了x的java语句;

}

importjava.util.Arrays;
importjava.util.List;
importjava.util.ArrayList;
/**
*webkfa技术提供
*/
publicclassTestArray{
publicstaticvoidmain(Stringargs[]){
TestArraytest=newTestArray();
test.test1();
test.listToArray();
test.testArray3();

}

/**
*foreach语句输出一维数组
*/
publicvoidtest1(){
//定义并初始化一个数组
intarr[]={2,3,1};
System.out.println("----1----排序前的一维数组");
for(intx:arr){
System.out.println(x);//逐个输出数组元素的值
}

//对数组排序
Arrays.sort(arr);

//利用java新特性foreach循环输出数组
System.out.println("----1----排序后的一维数组");
for(intx:arr){
System.out.println(x);//逐个输出数组元素的值
}
}

/**
*集合转换为一维数组
*/
publicvoidlistToArray(){
//创建List并添加元素
List<String>list=newArrayList<String>();
list.add("1");
list.add("3");
list.add("4");

//利用froeach语句输出集合元素
System.out.println("----2----froeach语句输出集合元素");
for(Stringx:list){
System.out.println(x);
}

//将ArrayList转换为数组
Objects[]=list.toArray();

//利用froeach语句输出集合元素
System.out.println("----2----froeach语句输出集合转换而来的数组元素");
for(Objectx:s){
System.out.println(x.toString());//逐个输出数组元素的值
}
}

/**
*foreach输出二维数组测试
*/
publicvoidtestArray2(){
intarr2[][]={{4,3},{1,2}};
System.out.println("----3----foreach输出二维数组测试");
for(intx[]:arr2){
for(inte:x){
System.out.println(e);//逐个输出数组元素的值
}
}
}

/**
*foreach输出三维数组
*/
publicvoidtestArray3(){
intarr[][][]={
{{1,2},{3,4}},
{{5,6},{7,8}}
};

System.out.println("----4----foreach输出三维数组测试");
for(int[][]a2:arr){
for(int[]a1:a2){
for(intx:a1){
System.out.println(x);
}
}
}
}
}

㈢在java中，遍历是干嘛用的有什么意义

你说的比较笼统，遍历的话，可以遍历数组，遍历list，遍历链表，遍历图，树等等，遍历的意义就在于检查集合中的元素并做处理。至于什么顺序，那要根据需求喽。
例子，比较简单的是，遍历一个整型数组，找出里面最大的数。

㈣ java Map 怎么遍历

关于java中遍历map具体有四种方式，请看下文详解。

1、这是最常见的并且在大多数情况下也是最可取的遍历方式，在键值都需要时使用。

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Map.Entry<Integer, Integer> entry : map.entrySet()) {

System.out.println("Key = "+ entry.getKey() + ", Value = "+ entry.getValue());

}

2、在for-each循环中遍历keys或values。

如果只需要map中的键或者值，你可以通过keySet或values来实现遍历，而不是用entrySet。

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Integer key : map.keySet()) {

System.out.println("Key = "+ key);

}

for(Integer value : map.values()) {

System.out.println("Value = "+ value);

}

该方法比entrySet遍历在性能上稍好（快了10%），而且代码更加干净。

3、使用Iterator遍历

使用泛型：

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();

while(entries.hasNext()) {

Map.Entry<Integer, Integer> entry = entries.next();

System.out.println("Key = "+ entry.getKey() + ", Value = "+ entry.getValue());

}

不使用泛型：

Map map = newHashMap();

Iterator entries = map.entrySet().iterator();

while(entries.hasNext()) {

Map.Entry entry = (Map.Entry) entries.next();

Integer key = (Integer)entry.getKey();

Integer value = (Integer)entry.getValue();

System.out.println("Key = "+ key + ", Value = "+ value);

}

4、通过键找值遍历（效率低）

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Integer key : map.keySet()) {

Integer value = map.get(key);

System.out.println("Key = "+ key + ", Value = "+ value);

}

假设Map中的键值对为1=>11,2=>22,3=>33,现用方法1来遍历Map代码和调试结果如下：

(4)前序遍历java扩展阅读：

1、HashMap的重要参数

HashMap 的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。

加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

在Java编程语言中，加载因子默认值为0.75，默认哈希表元为101。

2、HashMap的同步机制

注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

（结构上的修改是指添加或删除一个或多个映射关系的任何操作；以防止对映射进行意外的异步访问，如下：

Map m = Collections.synchronizedMap(new HashMap(...));

㈤写一个java层次遍历二叉树,简单点就可以,我要的是代码,不是纯文字说明

public class BinaryNode {
Object element;
BinaryNode left;
BinaryNode right;

}

import java.util.*;

public class Queue {

protected LinkedList list;

// Postcondition: this Queue object has been initialized.
public Queue() {

list = new LinkedList();

} // default constructor

// Postcondition: the number of elements in this Queue object has been
// returned.
public int size() {

return list.size();

} // method size

// Postcondition: true has been returned if this Queue object has no
// elements. Otherwise, false has been returned.
public boolean isEmpty() {

return list.isEmpty();

} // method isEmpty

// Postconditon: A of element has been inserted at the back of this
// Queue object. The averageTime (n) is constant and
// worstTime (n) is O (n).
public void enqueue(Object element) {

list.addLast(element);

} // method enqueue

// Precondition: this Queue object is not empty. Otherwise,
// NoSuchElementException will be thrown.
// Postcondition: The element that was at the front of this Queue object -
// just before this method was called -- has been removed
// from this Queue object and returned.
public Object dequeue() {

return list.removeFirst();

} // method dequeue

// Precondition: this Queue object is not empty. Otherwise,
// NoSuchElementException will be thrown.
// Postcondition: the element at index 0 in this Queue object has been
// returned.
public Object front() {

return list.getFirst();

} // method front

} // Queue class

import java.io.IOException;

public class BinaryTree {
BinaryNode root;

public BinaryTree() {
super();
// TODO 自动生成构造函数存根
root=this.createPre();
}

public BinaryNode createPre()
//按照先序遍历的输入方法，建立二叉树
{
BinaryNode t=null;
char ch;
try {
ch = (char)System.in.read();

if(ch==' ')
t=null;
else
{
t=new BinaryNode();
t.element=(Object)ch;
t.left=createPre();
t.right=createPre();
}
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
return t;
}

public void inOrder()
{
this.inOrder(root);
}

public void inOrder(BinaryNode t)
//中序遍历二叉树
{
if(t!=null)
{
inOrder(t.left);
System.out.print(t.element);
inOrder(t.right);
}
}

public void postOrder()
{
this.postOrder(root);
}

public void postOrder(BinaryNode t)
//后序遍历二叉树
{
if(t!=null)
{
postOrder(t.left);
System.out.print(t.element);
postOrder(t.right);
}
}

public void preOrder()
{
this.preOrder(root);
}
public void preOrder(BinaryNode t)
//前序遍历二叉树
{
if(t!=null)
{
System.out.print(t.element);
preOrder(t.left);
preOrder(t.right);
}
}

public void breadthFirst()
{
Queue treeQueue=new Queue();
BinaryNode p;
if(root!=null)
treeQueue.enqueue(root);
while(!treeQueue.isEmpty())
{
System.out.print(((BinaryNode)(treeQueue.front())).element);
p=(BinaryNode)treeQueue.dequeue();
if(p.left!=null)
treeQueue.enqueue(p.left);
if(p.right!=null)
treeQueue.enqueue(p.right);
}
}
}

public class BinaryTreeTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成方法存根
BinaryTree tree = new BinaryTree();

System.out.println("先序遍历：");
tree.preOrder();
System.out.println();

System.out.println("中序遍历：");
tree.inOrder();
System.out.println();

System.out.println("后序遍历：");
tree.postOrder();
System.out.println();

System.out.println("层次遍历：");
tree.breadthFirst();
System.out.println();
}

}

㈥ Java 循环遍历什么意思啊

比如
for (int i = 0; i < 10; i++) {System.out.println(i);}
就是循环遍历
出0-9

下面说得具体点

循环语句使语句或块的执行得以重复进行。Java 编程语言支持三种循环构造类型：for，while 和 do 循环。for 和 while 循环是在执行循环体之前测试循环条件，而 do 循环是在执行完循环体之后测试循环条件。这就意味着 for 和 while 循环可能连一次森腔循环体都未执行，而 do 循环将至少执行一次循环体。

【1】 for 循环

for 循环的句法是：

for (初值表达式; boolean 测试表达式; 改变量表达式)｛
语句或语句块
｝
注意：for 语句里面的 3 个部分都可以省略，但是我们不建议这么做。
【2】 while 循环

while 循环的句法是：

while (布尔表达式) ｛
语句或块
｝
请确认循环控制变量在循环体被开始执行之前已被正确初始化，并确认循环控制变量是真时，循环体才开始执行。控制变量必须被正确更新以防止死循环。

【3】do while循环

do while循环的句法是：

do ｛
语句或块；
｝while (布尔测试);

象 while 循环一样，请确团春贺认循环控制变量在循环体中被正确初始化和测试并被适时更新。作为一种编程惯例，for 循环一般用在那种循环次数事先可确定的情况，而 while 和 do用在那种循环次数事先不可确定的情况。

do 循环与 while 循环的不同这处在于，前者至少执行一次，而后者可能一次都不执行。

【4】特殊循环流程控制

下列语句可被用在更深层次的控制循环语句中：

break；

continue；

break 语句被用来从 switch 语句、循环语句中退出，跳出离 break 最近的循环。

continue 语句被用来略过并跳到循环体的结尾，终塌派止本次循环，继续下一次循环。

㈦ java pager 怎么遍历

首先，自然是下载组件，并将pager-taglib.jar放入/web-inf/lib目录下。游竖颤
其次，引入标签库。
[java] view plain
<%@taglib uri="http://jsptags.com/tags/navigation/pager" prefix="pg" %>
再者，书写标签体。
[html] view plain
<table cellpadding="0" cellspacing="0">
<tr>
<th>ID</th>
<th>用户名</th>
<th>角色</th>
<th>姓名</th>
<th>性别</th>纤李
<th>年龄</th>
<th>电子邮箱</th>
<th>联系电话</th>
<th>状态</th>
</tr>
<c:forEach items="${requestScope.users}" var="item">
<tr>
<td>${item.userID}</td>
<td>${item.userName }</td>
<td>${item.roleName }</td>
<td>${item.name }</td>
<td>${item.gender }</td>
<td>${item.age }</td>
<td>${item.email }</td>
<td>${item.telephone }</td>
<td>${(item.state=="0")?"不在线":"在线" }</td>
</tr>
</c:forEach>
</table>

<pg:pager url="/clinic/usermanage" items="${requestScope.total}" maxPageItems="10" maxIndexPages="10">
<pg:index>
<pg:first><a href="${pageUrl}">首页</a></pg:first>
<pg:prev><a href="${pageUrl}">上一页</a></pg:prev>
<pg:pages><a href="${pageUrl}">${pageNumber}</a></pg:pages>
<pg:next><a href="${pageUrl}">下一页</a></pg:next>
<pg:last><a href="${pageUrl}">尾页</a></pg:last>
</pg:index>
</pg:pager>

㈧利用JAVA 先序建立二叉树 #表示空树。例如输入ABC##DE#G##F### 先序遍历输出ABCDEGF 我写的程序不能输出

你的程序有诸多问题，你的程序运行时候应该也会报错的吧？
这个写法不是很通用，不过我还是按照你的源码修改成了你想要的结果。
结构上基本一致，可实现基本已经面目全非了。
我用字符串代替了手工输入，你要是喜欢手工输入，你可以把我那个注释掉，用你自己的……
以下是修改后可用的代码：

import java.util.*;

class Node {
Node left;
Node Right;
char data;// 节点数据

void print() {
System.out.println(data + "");
}

public Node() {
this.left = null;
this.Right = null;
}

public Node(char data) {
this.left = null;
this.Right = null;
this.data = data;

}

}

class BTree {
static Node root = new Node();// 为根节点分配空间
static char ch[];// 输入御毁的字符串
static int i = 0;

static Node CreateTree()// 先序建立二叉树
{
Node node = null;
if (ch[i] == '#') {
node = null;
i++;
}else {
node = new Node();
node.data = ch[i];
i++;
node.left = CreateTree();
node.Right = CreateTree();

}
return node;
}

static public void preorder(Node node)// 先序遍历二叉树
{
if (node != null) {
node.print();
preorder(node.left);
preorder(node.Right);
} else {
System.out.println("Tree node is empty");
}

}
}

public class Tree {
public static void main(String args[]) {
Scanner reader = new Scanner(System.in);
BTree.ch = new char[16];
BTree.ch[0] = 'a';
// 读取输入字符数组，以*结镇滚备尾
BTree.ch = "ABC##DE#G##F###".toCharArray();
//备歼for (int i = 0; (BTree.ch[i] = reader.next().charAt(0)) != '*'; i++){}
BTree.root = BTree.CreateTree();
BTree.preorder(BTree.root);
}
}

㈨如何用java实现二叉树

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

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

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

// 对除最后一个父节点按照父节点和孩子节点的数字关系建立二叉树
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);
}
}

// 前序遍历
public static void preOrderTraverse(Node node) {
if (node == null) {
return;
}
System.out.print(node.data + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}

// 中序遍历
public static void inOrderTraverse(Node node) {
if (node == null) {
return;
}

inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}

// 后序遍历
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) {
Bintrees binTree = new Bintrees();
binTree.createBintree();
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);
}
}

输出结果：
前序遍历：
1 2 4 8 9 5 3 6 7
中序遍历：
8 4 9 2 5 1 6 3 7
后序遍历：
8 9 4 5 2 6 7 3 1

㈩ Java List遍历方法及其效率对比

Java代码

package zbalpha test;

差州吵 import java util ArrayList;

import java util Iterator;

import java util List;

public class ListTest {

public static void main(String args[]){

迹世 List<Long> lists = new ArrayList<Long>();

for(Long i= l;i< l;i++){

lists add(i);

}

Long oneOk = oneMethod(lists);

Long oOk = oMethod(lists);

Long threeOk = threeMethod(lists);

Long fourOk = fourMethod(lists);

System out println( One: + oneOk);

System out println( Two: + oOk);

System out println( Three: + threeOk);

System out println( four: + fourOk);

}

public static Long oneMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(int i= ;i<lists size();i++) {

System out println(lists get(i));

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long oMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(Long string : lists) {

System out println(string);

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long threeMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

Iterator<Long> it = erator();

while (it hasNext())

{

虚侍 System out println(it next());

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long fourMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(Iterator<Long> i = erator(); i hasNext();) {

System out println(i next());

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

容器类可以大大提高编程效率和编程能力在Java 中所有的容器都由SUN公司的Joshua Bloch进行了重新设计丰富了容器类库的功能

Java 容器类类库的用途是保存对象它分为两类

Collection 一组独立的元素通常这些元素都服从某种规则 List必须保持元素特定的顺序而Set不能有重复元素

Map 一组成对的键值对对象即其元素是成对的对象最典型的应用就是数据字典并且还有其它广泛的应用另外 Map可以返回其所有键组成的Set和其所有值组成的Collection 或其键值对组成的Set 并且还可以像数组一样扩展多维Map 只要让Map中键值对的每个值是一个Map即可

迭代器

迭代器是一种设计模式它是一个对象它可以遍历并选择序列中的对象而开发人员不需要了解该序列的底层结构迭代器通常被称为轻量级对象因为创建它的代价小

Java中的Iterator功能比较简单并且只能单向移动

( ) 使用方法iterator()要求容器返回一个Iterator 第一次调用Iterator的next()方法时它返回序列的第一个元素

( ) 使用next()获得序列中的下一个元素

( ) 使用hasNext()检查序列中是否还有元素

( ) 使用remove()将迭代器新返回的元素删除

Iterator是Java迭代器最简单的实现为List设计的ListIterator具有更多的功能它可以从两个方向遍历List 也可以从List中插入和删除元素

List的功能方法

List(interface): 次序是List最重要的特点它确保维护元素特定的顺序 List为Collection添加了许多方法使得能够向List中间插入与移除元素(只推荐 LinkedList使用) 一个List可以生成ListIterator 使用它可以从两个方向遍历List 也可以从List中间插入和删除元素

ArrayList: 由数组实现的List 它允许对元素进行快速随机访问但是向List中间插入与移除元素的速度很慢 ListIterator只应该用来由后向前遍历ArrayList 而不是用来插入和删除元素因为这比LinkedList开销要大很多

LinkedList: 对顺序访问进行了优化向List中间插入与删除得开销不大随机访问则相对较慢(可用ArrayList代替) 它具有方法addFirst() addLast() getFirst() getLast() removeFirst() removeLast() 这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈队列和双向队列使用

Set的功能方法

Set(interface): 存入Set的每个元素必须是唯一的因为Set不保存重复元素加入Set的Object必须定义equals()方法以确保对象的唯一性 Set与Collection有完全一样的接口 Set接口不保证维护元素的次序

HashSet: 为快速查找而设计的Set 存入HashSet的对象必须定义hashCode()

TreeSet: 保持次序的Set 底层为树结构使用它可以从Set中提取有序的序列

LinkedHashSet: 具有HashSet的查询速度且内部使用链表维护元素的顺序(插入的次序) 于是在使用迭代器遍历Set时结果会按元素插入的次序显示

lishixin/Article/program/Java/hx/201311/26494

导航:首页 > 编程语言 > 前序遍历java

前序遍历java

与前序遍历java相关的资料