java遍歷二叉樹,java遍歷二叉樹代碼

本文目錄一覽：

• 1、JAVA：在一棵二叉鏈表表示的二叉樹中，採用哪種遍歷算法操作： 1.輸出葉子結點 2求葉子結點個數 我要編碼
• 2、java一個關於二叉樹的簡單編程題
• 3、寫一個java層次遍歷二叉樹,簡單點就可以,我要的是代碼,不是純文字說明
• 4、java實現二叉樹層次遍歷
• 5、java構建二叉樹算法
• 6、java Map 怎麼遍歷

JAVA：在一棵二叉鏈表表示的二叉樹中，採用哪種遍歷算法操作： 1.輸出葉子結點 2求葉子結點個數 我要編碼

暈死了，人家說用java實現

int i = 0;

void getChildren(int parentId) {

List list = “select * from table where parentId = “+parendId; //從數據庫獲取子節點

if(list.size() 0){

for(list) { //遍歷list，遞歸取子節點

getChildren(“aaa”); //遞歸取子節點

}

}else { //如果list為空，說明為子節點

System.out.println(parentId); //打印子節點

i++；

}

}

java一個關於二叉樹的簡單編程題

定義一個結點類：

public class Node {

private int value;

private Node leftNode;

private Node rightNode;

public Node getRightNode() {

return rightNode;

}

public void setRightNode(Node rightNode) {

this.rightNode = rightNode;

}

public int getValue() {

return value;

}

public void setValue(int value) {

this.value = value;

}

public Node getLeftNode() {

return leftNode;

}

public void setLeftNode(Node leftNode) {

this.leftNode = leftNode;

}

}

初始化結點樹：

public void initNodeTree()

{

int nodeNumber;

HashMapString, Integer map = new HashMapString, Integer();

Node nodeTree = new Node();

Scanner reader = new Scanner(System.in);

nodeNumber = reader.nextInt();

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

int value = reader.nextInt();

String str = reader.next();

map.put(str, value);

}

if (map.containsKey(“#”)) {

int value = map.get(“#”);

nodeTree.setValue(value);

setChildNode(map, value, nodeTree);

}

preTraversal(nodeTree);

}

private void setChildNode(HashMapString, Integer map, int nodeValue, Node parentNode) {

int value = 0;

if (map.containsKey(“L” + nodeValue)) {

value = map.get(“L” + nodeValue);

Node leftNode = new Node();

leftNode.setValue(value);

parentNode.setLeftNode(leftNode);

setChildNode(map, value, leftNode);

}

if (map.containsKey(“R” + nodeValue)) {

value = map.get(“R” + nodeValue);

Node rightNode = new Node();

rightNode.setValue(value);

parentNode.setRightNode(rightNode);

setChildNode(map, value, rightNode);

}

}

前序遍歷該結點樹：

public void preTraversal(Node nodeTree) {

if (nodeTree != null) {

System.out.print(nodeTree.getValue() + “\t”);

preTraversal(nodeTree.getLeftNode());

preTraversal(nodeTree.getRightNode());

}

}

寫一個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 copy 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實現二叉樹層次遍歷

import java.util.ArrayList;

public class TreeNode {

private TreeNode leftNode;

private TreeNode rightNode;

private String nodeName;

public TreeNode getLeftNode() {

return leftNode;

}

public void setLeftNode(TreeNode leftNode) {

this.leftNode = leftNode;

}

public TreeNode getRightNode() {

return rightNode;

}

public void setRightNode(TreeNode rightNode) {

this.rightNode = rightNode;

}

public String getNodeName() {

return nodeName;

}

public void setNodeName(String nodeName) {

this.nodeName = nodeName;

}

public static int level=0;

public static void findNodeByLevel(ArrayListTreeNode nodes){

if(nodes==null||nodes.size()==0){

return ;

}

level++;

ArrayListTreeNode temp = new ArrayList();

for(TreeNode node:nodes){

System.out.println(“第”+level+”層:”+node.getNodeName());

if(node.getLeftNode()!=null){

temp.add(node.getLeftNode());

}

if(node.getRightNode()!=null){

temp.add(node.getRightNode());

}

}

nodes.removeAll(nodes);

findNodeByLevel(temp);

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

TreeNode root = new TreeNode();

root.setNodeName(“root”);

TreeNode node1 = new TreeNode();

node1.setNodeName(“node1”);

TreeNode node3 = new TreeNode();

node3.setNodeName(“node3”);

TreeNode node7 = new TreeNode();

node7.setNodeName(“node7”);

TreeNode node8 = new TreeNode();

node8.setNodeName(“node8”);

TreeNode node4 = new TreeNode();

node4.setNodeName(“node4”);

TreeNode node2 = new TreeNode();

node2.setNodeName(“node2”);

TreeNode node5 = new TreeNode();

node5.setNodeName(“node5”);

TreeNode node6 = new TreeNode();

node6.setNodeName(“node6”);

root.setLeftNode(node1);

node1.setLeftNode(node3);

node3.setLeftNode(node7);

node3.setRightNode(node8);

node1.setRightNode(node4);

root.setRightNode(node2);

node2.setLeftNode(node5);

node2.setRightNode(node6);

ArrayListTreeNode nodes = new ArrayListTreeNode();

nodes.add(root);

findNodeByLevel(nodes);

}

}

java構建二叉樹算法

//******************************************************************************************************//

//*****本程序包括簡單的二叉樹類的實現和前序,中序,後序,層次遍歷二叉樹算法,*******//

//******以及確定二叉樹的高度,制定對象在樹中的所處層次以及將樹中的左右***********//

//******孩子節點對換位置,返回葉子節點個數刪除葉子節點,並輸出所刪除的葉子節點**//

//*******************************CopyRight By phoenix*******************************************//

//************************************Jan 12,2008*************************************************//

//****************************************************************************************************//

public class BinTree {

public final static int MAX=40;

private Object data; //數據元數

private BinTree left,right; //指向左,右孩子結點的鏈

BinTree []elements = new BinTree[MAX];//層次遍歷時保存各個節點

int front;//層次遍歷時隊首

int rear;//層次遍歷時隊尾

public BinTree()

{

}

public BinTree(Object data)

{ //構造有值結點

this.data = data;

left = right = null;

}

public BinTree(Object data,BinTree left,BinTree right)

{ //構造有值結點

this.data = data;

this.left = left;

this.right = right;

}

public String toString()

{

return data.toString();

}//前序遍歷二叉樹

public static void preOrder(BinTree parent){

if(parent == null)

return;

System.out.print(parent.data+” “);

preOrder(parent.left);

preOrder(parent.right);

}//中序遍歷二叉樹

public void inOrder(BinTree parent){

if(parent == null)

return;

inOrder(parent.left);

System.out.print(parent.data+” “);

inOrder(parent.right);

}//後序遍歷二叉樹

public void postOrder(BinTree parent){

if(parent == null)

return;

postOrder(parent.left);

postOrder(parent.right);

System.out.print(parent.data+” “);

}// 層次遍歷二叉樹

public void LayerOrder(BinTree parent)

{

elements[0]=parent;

front=0;rear=1;

while(frontrear)

{

try

{

if(elements[front].data!=null)

{

System.out.print(elements[front].data + ” “);

if(elements[front].left!=null)

elements[rear++]=elements[front].left;

if(elements[front].right!=null)

elements[rear++]=elements[front].right;

front++;

}

}catch(Exception e){break;}

}

}//返回樹的葉節點個數

public int leaves()

{

if(this == null)

return 0;

if(left == nullright == null)

return 1;

return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());

}//結果返回樹的高度

public int height()

{

int heightOfTree;

if(this == null)

return -1;

int leftHeight = (left == null ? 0 : left.height());

int rightHeight = (right == null ? 0 : right.height());

heightOfTree = leftHeightrightHeight?rightHeight:leftHeight;

return 1 + heightOfTree;

}

//如果對象不在樹中,結果返回-1;否則結果返回該對象在樹中所處的層次,規定根節點為第一層

public int level(Object object)

{

int levelInTree;

if(this == null)

return -1;

if(object == data)

return 1;//規定根節點為第一層

int leftLevel = (left == null?-1:left.level(object));

int rightLevel = (right == null?-1:right.level(object));

if(leftLevel0rightLevel0)

return -1;

levelInTree = leftLevelrightLevel?rightLevel:leftLevel;

return 1+levelInTree;

}

//將樹中的每個節點的孩子對換位置

public void reflect()

{

if(this == null)

return;

if(left != null)

left.reflect();

if(right != null)

right.reflect();

BinTree temp = left;

left = right;

right = temp;

}// 將樹中的所有節點移走,並輸出移走的節點

public void defoliate()

{

String innerNode = “”;

if(this == null)

return;

//若本節點是葉節點，則將其移走

if(left==nullright == null)

{

System.out.print(this + ” “);

data = null;

return;

}

//移走左子樹若其存在

if(left!=null){

left.defoliate();

left = null;

}

//移走本節點，放在中間表示中跟移走…

innerNode += this + ” “;

data = null;

//移走右子樹若其存在

if(right!=null){

right.defoliate();

right = null;

}

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

BinTree e = new BinTree(“E”);

BinTree g = new BinTree(“G”);

BinTree h = new BinTree(“H”);

BinTree i = new BinTree(“I”);

BinTree d = new BinTree(“D”,null,g);

BinTree f = new BinTree(“F”,h,i);

BinTree b = new BinTree(“B”,d,e);

BinTree c = new BinTree(“C”,f,null);

BinTree tree = new BinTree(“A”,b,c);

System.out.println(“前序遍歷二叉樹結果: “);

tree.preOrder(tree);

System.out.println();

System.out.println(“中序遍歷二叉樹結果: “);

tree.inOrder(tree);

System.out.println();

System.out.println(“後序遍歷二叉樹結果: “);

tree.postOrder(tree);

System.out.println();

System.out.println(“層次遍歷二叉樹結果: “);

tree.LayerOrder(tree);

System.out.println();

System.out.println(“F所在的層次: “+tree.level(“F”));

System.out.println(“這棵二叉樹的高度: “+tree.height());

System.out.println(“————————————–“);

tree.reflect();

System.out.println(“交換每個節點的孩子節點後……”);

System.out.println(“前序遍歷二叉樹結果: “);

tree.preOrder(tree);

System.out.println();

System.out.println(“中序遍歷二叉樹結果: “);

tree.inOrder(tree);

System.out.println();

System.out.println(“後序遍歷二叉樹結果: “);

tree.postOrder(tree);

System.out.println();

System.out.println(“層次遍歷二叉樹結果: “);

tree.LayerOrder(tree);

System.out.println();

System.out.println(“F所在的層次: “+tree.level(“F”));

System.out.println(“這棵二叉樹的高度: “+tree.height());

}

java Map 怎麼遍歷

java Map 遍歷一般有四種方式

方式一: 這是最常見的並且在大多數情況下也是最可取的遍歷方式。在鍵值都需要時使用。

方式二： 在for-each循環中遍歷keys或values。

如果只需要map中的鍵或者值，你可以通過keySet或values來實現遍歷，而不是用entrySet。

該方法比entrySet遍歷在性能上稍好（快了10%），而且代碼更加乾淨。

方式三：使用Iterator遍歷

使用泛型：

不使用泛型：

你也可以在keySet和values上應用同樣的方法。

方法四:  通過鍵找值遍歷（效率低）

作為方法一的替代，這個代碼看上去更加乾淨；但實際上它相當慢且無效率。

因為從鍵取值是耗時的操作（與方法一相比，在不同的Map實現中該方法慢了20%~200%）。如果安裝了FindBugs，它會做出檢查並警告你關於哪些是低效率的遍歷。所以盡量避免使用。

總結:

如果僅需要鍵(keys)或值(values)使用方法二。

如果所使用的語言版本低於java 5，或是打算在遍歷時刪除entries，必須使用方法三。

否則使用方法一(鍵值都要)。

擴展資料：

類似的遍歷算法：

二叉樹的遍歷算法

1、先（根）序遍歷的遞歸算法定義：

若二叉樹非空，則依次執行如下操作：

⑴ 訪問根結點；

⑵ 遍歷左子樹；

⑶ 遍歷右子樹。

2、中（根）序遍歷的遞歸算法定義：

若二叉樹非空，則依次執行如下操作：

⑴遍歷左子樹；

⑵訪問根結點；

⑶遍歷右子樹。

3、後（根）序遍歷得遞歸算法定義：

若二叉樹非空，則依次執行如下操作：

⑴遍歷左子樹；

⑵遍歷右子樹；

⑶訪問根結點。

參考資料：百度百科——Java