前序遍歷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相關的資料