《数据结构》-Chapter9-南京大学考研初试典型算法题

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;
}