精华内容
下载资源
问答
  • 快排的效率很快,但是我们很少知道如何利用它进行关键字排序,比如我想一个数组a[i][0]进行的一个元素进行关键字排序,又想a[i][1]进行关键字排序。那么接下来就是解决这个问题的方法。 学过数据结构的...

      快排的效率很快,但是我们很少知道如何利用它进行多关键字排序,比如我想对一个数组a[i][0]进行的一个元素进行主关键字排序,又想对a[i][1]进行次关键字排序。那么接下来就是解决这个问题的方法。  

      学过数据结构的同学,应该知道快排的基本原理,就是将要排序的物品(不说成值,因为我们可能要排多维数组或者是结构体),就是每次将一个物品放到序列中最合适的位置,那么如何放,如果想要递增排序,就是前面的物品和后面的物品,谁大的放后面。所以通过这个原理就知道void qsort(void*, size_t, size_t, int*(const void*, const void*));这个函数传参数的时候为什么最后一个参数是一个函数了,真正进行排序交换的是qsort(),但是还需要一个比较两个物品的大小的操作,这个操作是需要用户自定义的,如果需要物品递增,那么这个比较函数cmp()返回的就是a>b[a-b]的true结果,这个时候排序的时候会把大的交换到后面。同理,要想物品递减,那么cmp()返回的就是a<b[b-a]了。

      现在关键的问题来了。

    如果排序仅仅是一个int a[N]的数组

    int cmp(const void *a,const void *b)
    {
        return *(int *)a-*(int *)b;
    }

    //我来解释一下为什么会 return *(int *)a-*(int *)b;这个,因为我们传进到cmp()的参数是单个物体的地址,在这里我们传的是一个存储int值的一个int类型的地址,为了保持cmp()函数的可以让任何类型的数组进行比较大小,所以再传入到cmp()里面就会被转为不可变的const 的空void类型的地址,所以当我们在这个函数内部要比较大小时,又必须将这个地址转换成存储Int类型的地址,然后去取这个地址的值进行大小比较。所以(int *)a是将这个存储空类型void的地址强转换为存储int类型的地址,而只得到这个地址是比较不了大小的,这个时候就必须比较这个存储这个地址的内容了,获得地址内容只要在地址之前加上*号就可以了即*(int*)a这个的实际意义。

    同理如果你要比较结构体数组,就需要在cmp内部把const void *a单个结构体成员的地址然后就是去结构体中需要比较大小的关键字了

    int cmp( const void *a ,const void *b) 
    {
    return (*(Node *)a).data > (*(Node *)b).data ? 1 : -1; //或者true,false
    }

    qsort(s,100,sizeof(s[0]),cmp);
    根据这个结构体我们,同理可推出比较多维数组,这里我们用二维数组的例子,用二维数组的第二个值作为排序的关键字
    int a[1000][2];
    qsort(a,1000,sizeof(int)*2,comp);
     
    intcomp(constvoid*a,constvoid*b)
     
    {
    return((int*)a)[1]-((int*)b)[1];
    }
    那么我们进一步思考,怎样才能是二维数组有主次关键字排序,比如我想以a[i][2]中以a[i][0]为主关键字排序,以a[i][1]为次关键字排序。
    其实很简单比较一个物品大小的操作在我们手上,我们只需在cmp()最后给一个比较两个物品的大小的结构给qsort()就可以了,所以我们可以这样做:
    1,如果主关键字不相等就比较主关键字的大小并返回结果。
    2,如果主关键字相等,就比较次关键字的大小并返回结果就可以了。
    例子:
    int cmp( const void *a , const void *b )
    {
    if( ((int *)a)[0]==((int *)b)[0] ) return ((int *)a)[1]-((int *)b)[1];
    else return ((int *)a)[0]-((int *)b)[0];
    }
    qsort(a[1],n,sizeof(a[1]),cmp);
    这个例子还用了一个方法是如何忽略数组中a[0]的值,直接以a[1]开始排序。
    那么结构体中多关键字排序就是一样的了。至此就可以利用快排达到理想的排序状态了。
     

    转载于:https://www.cnblogs.com/woshijishu3/p/3604589.html

    展开全文
  • 快速排序基本思想:通过一轮的排序将序列分割成独立的两部分,其中前一部分序列的关键字(这里主要用值来表示)均比后一部分序列的关键字关键字小(递增排序)或者大(递减排序)。然后继续分别两部分的序列进行...

    快速排序,见名知意肯定是比较快。据实验所要排序的序列越乱,快速排序的效率越高!也是一种不稳定的排序!

    快速排序基本思想:通过一轮的排序将序列分割成独立的两部分,其中前一部分序列的关键字(这里主要用值来表示)均比后一部分序列的关键字关键字小(递增排序)或者大(递减排序)。然后继续分别对两部分的序列进行同样的分割,最后到达整体有序。在排序过程中,由于已经分开的两部分的元素不需要进行比较,因此减少了比较次数,降低了排序时间。

    -------------------------------------------------------分割线,画图说明----------------------------------------------------------------------

    int[] array = {5,1,4,8,0,7,2,9};

    确定一个在数组中的比较标杆,一般以数组下表0的数值作为标杆:index=array[0],     循环条件i<j.
    分别判断数组下表i与j处的对比标杆大小,如果下表j处的数值大于index,--j,如果下表j处的数值小于index,则把值赋予i下标位置;如果i处的数值小于index,++i,如果i处的数值大于index。则把值赋予j下标的位置。直到i=j,循环停止。      

     

                     下标j处的数字大于5,--j 

                      下标j处的数字小于5,i处数值赋值2 ,++i

                       下标i处的数字小于5,++i

                       下标i处的数字小于5,++i

                        下标i处的数字大于5,j处数值赋值8,--j

                        下标j处的数字大于5,--j 

                         下标j处的数字小于5,i处数值赋值0,++i

                           此时的i不在小于j,array[i]=index

    后面再分别对前后两部分递归使用上述方法,最后就会完成对整个序列的升序排序!!!

    下面贴代码,low和high分别代表i和j的位置。至此快拍就这么结束了,也并不难吧!主要是理解思路就变得简单!

       /**
         * 快速排序
         * @param a array name
         * @param low array begin index
         * @param high array end index
         */
        public static void quickSort(int a[],int low,int high){
    
            int i = low;
            int j = high;
            int temp = a[i];
            if(i>=j){
                return ;
            }
            while(i<j){
    
                while(i<j && a[j]>=temp){
                    j--;
                }
                if(i<j){
                    a[i]=a[j];
                    i++;
                }
                while(i<j && a[i]<=temp){
                    i++;
                }
                if(i<j){
                    a[j]=a[i];
                    j--;
                }
            }
            a[i] = temp;
            quickSort(a,low,i-1);
            quickSort(a,i+1,high);
        }
    
    

     

    展开全文
  • 排序

    2017-06-09 10:23:40
    对关键字进行排序,就相当于对关键字对应的文件进行排序。(有点像数据库SQL中的主键。)   排序的稳定性 如果序列中有相同项,即有相同的关键字。那么就涉及到排序的稳定性的问题。   排序后,相同值的项...

    排序基本概念

    排序,就是整理文件中的记录,使之按关键字递增(或递减)次序排列起来。

    被排序的对象可以是文件或数据项。

    排序的依据就是标识每个对象的关键字。对关键字进行排序,就相当于对关键字对应的文件进行排序。(有点像数据库SQL中的主键。)

     

    排序的稳定性

    如果序列中有相同项,即有相同的关键字。那么就涉及到排序的稳定性的问题。

     

    排序后,相同值的项之间的相对次序没有发生变化,那么这个排序就是稳定的。

    如果,排序后相同值的项之间的相对次序发生了变化,则这种排序方法是不稳定的。

     

    不稳定的排序:

    选择排序,希尔排序,堆排序,快速排序;

     

    稳定的排序:

    冒泡排序,双向冒泡排序,插入排序,二叉树排序等。

     

    排序的分类

    排序算法都要有两个基本的操作:

    (1)比较项值的大小

    (2)改变指向项的指针或移动项值本身

     

    根据是否涉及数据的内、外存交换:

    如果在排序过程中,整个文件都放在内存中处理,排序时不涉及数据的内、外存交换,则称之为内部排序。

    否则,排序中涉及到数据的内外存交换,称之为外部排序。

     

     

    排序的性能评价

    标准:

    1.执行时间和所需的辅助空间

    2.算法本身的复杂度。

     

    空间复杂度:

    若算法所需的辅助空间并不依赖于问题的规模n,即辅助空间是O(1),则称之为就地排序。否则,非就地排序的辅助空间一般为O(n)。

     

    时间复杂度:

    1.平方阶排序O(n2):一般为简单排序,如插入排序,折半排序,选择排序和冒泡排序。

    2.线性对数排序O(nlogn)排序:如快速,归并,堆排序。

    3.O(n1+ε)阶排序:ε是介于0和1之间的常数,即0<ε<1,如希尔排序。

    4.线性阶排序O(n):如桶,箱,和基数排序。

     

    简单排序中插入排序最好,快速排序最快。

    若n较小(n<50),可以采用插入排序和选择排序。

    若n较大,则应采用时间复杂度为O(nlogn)的排序方法:快速排序,堆排序,归并排序。

     

     

    平均角度而言,哈希表获取任意一个指定值是最快的。->查找用哈希。或是链表。

    因为哈希表需要的额外存储空间多。付出了高额外空间的代价,理应获得高性能。

    哈希函数,不管怎么样,都是输入键值对,输出桶编号。

     

     

    二分查找法:

    已知一个有序序列,找出指定元素的方法。

    1.定义三个指针:low, mid, high,分别指向元素所在范围的下界、中间、上界。Mid=(high+low)/2

    2.让元素与mid比较,若相等,返回mid;

    若关键字小于mid对应的数,则high=mid-1,继续递归循环;

    若关键字大于mid对应的数,则low=mid+1,继续递归循环;

    3.直到找到所在位置。

     

     

    冒泡法

    冒泡排序和快速排序都是属于交换排序:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。

     

    public static voidbubble(int[] a){

    boolean exchange;//交换标志。

    for(inti=0 ;i<a.length-1; i++){

    exchange= false;

    for(intj=0; j<a.length-1-i; j++){

    if(a[j]>a[j+1]){

    inttemp= a[j];

    a[j]=a[j+1];

    a[j+1]=temp;

    exchange = true;//发生了交换,故将交换标志置为true

    }

    }

    if(!exchange){//本次排序未发生交换,提前终止算法。

    return;

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    选择排序

    首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,放到排序序列的末尾。以此类推,直到所有的元素均排序完毕。

    public static voidchoice(int[] a){

    for(inti=0 ;i<a.length-1; i++){

    for(intj=i+1; j<a.length; j++){

    if(a[i]>a[j]){

    inttemp= a[j];

    a[j]=a[i];

    a[i]=temp;

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    插入排序

    1.从第一个元素开始,认为已经排序了;

    2.取下一个元素,在已经排序的元素序列中从后向前扫描;

    3.如果前者大于后者,则交换二者位置;

    4.重复步骤3,直到前面的小于等于后面的;

    5.把原始序列的指针向后移一位,重复步骤2。

     

    public static voidinsert(int[] a){

    for(inti=0 ;i<a.length; i++){

    for(intj=i; j>0 ; j--){

    if(a[j]<a[j-1]){

    inttemp= a[j];

    a[j]=a[j-1];

    a[j-1]=temp;

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    希尔排序

    1.通过设定的增量值,将数据进行分组;

    2.然后对每一组数据进行排序(每组的排序其实就是插入排序);

    3.增量不断变化,直至为1(要求最后一个增量必须为1);

    4.每组数据排好后,整体序列自然有序了。

     

    public static voidshell(int[] a){

     

    for(intincrement = a.length/2; increment>0; increment/=2){

    for(inti=increment; i<a.length; i++){

    for(intj=i; j>=increment ; j-=increment){

    if(a[j]<a[j-increment]){

    inttemp= a[j];

    a[j]=a[j-increment];

    a[j-increment]=temp;

    }

    }

    }

    }

    for(intk=0;k<a.length; k++){

    System.out.print(a[k]+"");

    }

    }

     

     

    快速排序

        快速排序采用分治策略。分治法的基本思想是:将原问题分为若干个规模更小但结构相似的子问题,递归地求解这些子问题,然后将这些子问题的解组合为原问题的解。

    具体思路见5月8日笔记。

     

    快排具体思路

    以这个思路为准。

    1. 设置两个变量i,j,其初值分别为low和high。分别表示待排序序列的起始下标和终止下标。

    2.将第i个记录当做枢纽元。即定义pivot=r[i]。

    3.从下标为j的位置开始由后向前依次搜索,当j位置处的元素值比枢纽元pivot的值小时,把该元素向前移动到下标为i的位置上,然后i=i+1;

    4.从下标为i的位置开始由前向后依次搜索,当找到第1个比pivot的值大的元素时,把该元素向后移动到下标为j的位置上;然后j=j-1;

    5.重复第3,4步,直到i==j为止。

    6.r[i]=pivot;

    7.进行一趟快速排序后,再分别对枢纽元分割所得的两个子序列进行快速排序,递归进行。

     

    算法的框架为:

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

    //对a[...]进行排序

    int index= (low + high)/2;//枢纽元所在的位置

    if(low<high){//仅当区间长度大于1时才需排序

    Partition(a, low , high);//对a[]进行划分,元素具体怎么换位

    QuickSort(a, low, index-1);//一次划分结束后,对枢纽元左边的序列进行递归排序。

    QuickSort(a, index+1, high);//对枢纽元右边的序列进行递归排序。

     

    }

    }

     

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

    1.把枢纽元和最右边的元素互换位置。

    2.给数组第一个元素一个index,i;给数组倒数第二个元素一个index,j。

    3.把i向右移,直到碰到元素的值大于等于枢纽元为止。

    4.把j向左移,直到碰到元素的值小于等于枢纽元为止。

    5.当i和j交错后,也停止移动。

    6.最后一步就是将枢纽元与i所指向的元素互换位置。

    在这个第一阶段就实现了把所有比枢纽元小的元素都移到枢纽元的左边;把所有比枢纽元大的元素都移到枢纽元的右边。

    }

     

    快排具体实现

    public static voidqSort(int[] arr, int low, int high){

    //快排入口

    if(low<high){

    intpivot = Partition(arr, low, high);

    qSort(arr,low, pivot-1);

    qSort(arr,pivot+1, high);

    }

    }

     

    public static intPartition(int[] arr, int i, int j){

    //一趟快排

    intpivot = arr[i];

    while(i<j){

    while(i<j&& pivot<arr[j]){

    j--;

    }

    if(i<j){

    arr[i]= arr[j];

    i++;

    }

    while(i<j&& arr[i]<pivot){

    i++;

    }

    if(i<j){

    arr[j]= arr[i];

    j--;

    }

    }

    arr[i]= pivot;

    returni;

    }

     

     

     

     

     

    归并排序

    将两个已经排序好的序列合并成一个序列。

    详细内容见5月8日笔记。

    注意:归并排序的空间复杂度为O(n)。因为多引入一个数组,所以需要长度为n的额外存储空间嘛。

     

     

     

    堆排序

    1.堆排序中使用到二叉堆的结构性质:

    二叉堆是一棵被完全填满的二叉树,底层例外。就是有些叶子节点可能没有。底层上的元素是从左至右填充的。就是缺的话,也是右边的缺。

    可以用一个数组来表示二叉堆的节点存储情况:

    对数组中任一位置i上的元素,其左儿子在位置2i上,右儿子在左儿子后面的单元(2i+1)中,它的父亲则在位置|_i/2_|上。

    2.涉及到的二叉堆的堆序性质:

    小顶堆性质:

    堆中,对于每一个节点X,X的父亲中的关键字都不大于X的关键字,根节点除外。

    由这个性质,最小元总可以在根处找到。

    大顶堆性质与其相反,根结点处元素的值最大。

     

    又考虑到deleteMin这个方法。最小元可以肯定是在根处,用deleteMin方法从堆中删去最小元后,堆缩小。从而数组的最后一个单元可以存放刚刚删去的元素。依次理论一直往下走,最终,原数组将以递减的次序排列这些元素。

    想递增的排列,deleteMin换成deleteMax就行了。

     

    因为deleteMin方法花费时间O(logn),对N个元素操作一遍,总的运行时间是O(nlogn)。

     

     

    堆排序两步走:

    1.首先构建一个大顶堆或小顶堆出来。

    建堆时是从N/2-1的位置从后往前进行筛选。父结点和两个孩子结点比较。

    2.堆代表的二叉树数组的根结点和数组的最后一个结点交换位置。如此循环进行,直到二叉树剩下一个结点为止。

     

    如果是大顶堆,堆排序后是升序排序。如果是小顶堆,堆排序后是降序排序。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 思想:二叉排序树来说,其中序遍历序列为一个递增有序序列,因此,给定的二叉树进行中序遍历,如果始终能保持前一个值比后一个值小,则说明该二叉树是一棵二叉排序树。算法如下: KeyType predt=0; //predt为...

    思想:二叉排序树来说,其中序遍历序列为一个递增有序序列,因此,对给定的二叉树进行中序遍历,如果始终能保持前一个值比后一个值小,则说明该二叉树是一棵二叉排序树。算法如下:

    KeyType predt=0;//predt为全局变量,保存当前节点中序前趋的值,初值为最小值

    int judgeBST(BSTNode *bt)

    {

    //返回1表示是一颗二叉排序树,返回0表示不是

    int b1,b2;

    if(bt==NULL)

     return 1;

    else

    {

    b1=judgeBST(bt->lchild);//判断左子树

    if(b1==0||predt>=bt->key)

      return 0;

    predt=bt->key;//保存当前节点的关键字

    b2=judgeBST(bt->rchild);//判断右子树

    return b2;

    }

    }

    注意:若一个二叉树的中序序列是一个有序序列,则该二叉树一定是一棵二叉排序树。

    展开全文
  • 排序:把一个无序的元素序列按照元素的关键字递增或递减排列为有序的序列排序分为:插入排序、选择排序、交换排序和归并排序排序的元素的存储结构: 1.顺序存储 2.链式存储 3.静态存储 插入排序 插入排序的...
  • 更确切的说,排序是把一个数据元素序列整理成按关键字递增(或递减)排列的过程。 不过首先,我们必须先解释一下关键字这个词。关键字是要排序的数据元素集合中的一个域,排序是以关键字为基准进行的。而关键字也...
  • 排序算法

    2019-07-16 23:22:14
    1.排序算法 假设含有n个记录的序列为{r1,r2,……,rn},其相应的关键字分别为{k1,k2,……, kn},需确定 1,2,……,n的一种排列p1,p2,……,pn,使其相应...序列对象根据某个关键字进行排序。 多个关键字排序最...
  • 更确切的说,排序是把一个数据元素序列整理成按关键字递增(或递减)排列的过程。 不过首先,我们必须先解释一下关键字这个词。关键字是要排序的数据元素集合中的一个域,排序是以关键字为基准进行的。而关键字也...
  • 有趣的排序算法—入门介绍

    热门讨论 2016-06-04 11:20:52
    排序其实是对关键字进行递增或递减顺序对一组记录重新进行排列的操作。即已知一序列,对其中的关键字进行从有序表到有序表的转换。 二:排序分类: 依据排序过程中记录多占用的存储设备进行分类,结构见下图: 三:...
  • 排序之简单排序方法

    2017-05-13 18:54:36
    排序就是按关键字的递减或递增顺序一组记录重新进行整队的操作。对于排序来说,主要考虑的因素就是时间复杂度、空间复杂度和算法的复杂度。 下面我先整理简单选择排序,直接插入排序,折半插入排序,希尔排序和...
  •  排序是按关键字的非递增或递减顺序一组记录中心进行排序的操作。(将一组杂乱无章的数据按一定规律顺次排列起来。) 未定列表与不稳定列表  假设 Ki = Kj ( 1 ≤ i ≤ n,1 ≤ j ≤ n,i ≠ j ),在序列前...
  • 起泡排序是一种简单的交换排序,它通过无序序列区中的相邻记录的关键字进行“比较”和记录位置的“交换”,以实现关键字较小的记录向“一头”漂移,而关键字较大的记录向“另一头”下沉,从而达到记录按关键字非...
  • 几种排序算法比较

    千次阅读 多人点赞 2018-12-27 11:52:50
    排序是按照关键字的非递减或非递增顺序一组记录重新进行排列的操作,是无规律的一组序列转化为递增或递减的操作。 排序的稳定性: 当排序记录中的关键字都部相同时,则任何一个记录的无序序列经过排序后得到...
  • 数据结构之排序算法

    2019-07-18 09:21:52
    排序就是序列对象根据某个关键字进行排序。假设含有n个记录的序列为{r1,r2,……,rn},其相应的关键字分别为{k1,k2,……,kn},需确定 1,2,……,n的一种排列p1,p2,……,pn,使其相应的关键字满足kp1≤kp2≤……...
  • 一、排序 假设含有n个记录的序列为{r1,r2,……,rn},其相应的关键字分别为{k1,k2,……, kn},需确定 1,2,……,n的一种排列p1,p2,……,pn,使其...1、序列对象根据某个关键字进行排序 2、多个关键字排序...
  • python--排序算法

    2019-07-18 17:44:16
    1.排序算法的描述 假设含有n个记录的序列为{r1,r2,……,rn},其相应的关键字分别为{k1,k2,……, kn},需确定 1,2,……,n的一种排列p1,p2,……,pn,使其相应的关键字...序列对象根据某个关键字进行排序。 2....
  • 排序的超详细讲解

    2019-08-07 08:19:17
    所谓的排序就是元素序列建立某种有序排列的过程,是把一个数据元素序列整理成按关键字递增(递减)排列的过程。 排序分为两大部分:内排序和外排序。 内排序:内排就是对待排序数据存放在内存中进行排序过程,...
  • 第7章 排序算法 4课时 排序又称分类是计算机进行数据处理...7.1 排序算法及常见排序算法比较 排序是指将一个待排序元素集合按关键字递增或递减顺序整理为一个有序序列的过程例如对于一组具有关键字值{43, 56, 37, 28, 1
  • 排序的定义:任意连续有限序列内的元素进行重新排列,使得该序列关键字非递减或非递增排序的稳定性:待排序序列中存在两个不同位置的元素且 x在y 前面,若排序之后,仍然x在y前面,则称该排序算法是稳定的。...
  • 10.3交换排序 交换排序法是对序列中的元素进行一系列比较, 被比较的两元素逆序时,进行交换通过交换得到 无序序列中的关键字最小或最大的记录,并将其加入到 有序子序列中,以此方法增加记录的有序子序列的长度 这里...
  • 快速排序算法

    2021-01-15 20:49:08
    通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。...
  • 数据结构——排序

    2020-12-17 22:24:28
    排序是按照关键字的非递减或非递增序列对一组重新进行排列的操作。 排序分为:内部排序和外部排序 排序的稳定性:一组不规则的序列中有两个相同的数组(他们有前后之分),排之后他们的前后顺序不变,就称这种排序...
  • 数据结构-排序

    2018-02-10 22:41:18
    排序:重新排列序列,使之按关键字递增或递减。 n个元素进行排序的时间复杂度最快也要O(n)/*初始有序*/、通常是O(nlogn)或O(n^2). 根据排序过程中,数据元素是否完全在内存中,将排序算法分为两类;内部排序和...
  • 1.排序算法 定义:把一个无序元素序列按照元素的关键字递增或递减排列为有序的序列 一、插入排序 1)直接插入排序: 基本思想:假设前i-1个元素已经...例如:对序列(45,23,56,12,97,76,29,68)进行直接插入排序。 ...
  • 直接插入排序

    2012-09-13 22:03:25
    顾名思义, 直接插入排序就类似于我们打扑克牌时, 一边摸牌, 一边理牌。先拿第一张牌在手上, 再拿第二张牌时, 我们比较一下大小, 才知道是 ...按关键字递增的有序序列为止。   /** * 顺序表L作直
  •   二叉排序树(BST)   定义   二叉排序树又称二叉查找树。... 右子树结点值,二叉排序进行中序遍历,可以得到一个递增的有序序列。   查找   二叉排序树的查找是从根结点开始,沿某个分支逐层向下进行比较

空空如也

空空如也

1 2 3
收藏数 60
精华内容 24
关键字:

对关键字序列进行递增排序