❶ 用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;
HashMap<String, Integer> map = new HashMap<String, 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(HashMap<String, 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 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中queue的使用方法
java中的queue類是隊列數據結構管理類。在它里邊的元素可以按照添加它們的相慧握同順序被移除。
隊列通常（但並非一定）以 FIFO（先進先出）的方式排序各個元素。不過優先順序隊列和 LIFO 隊列（或堆棧）例外，前者根據提供的比較器或元素的自然順序對元素進行排序，後者稿歲按 LIFO（後進先出）的方式對元素進行排序。無論使用哪種排序方式，隊列的頭都是調用remove()或poll()所移除的元素。在 FIFO 隊列中，所有的新元素都插入隊列的末尾。其他種類的隊列可能使用不同的元素放置規則。每個Queue實現必須指定其順序屬性。
offer 添加一個元素並返回true 如果隊列已滿，則返回false
poll 移除並返問隊列頭部的元素 如果隊列為空，則返回null
peek 返回隊列頭部前敬慶的元素 如果隊列為空，則返回null
put 添加一個元素 如果隊列滿，則阻塞
take 移除並返回隊列頭部的元素 如果隊列為空，則阻塞
element 返回隊列頭部的元素 如果隊列為空，則拋出一個NoSuchElementException異常
add 增加一個元索 如果隊列已滿，則拋出一個IIIegaISlabEepeplian異常
remove 移除並返回隊列頭部的元素 如果隊列為空，則拋出一個
NoSuchElementException異常
注意：poll和peek方法出錯進返回null。因此，向隊列中插入null值是不合法的。
還有帶超時的offer和poll方法重載，例如，下面的調用：
boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
嘗試在100毫秒內向隊列尾部插入一個元素。如果成功，立即返回true；否則，當到達超時進，返回false。同樣地，調用：
Object head = q.poll(100, TimeUnit.MILLISECONDS);
如果在100毫秒內成功地移除了隊列頭元素，則立即返回頭元素；否則在到達超時時，返回null。
阻塞操作有put和take。put方法在隊列滿時阻塞，take方法在隊列空時阻塞。
Queue介面與List、Set同一級別，都是繼承了Collection介面。LinkedList實現了Queue接 口。Queue介面窄化了對LinkedList的方法的訪問許可權（即在方法中的參數類型如果是Queue時，就完全只能訪問Queue介面所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法才可以使用。BlockingQueue 繼承了Queue介面。
❹ 求java多線程遍歷目錄的完整代碼，能運行的那種
目錄結構為樹型結構，用多線程不大好做，線程最多在前幾層進行分割，比如每個目錄下有兩個目錄，共5層，那麼root目錄下就能啟用2個線程分別進行遍歷，所以第二層就啟動了2個線程進行遍歷，加上主線程共三個線程，雖然這樣做是可以做，但是要更具實際情況進行線程的規劃，否則容易線程過多導致cpu超負荷，或者假死，再提一點，遍歷目錄不建議用遞歸來寫，因為目錄較多容易棧溢出。
隨手寫了個，會有點bug就是關閉線程池的時候，還有就是有可能目錄太多進入拒絕策略，這個東西 可以考慮使用令牌桶演算法，或者計數器演算法來做。這里提供個簡單的例子。
public class TraverseUtil {
public static BlockingQueue blockingQueue = new LinkedBlockingQueue(100);
public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(100,100,10, TimeUnit.SECONDS,blockingQueue);
public static void traverseFolder2(String path) {
File file = new File(path);
if (file.exists()) {
File[] files = file.listFiles();
if (null == files || files.length == 0) {
System.out.println("文件夾是空的!");
return;
} else {
for (File file2 : files) {
if (file2.isDirectory()) {
System.out.println("文件夾:" + file2.getAbsolutePath());
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
traverseFolder2(file2.getAbsolutePath());
}
});
} else {
System.out.println("文件:" + file2.getAbsolutePath());
}
}
}
} else {
System.out.println("文件不存在!");
}
}
public static void main(String[] args) throws InterruptedException {
traverseFolder2("C:\\Users\\a8932\\Desktop\\md");
}
}
❺ 用java實現循環隊列
簡單寫了下，希望你能看明白
import java.util.ArrayList;
public class SeqQueue {
ArrayList<String> list;
public SeqQueue() {
list = new ArrayList<String>();
}
public String getFirst() {
if (!list.isEmpty()) {
String s = list.get(0);
list.remove(0);
return s;
}
return null;
}
public void insertLast(String s) {
list.add(s);
}
public static void main(String[] args) {
SeqQueue seq = new SeqQueue();
seq.insertLast("111");
seq.insertLast("222");
seq.insertLast("333");
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
}
}
❻ Java如何使用數組實現循環隊列的案例
class Element{
int id;
String name;
Element(int a,String n){
id=a;name=n;
}
}
class SeqQueue{
int first,last,maxsize;
Element queue[];
SeqQueue(int i){
maxsize=i;
first=last=-1;
queue=new Element[i];
}
public void clear(){//置空
first=last=-1;
}
public boolean isEmpty(){//判空
if(first==-1)return true;
else return false;
}
public Element getFirst(){//取隊列頭元素
if(first==-1)return null;
else return queue[first+1];
}
public boolean isFull(){//判滿
if((last+1)%maxsize==first)return true;
else return false;
}
public boolean enQueue(Element e){//入隊
if(this.isFull())return false;
if(this.isEmpty())
first=last=0;
else
last=(last+1)%maxsize;
queue[last]=e;
return true;
}
public Element deQueue(){//出隊
Element t=queue[first];
if(this.isEmpty())return null;
if(first==last){
queue[first]=null;
this.clear();
return t;
}
queue[first]=null;
first=(first+1)%maxsize;
return t;
}
public int getLength(){//隊列長度
if(last>=first)return last-first+1;
else return maxsize-(first-last)+1;
}
public void display(){//列印所有元素
int i,j;
for (i=first,j=0;j<this.getLength();i=(i+1)%maxsize,j++)
System.out.println(queue[i].id);
}
}