class Tree{
Tree left;
Tree right;
int data;
}
class BST{
private Tree t;
public BST(Tree T){
this.t=T;
}
public void getK(int k){
getKmethod(this.t,int k);
}
private void getKmethod(Tree t,int k);
}
private getKmethod(Tree t,int k){
if(t==NULL) return;
getKmethod(t.right,k);
if(t.data>=k) system.out.println(t.data);
getKmethod(t.left,k);
}
int palindrome(char s[], int start, int end) {
if (start >= end) return 1;
if ((s[start] == s[end]) && palindrome(s, start + 1, end - 1)) return 1;
return 0;
}
根据中序和前序,建立二叉树public TreeNode buildTreeIndex(int[] preorder, int[] inorder) {
if (preorder == null || inorder == null) {
return null;
}
return getBinaryTree(0, 0, inorder.length - 1, preorder, inorder);
}
public TreeNode getBinaryTree(int preIndex, int inIndex, int inEndIndex, int[] preorder, int[] inorder) {
if (preIndex > preorder.length - 1 || inIndex > inEndIndex) {
return null;
}
// 根节点的值
int rootValue = preorder[preIndex]; // 由于是前序遍历,第一个值一定是根节点的值
// 找出根节点的下标,由于中序遍历的结果是有序的,所以可以通过“二分搜索法”查找下标的值
int rootIndex = getRootIndex(inorder, rootValue, inIndex, inEndIndex + 1);
// 创建根节点
TreeNode treeNode = new TreeNode(rootValue);
treeNode.left = getBinaryTree(preIndex + 1, inIndex, rootIndex - 1, preorder, inorder);
treeNode.right = getBinaryTree(preIndex + rootIndex + 1 - inIndex, rootIndex + 1, inEndIndex, preorder, inorder);
return treeNode;
}
private static void percUp( Comparable [ ] a, int start )
{
int j = start, i = j / 2;
Comparable temp = a [j];
while (j > 1){
if ( a[i] <= temp)
break;
else { a[j] = a[i]; j= i; i = i / 2; }
}
a[j] = temp;
}
写一个程序判断一个二叉树是不是二叉搜索树
方法一:
Public boolean isBST(Node n) {
If (n==null) return true;
If (n.left!=null && max(n.left).element>n.element) return false;
If (n.right!=null && min(n.right).element<n.element) return false;
return isBST(n.left) && isBST(n.right);
}
Public Node max (Node n) {
If (n==null) return null;
While (n.right!=null) { n=n.right; }
Return n;
}
Public Node min (Node n) {
If (n==null) return null;
While (n.left!=null) { n=n.left; }
Return n;
}
方法二
Public boolean isBST(Node n) {
If(n==null) return true;
List l = inOrderList(n);
int i,j;
For(i=0,j=1;j<l.length();i++,j++) {
if(l.get(i)>=l.get(j)) return false;
}
Return true;
}
Public List inOrderList(Node n) {
List l = new ArrayList();
inOrderList(n, l);
Return l;
}
Public void inOrderList(Node n, List l) {
If(n==null) return;
inOrderList(n.left, l);
l.add(n.element);
inOrderList(n.right, l);
}
编写带有下列声明的例程
public void permute(String str);
private void permute(char[] str,int low,int high);
第一个例程是驱动程序,它调用第二个例程并显示String str中字符的所有排列。如果str是“abc”,那么输出的串则是abc,acb,bac,bca,cab,和cba。第二个例程使用递归。
(2)设置边界条件。
当遍历到最后一个字母时,输出。虽然JAVA中没有指针的概念。但是我们也可以使用一些方法来代替指针。
(3)设计函数,确立参数。本题已经给大家设计好了。
//low和high表示需要被全排列的元素范围--两端点的index
private static void permute(char[] str, int low, int high) {
if (low == high) { //被处理的范围缩小为0
System.out.println(str);
} else {
for (int i = low; i <= high; i++) {
swap(str, low, i); //下标为low和i的元素交换在数组中的位置
permute(str, low + 1, high); //每次调用时low+1,即全排列范围缩小1
swap(str, low, i); //回溯的时候,还原为先前状态
}
}
}
void permute(char[] str, int low, int high) { //low=0,high=str.length-1
if (low == high) {
System.out.println(str);
} else {
for (int i = low; i <= high; i++) {
char[] str2 = new char[str.length];
for (int b = 0; b <= high; b++) str2[b] = str[b];
char temp = str2[low];
str2[low] = str2[i];
str2[i] = temp;
permute(str2, low + 1, high); //用空间换时间?
} //end of for
} //end of else
}
void swap(char[] str, int i, int j){
char temp=str[i];
str[i]=str[j];
str[j]=temp;
}//str是引用传递(passed by reference)
已知一个有向图的邻接表表示,给出一个算法高效地计算出这个图的逆邻接表(即顶 点 i 的边链表是所有进入该顶点的边)。要求算法的时间复杂度是 O(n+e),其中 n 是图的顶 点数,e 是图的边数。
for(int i=0;i<numVertices;i++){
Edge *p=NodeTable[i].adj;
while(p!=NULL){
Edge *q= new Edge(i,p->weight);
q->link=NodeTable[p->dest];
NodeTable[p->dest].reverseAjd=q;
}
}
void sort(float[]a){
int n=a.length();
int i=0,j=n-1;
while(i<j){
while(a[j]>=0 && i<j) j--;
while(a[i]<0 && i<j) i++;
swap(a,i,j);
}
}
void swap(float[] a,int i,int j){
float temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
return a;
}