1. 将一组无序的整型数据排序生成一颗排序二叉树，使得对这颗二叉树进行中序遍历可以得到递增有序序列。
#include <stdio.h>
#include <stdlib.h>
typedef struct BT{
int data;
BT *L_child;
BT *R_child;
}BT;
int add_sort(BT *fa,int num)//插入排山没缺序
{
if(fa->data>=num)//输入小于等于根结点，排在左子树
{
if(fa->L_child==NULL)//左子树为逗辩空，新建左察猜子树
{
fa->L_child=new BT;
fa->L_child->data=num;
fa->L_child->L_child=NULL;
fa->L_child->R_child=NULL;
}
else add_sort(fa->L_child,num);//遍历左子树 ，搜寻空位
}
else if(fa->R_child==NULL)//输入大于根结点，右子树为空，新建
{
fa->R_child=new BT;
fa->R_child->data=num;
fa->R_child->L_child=NULL;
fa->R_child->R_child=NULL;
}
else add_sort(fa->R_child,num);//遍历右子树，搜寻空位
}
void BT_printf(BT *fa)//中序遍历
{
if(fa->L_child)BT_printf(fa->L_child);
printf("%d ",fa->data);
if(fa->R_child)BT_printf(fa->R_child);
}
int main()
{
BT fa;//新建根结点
int i,j;
scanf("%d",&fa.data);
fa.L_child=NULL;
fa.R_child=NULL;
for(i=1;i<10;i++)
{
scanf("%d",&j);
add_sort(&fa,j);//插入新结点
}
BT_printf(&fa);
system("pause");
return 0;
}
这个问题本质上就是个数据结构的问题，所谓排序和查找效率依赖的是算法和数据结构的配合，你现在定下了链表（没有具体说明的话，这里应该指的是单向链敬谨表吧）、数组和二叉树，这几个之中，那排序和查找的数据就看用什么算法和相应的数据结构配合了~~~
排序算法中，快速排序是最快的，比较适合用链表来处理，但是链表的查找是比较慢的（双向链表的话可以加快查找速度）。
数组排序会比较慢，不返稿带是算法的问题漏芦，而是数组的调整因为需要位移，但是数组一旦排号顺序后，查找是很快的——折半查找。
二叉数较为平局，排序可以采用堆排序，查找可以建二叉排序树来找（用B+或B-树的话可以更快）。
个人看法，不一定对，欢迎拍砖，具体代码知道算法了就自己上网找吧。
3. 二叉树排序算法实现 急！急！急！
//二叉排序树（升序），桥陪辩平均性能O(nlogn)
//从根节点开始，小于节点的数放在左子树，大于等于节点的数放在右子树
#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;
int a[100],b[100];//定义两个数字，a是乱序的，b是排序的结果
int bshu=0;
struct Node
{
Node *father,*left,*right; //三个指针，父亲，左儿子，右儿子
int value; //每个节点都有一个值
};
Node *root; //定义二叉排序树的根结点，通常是第一个数字
void add(int value,Node *p) //通过递归对树进行深度优先搜索，确认指定的数字的位置
{
if(p->left==NULL && value<p->value) //如果值比p节点小且p节点没有左儿子
{
Node *x=new Node; //定义一个新节点
x->father=p;x->left=NULL;x->right=NULL; //这个新节点的父亲是p节点
x->value=value;
p->left=x; //p节点的左儿子为这个新节点
return; //递归上升，该数字的位置已确认乱带
}
if(p->right==NULL && value>=p->value) //如果数字大于等于p节点且p节点没有右儿子
{
Node *x=new Node; //定义一个新节点
x->father=p;x->left=NULL;x->right=NULL; //这个新节点的父亲是p节点
x->value=value;
p->right=x; //p节点的右儿子为这个新节点
return; //递归上升，该数字的位置已确认
}
//如果p节点不能最终确定该数字的位置
if(value<p->value) //如果该数字小于p节点
{
add(value,p->left); //在p节点的左子树中寻找位置，查询p节点的左儿子（递归）
return; //最终总会确定该数字的位置，该数字不可能出现在p节点的右子树，直接递归上升
}
if(value>=p->value) //如果该数字大于等于p节点
{
add(value,p->right); //在p节点的右子树中寻找位置，查询p节点的右儿子（递归）
return; //和上一个retrun相同的作用，此处也可省略return
}
}
void print(Node *p) //通过递归对树进行中序遍历，左、根、右的顺序
{
if(p->left!=NULL) //如果p的左子树不为空
print(p->敏缺left); //访问左儿子（递归）
b[bshu]=p->value; //访问完毕后把p节点加入结果数组
bshu++; //数组的元素个数加1
if(p->right!=NULL) //如果p的右子树不为空
print(p->right); //访问右儿子（递归）
//对该节点所引出的树的遍历结束，递归上升至p的父节点。
}
int main()
{
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
bshu=0; //初始化
for(int i=0;i<20;i++)
{
a[i]=rand()%100;
cout<<a[i]<<" "; //生成随机数并打印原始无序序列
}
cout<<endl;
system("pause");
root=new Node; //为根节点分配内存
root->father=NULL;root->left=NULL;root->right=NULL; //根节点没有父亲，左儿子和右儿子暂
//时为空
root->value=a[0]; //根节点的值是第一个数
for(int i=1;i<20;i++) //把数字一个个加入二叉排序树
add(a[i],root);
print(root); //在对二叉排序树中的数字进行中序遍历，完成排序
for(int i=0;i<bshu;i++)
cout<<b[i]<<" "; //打印排序后的升序数列
cout<<endl;
system("pause");
return 0; //main函数结束
}
//与快速排序一样，二叉排序树对有序序列的排序性能较差，为O(n2)，因为有序的数列无法构
//成理想平衡树，导致一边走到底的现象
4. java如何创建一颗二叉树
计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。
树是由一个或多个结点组成的有限集合，其中：
⒈必有一个特定的称为根(ROOT)的结点；
二叉树
⒉剩下的结点被分成n>=0个互不相交的集合T1、T2、......Tn，而且， 这些集合的每一个又都是树。树T1、T2、......Tn被称作根的子树(Subtree)。
树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树
1.树的度——也即是宽度，简单地说，就是结点的分支数。以组成该树各结点中最大的度作为该树的度，如上图的树，其度为2;树中度为零的结点称为叶结点或终端结点。树中度不为零的结点称为分枝结点或非终端结点。除根结点外的分枝结点统称为内部结点。
2.树的深度——组成该树各结点的最大层次。
3.森林——指若干棵互不相交的树的集合，如上图，去掉根结点A，其原来的二棵子树T1、T2、T3的集合{T1,T2,T3}就为森林；
4.有序树——指树中同层结点从左到右有次序排列，它们之间的次序不能互换，这样的树称为有序树，否则称为无序树。
树的表示
树的表示方法有许多，常用的方法是用括号：先将根结点放入一对圆括号中，然后把它的子树由左至右的顺序放入括号中，而对子树也采用同样的方法处理；同层子树与它的根结点用圆括号括起来，同层子树之间用逗号隔开，最后用闭括号括起来。如右图可写成如下形式：
二叉树
(a( b(d,e), c( f( ,g(h,i) ), )))
5. 结合二叉树的快速排序算法分析
对 3，9，1，6，5，4，8，2，10，7 进行从小到和悄迟大的快速排序
对于第一次遍历，如下图所示：
对应的二叉树结果是：
那么经过后几次遍历比较可以得到如下二叉树：
这运灶时我们可以计算一下我们的快速排序算法进行了多少次比较:
，即每个节点到根结点的距离之和。
由上例可知，快排可视为一个二叉树构建的过程，那么这个二叉树构建的速度就决定了我们快排的效率。可以确定的是，对于同样的数据元素在不同的原始排列条件下，构建的二叉树越矮，则排序效率越高。
通过这一理论，我们可以更具体的分析其不同情况下的时间复杂度：
完全二叉树满足如下公式：
对于深度为h的完全二叉树，若为满二叉树，比较次数为：
这里的叶子数量m与深度h的关系：
那么叶子到根的距离d为：
即， ，
由于 为整数，即可认为 ，
而对于完全二叉树来说，叶子数 ，与内点（带有叶子节点的顶点）数 的关系为 ，则顶点数
那么由上述公式可得：
即， ，时间复杂度为： 。
那么若节点数为n，则：
，即时间复杂度为： 。
由于分割标准的选取概率完全相同，那么可以得到平均比较次数为：
由于这里的 ，以及
由 ，以及 ，得：
令 ，得：
令 ，得：
令 ，得：
整理得：
由 ，故
则：唤李
即，
综合来看，快排的时间复杂度最理想状态与最糟糕状态分别为 、 ，但是对于一般随机情况而言时间复杂度仍为 。
6. java构建二叉树算法
下面是你第一个问题的解法，是构建了树以后又把后序输出的程序。以前写的，可以把输出后序的部分删除，还有检验先序中序的输入是否合法的代码也可以不要。/*****TreeNode.java*********/public class TreeNode {
char elem;
TreeNode left;
TreeNode right;
}/*******PlantTree.java*********/import java.io.*;
public class PlantTree {
TreeNode root;
public static void main(String[] args) {
PlantTree seed=new PlantTree();
String preorder=null;
String inorder=null;
try {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Please input the preorder");
preorder=br.readLine();
System.out.println("Please input the inorder");
inorder=br.readLine();
} catch (Exception e) {
// TODO: handle exception
}
if(preorder!=null&&seed.checkTree(preorder,inorder)) {
seed.root=new TreeNode();
seed.root.elem=preorder.charAt(0);
seed.makeTree(preorder,inorder,seed.root);
System.out.println("The tree has been planted,the postorder is:");
seed.printPostorder(seed.root);
}
}
void makeTree(String preorder,String inorder,TreeNode root) {
int i=inorder.lastIndexOf(root.elem);
if(i!=0) {//有左子树
String leftPre=preorder.substring(1, i+1);
String leftIn=inorder.substring(0,i);
TreeNode leftNode=new TreeNode();
leftNode.elem=leftPre.charAt(0);
root.left=leftNode;
makeTree(leftPre,leftIn,leftNode);
}
if(i!=inorder.length()-1) {//有右子树
String rightPre=preorder.substring(i+1,preorder.length());
String rightIn=inorder.substring(i+1,inorder.length());
TreeNode rightNode=new TreeNode();
rightNode.elem=rightPre.charAt(0);
root.right=rightNode;
makeTree(rightPre,rightIn,rightNode);
}
}
void printPostorder(TreeNode root) {
if(root.left!=null)
printPostorder(root.left);
if(root.right!=null)
printPostorder(root.right);
System.out.print(root.elem);
}
boolean checkTree(String a,String b) {
for(int i=0;i<a.length();i++) {
if(i!=a.lastIndexOf(a.charAt(i))) {
System.out.println("There are same element in the tree");
return false;
}
if(!b.contains(""+a.charAt(i))) {
System.out.println("Invalid input");
return false;
}
}
if(a.length()==b.length())
return true;
return false;
}
}
7. java排序算法有多少种
算法和语言无关吧，语言只是把具体的算法实现出来而已。据我了解的排序算法11-13种。排序算法嘛 主要就是个思想而已。不同的算法时间复杂度不一样，空间复杂度也不一样，当然执行的效率也不一样。当然采用哪种算法还取决于你要实现什么样的功能。就好比说：要同时尽快的找出最大最小，或者尽快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体
原地归并排序 — O(n2)
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
等。
8. java十大算法
算法一：快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1 从数列中挑出一个元素，称为 "基准"（pivot），
2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
算法二：堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。
算法步骤：
创建一个堆H[0..n-1]
把堆首（最大值）和堆尾互换
3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4. 重复步骤2，直到堆的尺寸为1
算法三：归并排序
归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
算法步骤：
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素
9. 二叉树和堆排序到底有什么关系啊请形象点描述，最好有图啦！
堆排序是一种选择排序。是不稳定的排序隐敬埋灶蚂方法。时间复杂度为O(nlog2n)。特点是在排序过程中，将排序数组看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和稿腔孩子节点之间的内在关系，在当前无序区中选择关键字最大(或最小)的记录。
其基本思想是
1、将要排序的数组创建为一个大根堆。大根堆的堆顶元素就是这个堆中最大的元素。
2、将大根堆的堆顶元素和无序区最后一个元素交换，并将无序区最后一个位置例入有序区，然后将新的无序区调整为大根堆。
3、重复操作，无序区在递减，有序区在递增。
初始时，整个数组为无序区，第一次交换后无序区减一，有序区增一。
每一次交换，都是大根堆的堆顶元素插入有序区，所以有序区保持是有序的。
P.S.
大根堆和小根堆
堆：是一颗完全二叉树。
大根堆：所有节点的子节点比其自身小的堆
小根堆：所有节点的子节点比其自身大的堆
10. 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);
}
}