java樹的數據結構
『壹』 java數據結構有哪幾種
數組、棧 、隊列、鏈表、樹、堆 、圖、散列表 。
1：數組是計算機編程語言上，對於「Array」的中文稱呼，是用於儲存多個相同類型數據的集合。
2：棧是限定僅在表尾進行插入和刪除操作的線性表，棧者，存儲貨物或供旅客住宿的地方，可引申為倉庫、中轉站，引入到計算機領域里，就是指數據暫時存儲的地方，所以才有進棧、出棧的說法。
3：一種特殊的線性表，它只允許在表的前端進行刪除操作，而在表的後端進行插入操作。
4：鏈表，一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。
5：哈希表，是根據關鍵碼值而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。
『貳』 java（演算法與數據結構）tree
代碼實現[一]部分
package ChapterEight;
class Tree {
class Node {
public long value;
public Node leftChild;
public Node rightChild;
public Node(long value) {
this.value = value;
leftChild = null;
rightChild = null;
}
}
public Node root;
public Tree() {
root = null;
}
// 向樹中插入一個節點
public void insert(long value) {
Node newNode = new Node(value);
// 樹是空的
if (root == null)
root = newNode;
else {
Node current = root;
Node parentNode;
while (true) {
parentNode = current;
if (value < current.value) {
current = current.leftChild;
// 要插入的節點為左孩子節點
if (current == null) {
parentNode.leftChild = newNode;
return;
}
} else {
// 要插入的節點為右孩子節點
current = current.rightChild;
if (current == null) {
parentNode.rightChild = newNode;
return;
}
}
}
}
}
// 先續遍歷樹中的所有節點
public void preOrder(Node currentRoot) {
if (currentRoot != null) {
System.out.print(currentRoot.value + " ");
preOrder(currentRoot.leftChild);
preOrder(currentRoot.rightChild);
}
}
// 中續遍歷樹中的所有節點
public void inOrder(Node currentNode) {
if (currentNode != null) {
inOrder(currentNode.leftChild);
System.out.print(currentNode.value + " ");
inOrder(currentNode.rightChild);
}
}
// 後續遍歷樹中的所有節點
public void postOrder(Node currentNode) {
if (currentNode != null) {
postOrder(currentNode.leftChild);
postOrder(currentNode.rightChild);
System.out.print(currentNode.value + " ");
}
}
public void traverse(int traverseType) {
switch (traverseType) {
case 1:
preOrder(root);
break;
case 2:
inOrder(root);
break;
case 3:
postOrder(root);
break;
default:
break;
}
// 依據樹節點的值刪除樹中的一個節點
public boolean delete(int value) {
// 遍歷樹過程中的當前節點
Node current = root;
// 要刪除節點的父節點
Node parent = root;
// 記錄樹的節點為左孩子節點或右孩子節點
boolean isLeftChild = true;
while (current.value != value) {
parent = current;
// 要刪除的節點在當前節點的左子樹里
if (value < current.value) {
isLeftChild = true;
current = current.leftChild;
}
// 要刪除的節點在當前節點的右子樹里
else {
isLeftChild = false;
current = current.rightChild;
}
// 在樹中沒有找到要刪除的節點
if (current == null)
return false;
}
// 要刪除的節點為葉子節點
if (current.leftChild == null && current.rightChild == null) {
// 要刪除的節點為根節點
if (current == root)
root = null;
// 要刪除的節點為左孩子節點
else if (isLeftChild)
parent.leftChild = null;
// 要刪除的節點為右孩子節點
else
parent.rightChild = null;
}
// 要刪除的節點有左孩子節點，沒有右孩子節點
else if (current.rightChild == null) {
// 要刪除的節點為根節點
if (current == null)
root = current.leftChild;
// 要刪除的節點為左孩子節點
else if (isLeftChild)
parent.leftChild = current.leftChild;
// 要刪除的節點為右孩子節點
else
parent.rightChild = current.leftChild;
}
// 要刪除的節點沒有左孩子節點，有右孩子節點
else if (current.leftChild == null) {
// 要刪除的節點為根節點
if (current == root)
root = root.rightChild;
// 要刪除的節點為左孩子節點
else if (isLeftChild)
parent.leftChild = current.rightChild;
// 要刪除的節點為右孩子節點
else
parent.rightChild = current.rightChild;
}
// 要刪除的接節點既有左孩子節點又有右孩子節點
else {
Node successor = getSuccessor(current);
// 要刪除的節點為根節點
if (current == root)
root = successor;
// 要刪除的節點為左孩子節點
else if (isLeftChild)
parent.leftChild = successor;
// 要刪除的節點為右孩子節點
else
parent.rightChild = successor;
}
return true;
}
// 找到要刪除節點的替補節點
private Node getSuccessor(Node delNode) {
// 替補節點的父節點
Node successorParent = delNode;
// 刪除節點的替補節點
Node successor = delNode;
Node current = delNode.rightChild;
while (current != null) {
// successorParent指向當前節點的上一個節點
successorParent = successor;
// successor變為當前節點
successor = current;
current = current.leftChild;
}
// 替補節點的右孩子節點不為空
if (successor != delNode.rightChild) {
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
}
public class TreeApp {
public static void main(String[] args) {
Tree tree = new Tree();
tree.insert(8);
tree.insert(50);
tree.insert(45);
tree.insert(21);
tree.insert(32);
tree.insert(18);
tree.insert(37);
tree.insert(64);
tree.insert(88);
tree.insert(5);
tree.insert(4);
tree.insert(7);
System.out.print("PreOrder : ");
tree.traverse(1);
System.out.println();
System.out.print("InOrder : ");
tree.traverse(2);
System.out.println();
System.out.print("PostOrder : ");
tree.traverse(3);
System.out.println();
System.out.println(tree.delete(7));
System.out.print("PreOrder : ");
tree.traverse(1);
System.out.println();
System.out.print("InOrder : ");
tree.traverse(2);
System.out.println();
System.out.print("PostOrder : ");
tree.traverse(3);
System.out.println();
}
}
『叄』 怎樣用Java實現一個多叉樹數據結構
這是一個典型的多叉樹問題！ 最早的祖先用根節點表示，以下依次是他的/她的子女。這個就組成一棵樹。 每一棵樹的數據包括了： 名稱、父節點指針、第一個孩子的指針、配偶指針、下一個兄弟姐妹的指針
『肆』 如何用Java實現樹形結構啊
定義一個簡單的菜單類 這里是簡單的示例 你可以自行擴展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
『伍』 請問java中哪一個類可以很方便的處理「樹」這個數據結構
可以參考jdk中的TreeModel介面，可以單獨拿出來對樹結構進行操作。
實例可以在網上搜索一下JTree的用法。
『陸』 java 如何實現樹、圖結構
他們的實現是底層程序員早都寫好了的，他們的原理確實是樹、圖結構。
『柒』 java（樹的內容）演算法與數據結構
其實有兩種方式：
第一種就是遞歸 就像現在比較老的樹形菜單。這種方式應該string類型應該是存不了的。就是自定義一個類型A 裡面有一個成員變數 list<A>。 這種結構就是list裡面嵌套list，你有多少級就有多少層。
第二種其實要做處理，就是把原數據按一定規則排序放到一個list裡面，這裡面不會再嵌套list。list排完序就如你的效果圖一樣。第一個 一級節點 》》其子節點；然後第二個一級節點》》其子節點，etc。 但是這種結構要有存的時候要循環一遍排成上述的順序，取的時候還需要判斷哪個是下一個不同級節點的開始。
js前台展示比較簡單，根據父id直接添加就行了，原數據什麼都不用做。但是java里這種方式不行。
『捌』 Java數據結構二叉樹深度遞歸調用演算法求內部演算法過程詳解
二叉樹
1
2
3
4
5
6
7
這個二叉樹的深度是3，樹的深度是最大結點所在的層，這里是3.
應該計算所有結點層數，選擇最大的那個。
根據上面的二叉樹代碼，遞歸過程是：
f
(1)=f
(2)+1
>
f
(3)
+1
?
f(2)
+
1
:
f(3)
+1
f(2)
跟f(3)計算類似上面，要計算左右結點，然後取大者
所以計算順序是f(4.left)
=
0,
f(4.right)
=
0
f
(4)
=
f(4.right)
+
1
=
1
然後計算f(5.left)
=
0,f(5.right)
=
0
f
(5)
=
f(5.right)
+
1
=1
f(2)
=
f(5)
+
1
=2
f(1.left)
計算完畢，計算f(1.right)
f(3)
跟計算f(2)的過程一樣。
得到f(3)
=
f(7)
+1
=
2
f(1)
=
f(3)
+
1
=3
12345if(depleft>depright){ return depleft+1;}else{ return depright+1;}
只有left大於right的時候採取left
+1，相等是取right
『玖』 JAVA數據結構有哪幾種
JAVA數據結構有以下幾種：
1、List：
List是有序的Collection，使用此介面能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似於數組下 >標）來訪問List中的元素，這類似於Java的數組。
2、Vector：
基於數組（Array）的List，其實就是封裝了數組所不具備的一些功能方便我們使用，所以它難易避免數組的限制，同時性能也不可能超越數組。
另外很重要的一點就是Vector是線程同步的(sychronized)的，這也是Vector和ArrayList 的一個的重要區別。
3、ArrayList：
同Vector一樣是一個基於數組上的鏈表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector好一些，但是當運行到多線程環境中時，可需要自己在管理線程的同步問題。
4、LinkedList：
LinkedList不同於前面兩種List，它不是基於數組的，所以不受數組性能的限制。 它每一個節點（Node）都包含兩方面的內容：節點本身的數據（data），下一個節點的信息（nextNode）。
所以當對LinkedList做添加，刪除動作的時候就不用像基於數組的ArrayList一樣，必須進行大量的數據移動。只要更改nextNode的相關信息就可以實現了，這是LinkedList的優勢。
5、HashSet：
雖然Set同List都實現了Collection介面，但是他們的實現方式卻大不一樣。List基本上都是以Array為基礎。
但是Set則是在 HashMap的基礎上來實現的，這就是Set和List的根本區別。HashSet的存儲方式是把HashMap中的Key作為Set的對應存儲項。
6、HashMap：
基於哈希表的 Map 介面的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。(除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。)此類不保證映射的順序，特別是它不保證該順序恆久不變。
7、HashTable：
Hashtable 是一個散列表，它存儲的內容是鍵值對(key-value)映射。Hashtable 繼承於Dictionary，實現了Map、Cloneable、java.io.Serializable介面。
Hashtable 的函數都是同步的，這意味著它是線程安全的。它的key、value都不可以為nul
『拾』 java中有哪些數據結構
數據結構：
①數組 (Array)
在程序設計中，為了處理方便， 把具有相同類型的若干變數按有序的形式組織起來。這些按序排列的同類數
據元素的集合稱為數組。在C語言中， 數組屬於構造數據類型。一個數組可以分解為多個數組元素，這些數組
元素可以是基本數據類型或是構造類型。因此按數組元素的類型不同，數組又可分為數值數組、字元數組、指
針數組、結構數組等各種類別。
②棧 (Stack)
棧是只能在某一端插入和刪除的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底，最後
的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。
③隊列 (Queue)
一種特殊的線性表，它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作。進行
插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。
④鏈表 (Linked List)
一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。
鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態生成。每個結點包括兩個部分：
一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。
⑤樹 (Tree)
樹是包含n（n>0）個結點的有窮集合K，且在K中定義了一個關系N，N滿足 以下條件：
（1）有且僅有一個結點 k0，他對於關系N來說沒有前驅，稱K0為樹的根結點。簡稱為根（root）
（2）除K0外，k中的每個結點，對於關系N來說有且僅有一個前驅。
（3）K中各結點，對關系N來說可以有m個後繼（m>=0）。
⑥堆 (Heap)
在計算機科學中，堆是一種特殊的樹形數據結構，每個結點都有一個值。通常我們所說的堆的數據結構，是指
二叉堆。堆的特點是根結點的值最小（或最大），且根結點的兩個子樹也是一個堆。
⑦圖 (Graph)
圖是由結點的有窮集合V和邊的集合E組成。其中，為了與樹形結構加以區別，在圖結構中常常將結點稱為頂點，
邊是頂點的有序偶對，若兩個頂點之間存在一條邊，就表示這兩個頂點具有相鄰關系。
⑧散列表 (Hash)
若結構中存在關鍵字和K相等的記錄，則必定在f(K)的存儲位置上。由此，不需比較便可直接取得所查記錄。稱
這個對應關系f為散列函數(Hash function)，按這個思想建立的表為散列表。
差不多我就知道這些了~