亚洲欧洲精品在线,亚洲国产精品成人AV无码久久综合影院,国产一区二区三区亚洲综合

排序��法

天外飞仙 — Mon, 05 Jun 2006 02:24:00 GMT

public class Sort {

  public void swap(int a[], int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
  }

  public int partition(int a[], int low, int high) {
    int pivot, p_pos, i;
    p_pos = low;
    pivot = a[p_pos];
    for (i = low + 1; i <= high; i++) {
      if (a[i] > pivot) {
        p_pos++;
        swap(a, p_pos, i);
      }
    }
    swap(a, low, p_pos);
    return p_pos;
  }

  public void quicksort(int a[], int low, int high) {
    int pivot;
    if (low < high) {
      pivot = partition(a, low, high);
      quicksort(a, low, pivot - 1);
      quicksort(a, pivot + 1, high);
    }

  }

  public static void main(String args[]) {
    int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
    int temp;
    //选择排序�?Selection Sort)
    long begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length; j++) {
          if (vec[j] > vec[i]) {
            temp = vec[i];
            vec[i] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    long end = System.currentTimeMillis();
    System.out.println("选择法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
    //  冒��排序�?Bubble Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length - 1; j++) {
          if (vec[j + 1] > vec[j]) {
            temp = vec[j + 1];
            vec[j + 1] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    end = System.currentTimeMillis();
    System.out.println("冒��法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //插入排序�?Insertion Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 1; i < vec.length; i++) {
        int j = i;
        while (vec[j - 1] < vec[i]) {
          vec[j] = vec[j - 1];
          j--;
          if (j <= 0) {
            break;
          }
        }
        vec[j] = vec[i];
      }
    }
    end = System.currentTimeMillis();
    System.out.println("插入法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //快速排序法(Quick Sort)

    Sort s = new Sort();
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      s.quicksort(vec, 0, 5);
    }
    end = System.currentTimeMillis();
    System.out.println("快速法用时为：" + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
  }

}

天外飞仙 2006-06-05 10:24 发表评论

天外飞仙 — Wed, 29 Mar 2006 09:30:00 GMT

用Java语言实现的各�U�排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归�q�排序、堆排序、SortUtil�{��?

插入排序�Q?/p>

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;
/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class InsertSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i            for(int j=i;(j>0)&&(data[j]                SortUtil.swap(data,j,j-1);
            }
        }
    }

}

冒��排序�Q?/p>

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class BubbleSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i            for(int j=data.length-1;j>i;j--){
                if(data[j]                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

选择排序�Q?/p>

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class SelectionSort implements SortUtil.Sort {

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }

}

Shell排序�Q?/p>

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ShellSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        for(int i=data.length/2;i>2;i/=2){
            for(int j=0;j                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }

    /**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) {
        int temp;
        for(int i=start+inc;i            for(int j=i;(j>=inc)&&(data[j]                SortUtil.swap(data,j,j-inc);
            }
        }
    }

}

快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class QuickSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);

        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);

    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l        SortUtil.swap(data,l,r);
        return l;
    }

}

改进后的快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ImprovedQuickSort implements SortUtil.Sort {

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];

        int top=-1;
        int pivot;
        int pivotIndex,l,r;

        stack[++top]=0;
        stack[++top]=data.length-1;

        while(top>0){
            int j=stack[top--];
            int i=stack[top--];

            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];

            SortUtil.swap(data,pivotIndex,j);

            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);

            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }

        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i            for(int j=i;(j>0)&&(data[j]                SortUtil.swap(data,j,j-1);
            }
        }
    }

}

归�ƈ排序�Q?/p>

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class MergeSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];
        }
    }

}

改进后的归�ƈ排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ImprovedMergeSort implements SortUtil.Sort {

    private static final int THRESHOLD = 10;

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i            for(int j=i;(j>start) && data[j]                SortUtil.swap(data,j,j-1);
            }
        }
    }

}

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class HeapSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }

     private static class MaxHeap{

        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i                queue[++size]=data[i];
                fixUp(size);
            }
        }

        private int size=0;

        private int[] queue;

        public int get() {
            return queue[1];
        }

        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]                    j++;
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }

    }

}

SortUtil�Q?/p>

package org.rut.util.algorithm;

import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class SortUtil {
    public final static int INSERT = 1;
    public final static int BUBBLE = 2;
    public final static int SELECTION = 3;
    public final static int SHELL = 4;
    public final static int QUICK = 5;
    public final static int IMPROVED_QUICK = 6;
    public final static int MERGE = 7;
    public final static int IMPROVED_MERGE = 8;
    public final static int HEAP = 9;

    public static void sort(int[] data) {
        sort(data, IMPROVED_QUICK);
    }
    private static String[] name={
            "insert", "bubble", "selection", "shell", "quick", "improved_quick", "merge", "improved_merge", "heap"
    };

    private static Sort[] impl=new Sort[]{
            new InsertSort(),
            new BubbleSort(),
            new SelectionSort(),
            new ShellSort(),
            new QuickSort(),
            new ImprovedQuickSort(),
            new MergeSort(),
            new ImprovedMergeSort(),
            new HeapSort()
    };

    public static String toString(int algorithm){
        return name[algorithm-1];
    }

    public static void sort(int[] data, int algorithm) {
        impl[algorithm-1].sort(data);
    }

    public static interface Sort {
        public void sort(int[] data);
    }

    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

天外飞仙 2006-03-29 17:30 发表评论

数据�l�构

天外飞仙 — Thu, 17 Nov 2005 08:32:00 GMT

各章节重点勾划：
�W?章　概述
本章主要起到总领作用�Q��ؓ读者进行数据结构的学习�q�行了一些先期铺垫。大家主要注意以下几点：数据�l�构的基本概念，旉��和空间复杂度的概念及度量�Ҏ��Q�算法设计时的注意事��V��本章考点不多�Q�只要稍加注意理解即可�?BR>
�W�一章　�U�性表
作�ؓ�U�性结构的开��章节，�U�性表一章在�U�性结构的学习乃至整个数据�l�构学科的学习中�Q�其作用都是不可低估的。在�q�一章，�W�一�ơ系�l�性地引入铑ּ�存储的概念，铑ּ�存储概念��是整个数据�l�构学科的重中之重，无论哪一章都涉及��C��q�个概念�?BR>
��M��来说�Q�线性表一章可供考查的重要考点有以下几个方面：

1.�U�性表的相兛_��本概念，如：前驱、后�l�、表�ѝ��空表、首元结点，头结点，头指针等概念�?BR>2.�U�性表的结构特点，主要是指�Q�除�W�一及最后一个元素外�Q�每个结炚w��只有一个前��和只有一个后�l��?BR>3.�U�性表的顺序存储方式及其在具体语言环境下的两种不同实现�Q�表�I�间的静态分配和动态分配。静态链表与��序表的�怼�及不同之处�?BR>4.�U�性表的链式存储方式及以下几种常用链表的特点和�q�算�Q�单链表、��@环链表，双向链表�Q�双向��@环链表。其中，单链表的归�ƈ��法、��@环链表的归�ƈ��法、双向链表及双向循环链表的插入和删除��法�{�都是较为常见的考查方式。此外，�q�年来在不少学校中还多次出现要求用递归��法实现单链表输出（可能是顺序也可能是倒序�Q�的问题�?BR>在链表的��题型中�Q�经常考到一些诸如：判表�I�的题。在不同的链表中�Q�其判表�I�的方式是不一��L��Q�请大家注意�?BR>5.�U�性表的顺序存储及铑ּ�存储情况下，其不同的优缺�Ҏ��较，卛_��各自适用的场合。单链表中设�|�头指针、��@环链表中讄��指针而不讄��头指针以及烦引存储结构的各自好处�?BR>
�W�二章　栈与队列
栈与队列�Q�是很多学习DS的同学遇到第一只拦路虎�Q�很多�h从这一章开始坐晕�R�Q�一直晕到现在。所以，理解栈与队列�Q�是走向DS高手的一条必�׃��路，�?BR>
学习此章前，你可以问一下自己是不是已经知道了以下几点：

1.栈、队列的定义及其相关数据�l�构的概念，包括�Q�顺序栈�Q�链栈，�׃�n栈，循环队列�Q�链队等。栈与队列存取数据（��h��意包括：存和取两部分�Q�的特点�?BR>2.递归��法。栈与递归的关�p�，以及借助栈将递归转向于非递归的经典算法：n!阶乘问题�Q�fib数列问题�Q�hanoi问题�Q�背包问题，二叉树的递归和非递归遍历问题�Q�图的深度遍历与栈的关系�{�。其中，涉及到树与图的问题，多半会在树与囄��相关章节中进行考查�?BR>3.栈的应用�Q�数��D��辑ּ�的求解，括号的配对等的原理，只作原理性了解，具体要求考查此�ؓ题目的算法设计题不多�?BR>4.循环队列中判队空、队满条�Ӟ��循环队列中入队与出队��法�?BR>
如果你已�l�对上面的几点了如指掌，栈与队列一章可以不看书了。注意，我说的是可以不看书，�q�不是可以不作题哦�?BR>
�W�三章　�?BR>�l�历了栈一章的痛苦煎熬后，�l�于�q�来了串一章的��x��花明�?BR>
�Ԍ��在概念上是比较少的一个章节，也是最�Ҏ��自学的章节之一�Q�但正如每个�q�来人所了解的，KMP��法是这一章的重要关隘�Q�突破此关隘后，走过��d��是一马��^川的大好DS山河了，呵呵�?BR>
串一章需要攻破的主要堡垒有：

1.串的基本概念�Q�串与线性表的关�p�（串是其元素均为字�W�型数据的特�D�线性表�Q�，�I�Z��与空��g��的区别，串相�{�的条�g
2.串的基本操作�Q�以及这些基本函数的使用�Q�包括：取子�Ԍ��串连接，串替换，求串长等�{�。运用串的基本操作去完成特定的算法是很多学校在基本操作上的考查重点�?BR>3.��序串与链串及块链串的区别和联系�Q�实现方式�?BR>4.KMP��法思想。KMP中next数组以及nextval数组的求法。明��传�l�模式匹配算法的不��Q�明��next数组需要改�q�之外。其中，理解��法是核心，会求数组是得分点。不用我多说�Q�这一节内�Ҏ��本章的重中之重。可能进行的考查方式是：求next和nextval数组��|��Ҏ��求得的next或nextval数组值给��用KMP��法�q�行匚w��的匹配过�E��?BR>

�W�四章　数组与广义表
学过�E�序语言的朋友，数组的概忉|��们已�l�不是第一�ơ见��C��Q�应该已�l�“一回生�Q�二回熟”了�Q�所以，在概念上�Q�不会存在太大障��。但作�ؓ考研评��来说�Q�本章的考查重点可能与大学里的程序语�a�所��x��的不太一��P��下面会作介绍�?BR>
�q�义表的概念�Q�是数据�l�构里第一�ơ出现的。它是线性表或表元素的有限序列，构成该结构的每个子表或元素也是线性结构的�Q�所以，�q�一章也归入�U�性结构中�?BR>
本章的考查重点有：
1.多维数组中某数组元素的position求解。一般是�l�出数组元素的首元素地址和每个元素占用的地址�I�间�q�组�l�出多维数组的维敎ͼ�然后要求你求��数组中的某个元素所在的位置�?BR>2.明确按行存储和按列存储的区别和联�p�，�q�能够按照这两种不同的存储方式求�?中类型的题�?BR>3.��特�D�矩阵中的元素按相应的换��方式存入数�l�中。这些矩阵包括：对称矩阵�Q�三角矩阵，��h��某种特点的稀疏矩�늭�。熟悉稀疏矩�늚�三种不同存储方式�Q�三元组�Q�带辅助行向量的二元�l�，十字链表存储。掌握将�E�疏矩�늚�三元�l�或二元�l�向十字链表�q�行转换的算法�?BR>4.�q�义表的概念�Q�特别应该明��表头与表尾的定义。这一点，是理解整个广义表一节算法的基础。近来，在一些学校中�Q�出��C��q�样一�U�题目类型：�l�出�Ҏ��个广义表L若干个求了若�q�次的取头和取尾操作后的串��|��要求求出原广义表L。大家要留意�?BR>5.与广义表有关的递归��法。由于广义表的定义就是递归的，所以，与广义表有关的算法也常是递归形式的。比如：求表深度�Q�复制广义表�{�。这�U�题目，可以�Ҏ��不同角度�q�义表的表现形式�q�用两种不同的方式解�{�：一是把一个广义表看作是表头和表尾两部分，分别对表头和表尾�q�行操作�Q�二是把一个广义表看作是若�q�个子表�Q�分别对每个子表�q�行操作�?BR>
�W�五章　树与二叉�?BR>从对�U�性结构的研究�q�度到对树�Ş�l�构的研�IӞ��是数据结构课�E�学习的一�ơ跃变，此次跃变完成的好坏，��直接关�p�d��你到实际的考试中是否可以拿到高分，而这所有的一切，��最�l�媄响你的专业课��d��。所以，树这一章的重要性，已经不说自明了�?BR>
��M��来说�Q�树一章的知识点包括：
二叉树的概念、性质和存储结构，二叉树遍历的三种��法�Q�递归与非递归�Q�，在三�U�基本遍历算法的基础上实��C��叉树的其它算法，�U�烦二叉树的概念和线索化��法以及�U�烦化后的查扄��法，最优二叉树的概��c��构成和应用�Q�树的概念和存储形式�Q�树与森林的遍历��法及其与二叉树遍历��法的联�p�，树与��林和二叉树的�{换�?BR>
下面我们来看考试中对以上知识的主要考查�Ҏ��Q?BR>1.二叉树的概念、性质和存储结�?BR>考查�Ҏ��可有�Q�直接考查二叉树的定义�Q�让你说明二叉树与普通双分支树的区别�Q�考查满二叉树和完全二叉树的性质�Q�普通二叉树的五个性质�Q�第i层的最多结�Ҏ��Q�深度�ؓk的二叉树的最多结�Ҏ��Q�n0=n2+1的性质�Q�n个结点的完全二叉树的深度�Q�顺序存储二叉树时孩子结点与父结点之间的换算关系�Q�左为：2*i�Q�右为：2*i+1�Q��?BR>二叉树的��序存储和二叉链表存储的各自优缺点及适用场合�Q�二叉树的三叉链表表�C�方法�?BR>2.二叉树的三种遍历��法
�q�一知识�Ҏ��握的好坏�Q�将直接关系到树一章的��法能否理解�Q�进而关�p�d��树一章的��法设计题能否顺利完成。二叉树的遍历算法有三种�Q�先序，中序和后序。其划分的依据是视其每个��法中对根结�Ҏ��据的讉K��序而定。不仅要熟练掌握三种遍历的递归��法�Q�理解其执行的实际步骤，�q�且应该熟练掌握三种遍历的非递归��法。由于二叉树一章的很多��法�Q�可以直接根据三�U�递归��法攚w��而来�Q�比如：求叶子个敎ͼ��Q�所以，掌握了三�U�遍历的非递归��法后，对付诸如�Q�“利用非递归��法求二叉树叶子个数”这��L��题目��׃��W�如有神了。我会在另一��系列文章（0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}} }" align=absBottom border=0>天外飞仙 2005-11-17 16:32 发表评论

亚洲欧洲精品在线,亚洲国产精品成人AV无码久久综合影院,国产一区二区三区亚洲综合

排序���法

数据�l�构

排序��法