① java 如何對對象進行排序
糾正幾點錯誤：
首先TreeSet就是一個二叉樹排序容器，由用戶定義對象比較規則，然後介面回調進行排序，也就是說當對象在add到容器後實際上已經按照你定義的排序規則排序完畢了，所以你也沒有必要再單獨寫一個排序方塵亂法。
如果你想單獨寫一個排序演算法，傳送TreeSet()這樣已經排序完畢的容器當然是多此一舉的。 你可以用List保存你的對象，這樣容器保存的就是原始的對象集合(按add()的先後順序排序)，這樣才能真正發揮排序方法的功能.
其次，你的冒泡排序演算法是按照價格從小到大的，而你add對象的時候就是從小到大的，所以一直沒有滿足if(iArr[j].price > iArr[j+1].price) { 這個條件，可以把>號改成<號，或者打亂add的順粗好序，這樣就能看派凳檔出效果。
另外從容器內取元素應該用循環，而不應該寫死。你應該知道，所以程序我也沒修改~
下面的程序在原作上面稍微修改了一下，自己可以比較一下區別
package cn.com.csuinfo.Mycollec;
import java.util.ArrayList;
import java.util.List;
public class TestMySort {
public void BubbleSort(List<Car> list) {
Car c1;
Car c2;
Car c3;
Car c4;
c1 = list.get(0);// 將set中的元素一個個取出來，再存入Car數組中
c2 = list.get(1);
c3 = list.get(2);
c4 = list.get(3);
Car[] iArr = { c1, c2, c3, c4 }; // 數組中存放了Car類型的四個對象
Car tmp = null;
int len = list.size();
for (int i = 0; i < len - 1; i++) {// 對數組中的對象按屬性值price的大小進行排序
for (int j = 0; j < len - 1 - i; j++) {
if (iArr[j].price < iArr[j + 1].price) {
tmp = iArr[j];
iArr[j] = iArr[j + 1];
iArr[j + 1] = tmp;
System.out.println("change");// 測試之注意！：程序沒執行到此來？？？
}
}
}
for (Car car : iArr) {
System.out.println(car);
}
}
public static void main(String[] args) {
List<Car> list = new ArrayList<Car>();
Car car1 = new Car("Ford", 164000);
Car car2 = new Car("Honda", 286000);
Car car3 = new Car("Toyota", 410000);
Car car4 = new Car("Benz", 850000);
list.add(car1);
list.add(car2);
list.add(car3);
list.add(car4);
System.out.println("***********************「");
new TestMySort().BubbleSort(list);
}
}
② JAVA如何將英文字母進行二叉樹排序
如果僅限於java，而且是實際應用，java里有一個叫做TreeSet的東西，是個有序的樹結構。Sring類型的英文字元可在裡面自排序。
如果是考試，應該是靠你如何實現一個類似於TreeSet的東西
③ 如何用Java的方式設計一個後序線索二叉樹的方法
在Java中，你可以定義一哪激弊個類來表示後序線索二叉樹，其中包含有頭節點、尾節點和當前節點指針。你可以使用遞歸或迭代方法遍歷整棵樹，並創建線索，即存儲前驅和後繼節點的指針。當訪問到葉子節點時，需要將尾節點的指針指向它，尾節點鉛隱的指李族針則指向頭節點
// 定
④ java實現對樹形結構(文件夾式)數據數組進行排序
這個問題本質上就是個數據結構的問題，所謂排序和查找效率依賴的是演算法和數據結構的配合，你現在定下了鏈表（沒有具體說明的話，這里應該指的是單向鏈敬謹表吧）、數組和二叉樹，這幾個之中，那排序和查找的數據就看用什麼演算法和相應的數據結構配合了~~~
排序演算法中，快速排序是最快的，比較適合用鏈表來處理，但是鏈表的查找是比較慢的（雙向鏈表的話可以加快查找速度）。
數組排序會比較慢，不返稿帶是演算法的問題漏蘆，而是數組的調整因為需要位移，但是數組一旦排號順序後，查找是很快的——折半查找。
二叉數較為平局，排序可以採用堆排序，查找可以建二叉排序樹來找（用B+或B-樹的話可以更快）。
個人看法，不一定對，歡迎拍磚，具體代碼知道演算法了就自己上網找吧。
⑤ 找一個Java程序:關於二叉樹的建立和排序
從鍵盤接受輸入(先序)，以二叉鏈表作為存儲結構，建立二叉樹(以先序來建立)
結果不是唯一
⑥ 用java實現二叉樹
我有很多個(假設10萬個)數據要保存起來，以後還需要從保存的這些數據中檢索是否存在某
個數據，（我想說出二叉樹的好處，該怎麼說呢？那就是說別人的缺點），假如存在數組中，
那麼，碰巧要找的數字位於99999那個地方，那查找的速度將很慢，因為要從第1個依次往
後取，取出來後進行比較。平衡二叉樹（構建平衡二叉樹需要先排序，我們這里就不作考慮
了）可以很好地解決這個問題，但二叉樹的遍歷（前序，中序，後序）效率要比數組低很多，
public class Node {
public int value;
public Node left;
public Node right;
public void store(intvalue)
right.value=value;
}
else
{
right.store(value);
}
}
}
public boolean find(intvalue)
{
System.out.println("happen" +this.value);
if(value ==this.value)
{
return true;
}
else if(value>this.value)
{
if(right ==null)returnfalse;
return right.find(value);
}else
{
if(left ==null)returnfalse;
return left.find(value);
}
}
public void preList()
{
System.out.print(this.value+ ",");
if(left!=null)left.preList();
if(right!=null) right.preList();
}
public void middleList()
{
if(left!=null)left.preList();
System.out.print(this.value+ ",");
if(right!=null)right.preList();
}
public void afterList()
{
if(left!=null)left.preList();
if(right!=null)right.preList();
System.out.print(this.value+ ",");
}
public static voidmain(String [] args)
{
int [] data =new int[20];
for(inti=0;i<data.length;i++)
{
data[i] = (int)(Math.random()*100)+ 1;
System.out.print(data[i] +",");
}
System.out.println();
Node root = new Node();
root.value = data[0];
for(inti=1;i<data.length;i++)
{
root.store(data[i]);
}
root.find(data[19]);
root.preList();
System.out.println();
root.middleList();
System.out.println();
root.afterList();
}
}
⑦ java實現二叉樹的問題
/**
* 二叉樹測試二叉樹順序存儲在treeLine中，遞歸前序創建二叉樹。另外還有能
* 夠前序、中序、後序、按層遍歷二叉樹的方法以及一個返回遍歷結果asString的
* 方法。
*/
public class BitTree {
public static Node2 root;
public static String asString;
//事先存入的數組,符號#表示二叉樹結束。
public static final char[] treeLine = {'a','b','c','d','e','f','g',' ',' ','j',' ',' ','i','#'};
//用於標志二叉樹節點在數組中的存儲位置，以便在創建二叉樹時能夠找到節點對應的數據。
static int index;
//構造函數
public BitTree() {
System.out.print("測試二叉樹的順序表示為：");
System.out.println(treeLine);
this.index = 0;
root = this.setup(root);
}
//創建二叉樹的遞歸程序
private Node2 setup(Node2 current) {
if (index >= treeLine.length) return current;
if (treeLine[index] == '#') return current;
if (treeLine[index] == ' ') return current;
current = new Node2(treeLine[index]);
index = index * 2 + 1;
current.left = setup(current.left);
index ++;
current.right = setup(current.right);
index = index / 2 - 1;
return current;
}
//二叉樹是否為空。
public boolean isEmpty() {
if (root == null) return true;
return false;
}
//返回遍歷二叉樹所得到的字元串。
public String toString(int type) {
if (type == 0) {
asString = "前序遍歷：\t";
this.front(root);
}
if (type == 1) {
asString = "中序遍歷：\t";
this.middle(root);
}
if (type == 2) {
asString = "後序遍歷：\t";
this.rear(root);
}
if (type == 3) {
asString = "按層遍歷：\t";
this.level(root);
}
return asString;
}
//前序遍歷二叉樹的循環演算法，每到一個結點先輸出，再壓棧，然後訪問它的左子樹，
//出棧，訪問其右子樹，然後該次循環結束。
private void front(Node2 current) {
StackL stack = new StackL((Object)current);
do {
if (current == null) {
current = (Node2)stack.pop();
current = current.right;
} else {
asString += current.ch;
current = current.left;
}
if (!(current == null)) stack.push((Object)current);
} while (!(stack.isEmpty()));
}
//中序遍歷二叉樹
private void middle(Node2 current) {
if (current == null) return;
middle(current.left);
asString += current.ch;
middle(current.right);
}
//後序遍歷二叉樹的遞歸演算法
private void rear(Node2 current) {
if (current == null) return;
rear(current.left);
rear(current.right);
asString += current.ch;
}
}
/**
* 二叉樹所使用的節點類。包括一個值域兩個鏈域
*/
public class Node2 {
char ch;
Node2 left;
Node2 right;
//構造函數
public Node2(char c) {
this.ch = c;
this.left = null;
this.right = null;
}
//設置節點的值
public void setChar(char c) {
this.ch = c;
}
//返回節點的值
public char getChar() {
return ch;
}
//設置節點的左孩子
public void setLeft(Node2 left) {
this.left = left;
}
//設置節點的右孩子
public void setRight (Node2 right) {
this.right = right;
}
//如果是葉節點返回true
public boolean isLeaf() {
if ((this.left == null) && (this.right == null)) return true;
return false;
}
}
一個作業題，裡面有你要的東西。
主函數自己寫吧。當然其它地方也有要改的。