数据结构基础知识（三）

1.      如何找出数组中第k个最小的数

  给定一个无序的数组,从一个数组中找到第k个最小的数，1）排序法；2）“剪枝”法，采用快速排序的思想，主要思路：选一个数temp=a[n-1]作为枢纽，把比它小的数都放在它的左边，比它大的数放在右边，然后判断temp的位置，如果它的位置为k-1，则它就是要找的；如果它的位置小于k-1，说明k个小的元素一定在数组的右半边，采用递归的方法在数组右边继续查找；若小于k-1，可同思路。

public class Test {

    public static int quiKSort(int a[],int low,int high,int k){

           int i,j;

           int temp;

           if(low>high){

                  return Integer.MIN_VALUE;

           }

           i=low+1;

           j=high;

           temp=a[i];

           while(i<j){

                  while(i<j&&a[i]>=temp)

                         j--;

                  if(i<j)

                         a[i++]=a[j];

                  while(i<j&&a[i]<temp)

                         i++;

                  if(i<j)

                         a[j--]=a[i];

           }

           a[i]=temp;

           if(i+1==k)

                  return temp;

           else if(i+1>k)

                  return quiKSort(a, low, i-1, k);

           else

                  return quiKSort(a, i+1, high, k);

    }

    public static int getKMin(int a[],int k){

           if(a==null)

                  return Integer.MIN_VALUE;

           if(a.length<k)

                  return Integer.MIN_VALUE;

           return quiKSort(a, 0, a.length, k);

          

    }

    public static void main(String[] args) {

           int a[]={1,5,2,6,8,0,9,};

           int kMin=getKMin(a, 4);

           System.out.println(kMin);

    }

}

2.      找出数组中只出现一次的数字

考虑到时间复杂度与空间复杂度的限制，可以考虑到异或运算，，任何一个数字异或它自己的等于0。

public classOnceTime {

    public static int findNotDouble(int a[]){

           int n=a.length;

           int result=a[0];

           int i;

           for(i=1;i<n;i++){

                  result^=a[i];

           }

           return result;

    }

    public static void main(String[] args) {

           int a[]={1,2,3,2,4,3,5,4,1};

           int num=findNotDouble(a);

           System.out.println(num);

    }

}

3.       找出数组中唯一重复的元素

数组a[N]，包含1~N-1中的数，且其中有一个重复的元素。采用数学求和法，因为只有一个数字重复1次，且是连续的，则所有项的和减去1~N-1的和，即为重复的数字。

public class Test {

  public static int findDup(int a[]){

         int n=a.length;

         int tmp1=0;

         int tmp2=0;

         for(inti=0;i<n-1;i++){

                tmp1+=(i+1);

                tmp2+=a[i];

         }

         tmp2+=a[n-1];

         int result=tmp2-tmp1;

         return result;

  }

  public static void main(String[] args) {

         int a[]={1,2,3,4,4,5,6,7};

         int num=findDup(a);

         System.out.println(num);

  }

}

4.       递归方法求一个整数数组的最大元素

利用递归法。

public class MinNum{

  public static int getMinNum(int[] a,int begin){

         int len=a.length-begin;

         if(len==1)

                return a[begin];

         else

                return Max(a[begin], getMinNum(a,begin+1));

  }

 

  private static int Max(int a, int b) {

         return a>b? a:b;   

  }

  public static void main(String[] args) {

         MinNummin=new MinNum();

         int a[]={1,2,31,342,432,5,64,61,666};

         System.out.println(min.getMinNum(a, 0));

  }

}

5.       如何实现二叉排序树

二叉树的性质1:一棵非空二叉树的第i层最多有 个结点(i>=1);

2: 一棵深度为k的二叉树中,最多具有 个结点,最少有k个结点;

3:对于一棵非空而阐述,度为0的结点(叶节点)总是比度为2的节点多一个,即: .

4: 具有n个结点的完全二叉树的深度为 .

5: 对于具有n个结点的完全二叉树,如果按照从上至下和从左到右的顺序树对二叉树中的所有结点从1开始编号,1)如果i>1,那么序号为i的结点的双亲结点的序号为i/2；如果序号为1，则是根结点。2）如果 ，i的左孩子结点为2i；如果 ，i的节点无左孩子。3）如果 ，则i的右孩子结点为2i+1；，i无右孩子。

6.       实现二叉排序树

public class BinaryTree {

  private Node root;

  public BinaryTree(){

            root=null;

  }

  //将数据插入到排序树中

  public void insert(int data){

            NodenewNode=new Node(data);

            if(root==null)

                     root=newNode;

            else{

                     Nodecurrent=root;

                     Nodeparent;

                     while(true){

                              parent=current;

                              if(data<current.data){

                                        current=current.left;

                                        if(current==null){

                                                 parent.left=newNode;

                                                 return;

                                        }

                              }else{

                                        current=current.right;

                                        if(current==null){

                                                 parent.right=newNode;

                                                 return;

                                        }

                              }

                     }

            }

  }

  //将数值输入构建的二叉树

  public void buildTree(int []data){

            for(int i=0;i<data.length;i++){

                     insert(data[i]);

            }

  }

  //中序遍历方法的递归实现:左-根-右

  public void inOrder(Node localRoot){

            if(localRoot!=null){

                     inOrder(localRoot.left);

                     System.out.print(localRoot.data+" ");

                     inOrder(localRoot.right);

            }

  }

  public void inOrder(){

            this.inOrder(this.root);

  }

 

  //先序遍历方法的递归实现，跟-左-右

  public void preOrder(Node localRoot){

            if(localRoot!=null){

                     System.out.print(localRoot.data+" ");

                     preOrder(localRoot.left);

                     preOrder(localRoot.right);

            }

  }

  public void preOrder(){

            this.preOrder(this.root);

  }

  public static void main(String[] args) {

            BinaryTreebiTree=new BinaryTree();

            int[] data={2,8,7,4,9,3,1,6,7,5};

            biTree.buildTree(data);

            System.out.print("二叉树的中序遍历：");

            biTree.inOrder();

            System.out.println();

            System.out.print("二叉树的先序遍历：");

            biTree.preOrder();

            System.out.println();

  }

}