精华内容
下载资源
问答
  • 表1—为排序参照的表(并假排序关键字是A列)表2—排序的表(并假排序的目标关键字也是A列)1、对表1,在A列后面插入一个新列,作为辅助列(新插入的列即是B列)2、新插入的B列进行数字递增自动填充3、对表2,也在A列...

    怎么将一个excel表格数据按照另一个排序

    假设:

    表1—为排序参照的表(并假排序关键字是A列)

    表2—排序的表(并假排序的目标关键字也是A列)

    1、对表1,在A列后面插入一个新列,作为辅助列(新插入的列即是B列)

    2、对新插入的B列进行数字递增自动填充

    3、对表2,也在A列后面插入一个新列,作为辅助列(新插入的列也是B列了)

    表2 B2单元格中输入公式 =VLOOKUP(A2,表1!A:B,2,0)

    4、对表2进行排序,不过,排序的关键字是B列(而不是A列)

    excel表格怎么设置数据按递增排序

    如何快速填充1-100或者1000序列呢,本节视频小编教大家快速填充序列哦!

    如何排序Excel表格中的数据 ?

    1、打开所需Excel表格,如图所示,数据无排序,我们不能第看出哪个项目做的最好。那么,我们就要对该数据进行排序:

    2、鼠标选定第一行标题栏,如果你没有设标题栏的最好插入一行设标题栏,一是对各列数据进行标注,二是方便我们进行排序操作:

    3、选定第一行标题栏之后,在开始菜单找到“筛选”工具并点击,如图所示:

    4、点击“数量”单元格的小倒三角标志,出现下拉框可进行条件筛选,从大到小排序点击【降序】,从小到大排序点击【升序】,如图所示:

    excel表格如何按关键字进行排序

    excel关键字排序步骤如下:

    1、打开excel,选择好要进行排序域。

    2、点击

    菜单栏

    的【数据】-----【排序】。

    3、在弹出的

    菜单

    中选择

    主关键字

    姓名

    】,次关键字【总成绩】,点击确定。

    4、可以看到

    表格

    中的数据已经按照名字的升序排列。

    怎样使excel表格内容按某一列排序

    如下:

    操作版本EXCEL2003;

    以下图中表据为例;现在“考核成绩”这一列来排序,

    1;选中A1到C7单元格;

    2;然后,在工作表上方的命令栏中顺序点:数据-排序

    3;弹出”排序“设置框;在”主要关键字“的三角点下;弹出的菜单中点”考核成绩“;

    4;然后,在”升序“和”降序“这里,如果成绩是按从低分到高分排序的,就点选”升序“;若是从高分到低分排序的就点选”降序“; 现在以从高分到低分来排序为例。点”降序“;

    5;在”我的数据区域“这里点”有标题行“;然后再点确定。

    6;点确定后,表格中的内容即按”考核成绩“这一列排序。如下图所示。

    Excel表格怎么把数据按照班级排序?

    在上面的菜单栏里面选择筛选,选择自动筛选,然后就可以根据年级还是成绩,还是班级都可以根据你的需要来进行排序。

    在excel排序中,设置主要关键字和次要关键字进行排序。计算机先根据主关键字进行排序,主关键字有重

    excel中排序有数据和序数计算(类似成绩统的名次)两类。

    数据重排:一般排序  (单击excel“数据”菜单下的“排序”命令);自定义排序,如果要求excel按照“校长”、“副校长”、“主任”和“教师”的特定顺序重排工作表数据,这类问题可以用定义排序规则的方法解决;

    数值排序:rank函数,是excel计算序数的主要工具;countif函数,countif函数可以统计某一区域中符合条件的单元格数。

    扩展资料:

    Excel在排列数据时,从字段顺序来讲,都应该按照先主后次的顺序来排列;在安排各行数据的顺序时,也需要根据不同的数据查阅需要来排列。

    最简单的排序就是按一个条件将数据进行升序或降序的排列,即让工作表中的各项数据根据某一列单元格中的数据大小进行排列;使用自定义排序让表格的内容以自定义序列的先后顺序进行排列。

    Excel中对表格进行排序怎么让下面的数据跟着一起进行排序。

    这个可以通过排序来实现的:

    1、排序:打开excel表格----数据----排序

    2、排序-----主要关键字:输入“土方明挖、石方明挖”等,2013以上版本还可根据颜色来排序的。

    展开全文
  • 快排的效率很快,但是我们很少知道如何利用它进行关键字排序,比如我想一个数组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

    展开全文
  • 题目 从键盘接受输入,每个节点所含数据...根据二叉排序树的定义可知,进行中序遍历可得到由小到大遍历结果,进行逆中序遍历即可达到要求 代码 #include &lt;stdio.h&gt; #include &lt;malloc...

    题目

    从键盘接受输入,每个节点所含数据元素均为单字符,要完成:
    建立一棵二叉链表表示方式存储的二叉排序树,并打印输出对其由大到小遍历结果。
    测试数据:输入EFHJBCAGID,符号“@”表示结束字符。

    分析

    根据二叉排序树的定义可知,对其进行中序遍历可得到由小到大遍历结果,对其进行逆中序遍历即可达到要求

    代码

    #include <stdio.h>
    #include <malloc.h>
    
    #define LEN sizeof(BSTnode)
    typedef struct node {
    	char key;
    	struct node *lchild,*rchild;
    } BSTnode,*BSTree;
    //插入结点,并对结点进行判断,确定插入左子树还是右子树 
    void InsertBST(BSTree *bst,char key) {
    	BSTree s;
    //	若在二叉排序树中不存在关键字等于key的元素则插入该元素 
    	if(*bst==NULL) {
    		s = (BSTree)malloc(LEN);
    		s->key = key;
    		s->lchild = NULL;
    		s->rchild = NULL;
    		*bst = s;
    	} else if(key<(*bst)->key)	InsertBST(&((*bst)->lchild),key);		//将s插入左子树 
    	else if(key>(*bst)->key)	InsertBST(&((*bst)->rchild),key);	   //将s插入右子树 
    }
    //从键盘输入元素的值,创建相应的二叉排序树 
    void CreateBst(BSTree *bst) {
    	char key;
    	*bst = NULL;
    	printf("请输入需要排序的字符(以@符号结尾):\n");
    	scanf("%c",&key);
    	while(key!='@') {
    		InsertBST(bst,key);
    		scanf("%c",&key);
    	}
    }
    //逆中序遍历从大到小输出二叉树结点,即先遍历右子树,然后根,最后左子树 
    void Inorder(BSTree root) {
    
    	if(root!=NULL) {
    
    //		先序遍历右子树
    		Inorder(root->rchild);
    //		访问根节点
    		printf("%c\n",root->key);
    //		先序遍历左子树
    		Inorder(root->lchild);
    	}
    }
    int main() {
    	BSTree root;
    	CreateBst(&root);
    	printf("结果序列为:\n"); 
    	Inorder(root);
    	return 0;
    
    
    }
    
    展开全文
  • 牛牛定义排序序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序序列,牛牛想知道他 最少 可以把这个数组分为几...

    问答题

    问答题1:下面叙述错误的是
    char acX[]=“abc”;
    char acY[]={‘a’,‘b’,‘c’};
    char *szX=“abc”;
    char *szY=“abc”;

    (A) acX与acY的内容可以修改
    (B) szX与szY指向同一个地址
    (C) acX占用的内存空间比acY占用的大
    (D) szX的内容修改后,szY的内容也会被更改

    提示:对于acX 和 acY 的字符串是保存在栈空间数组里,所以可以修改,szX 和 szY 指向了同一个字符串abc,所以他们指向的是一个地址,但是指针地址并不相同;acX 比 acY多一个\0 ;szX中的内容是无法修改的.

    问答题2:下列代码运行结果是?

    int a[]={1,2,3,4};
    int *b=a;
    *b+=2;
    *(b+2)=2;
    b++;
    printf("%d,%d\n",*b,*(b+2));
    

    提示:第三行和第四行是赋值,指针并没有往前走,第五行指针才走了一步.

    问答题3:在32位 cpu 上选择缺省对齐的情况下,下列程序输出什么?

    struct A {
    		unsigned a:19;
    		unsigned b:11;
    		unsigned c:4;
    		unsigned d:29;
    		char index;
    	};
    cout << sizeof(struct A) << endl;
    

    这是一个位段的问题,可以节省空间,因为其内存分配和结构体对齐是不一样的,有个缺陷就是,不可移植无法跨平台.

    在这里插入图片描述
    一共占据 4 个 32位,一个32位是4个字节,所以sizeof(A)为16字节.

    问答题4:关于c++的inline关键字,哪个说法正确?

    A 使用inline关键字的函数会被编译器在调用处展开

    错误,inline 只是用户对编译器的建议,但是编译器有权利忽略,特别是对于一些复杂函数,如果被展开,会很复杂.

    B 头文件中可以包含inline函数的声明

    在函数的定义面前加 inline 才有作用,在声明前是无效果的.所以当函数被展开前,会在文件中寻找内联函数的定义,如果没有定义则不会展开.

    C 可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数

    函数名相同的两个函数,即使在不同文件,但是他们的实现一定要是相同的.否则会有未定义的行为,所以建议把内联函数放在头文件,这样就不需要程序猿去拷贝了.也就只有一个定义了.

    D 定义在Class声明内的成员函数默认是inline函数

    定义在类声明之中的成员函数将自动地成为内联函数

    E 优先使用Class声明内定义的inline函数
    F 优先使用Class实现的内inline函数的实现

    inline 关键字没有优先级的功能

    编程题

    编程题1:排序子序列

    牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。

    牛牛有一个长度为n 的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他 最少 可以把这个数组分为几段排序子序列.

    例:数组A划分为[1,2,3] 和 [2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出:2

    输入描述:输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
    第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字

    输出描述:输出一个整数表示牛牛可以将A最少划分为多少段排序子序列

    输入 6
    1 2 3 2 2 1
    输出 :2

    题目分析:在第一次看题的时候感觉题特别矛盾,要求子序列是非递增的,那例题给出数组 1 2 3 不就是递增的吗?在这个问题上就纠结了好久,我感觉我语文水平不是很高~~!!后来才明白子序列的要求是非递增或者非递减,只要满足其中一个要求就是 子序列了。还有一个注意的就是:非递增并不等于与递减,而非递减也并不等于递增…意思就是,1 2 2 2 并不是递增,但它是非递减;用数学角度来看 a(N) =< a(N+1) 就是非递减,而递增是 a(N) < a(N+1);

    思路分析:根据题意的分析,所分割出来的数组是非递增或者非递减的,
    在这里插入图片描述
    例如这个数列:红框前面都是非递减的,这里突然递减了,所以 红框这里必须要分开,反之也是一样,如果前面的数列是非递增的,然后突然出现了比前一个小的数字就必须分开;

    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main(){
        int n;
        while(cin>>n){
            vector<int>v(n,0);
            for(int i=0;i<n;++i){
                cin>>v[i];
            }
            int count = 0;
            // 进行判断
            for(int i = 1;i<n+1;++i){
            	// 如果后者大于前面则找到一个不满足条件的
                if(v[i-1]<v[i]){
                    while(i<n && v[i-1]<=v[i]){
                        ++i;
                    }
                    // 然后加次数
                    ++count;
                }else if(v[i-1]>v[i]){
                    while(i<n && v[i]<v[i-1]){
                        ++i;
                    }
                    ++count;
                }
            }
            cout<<count<<endl;
        }
        return 0;
    }
    

    编程题2:倒置字符串

    输入用例长度不超过100;依次输出倒置之后的字符串,以空格分割:

    输入:I like beijing.
    输出:beijing. like I

    C语言版

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void reverse(char* start, char* end){
    	while (start < end){
    		char tmp = *start;
    		*start = *end;
    		*end = tmp;
    		start++;
    		end--;
    	}
    }
    
    void str_reverse(char* str){
    	int len = strlen(str);
    	reverse(str, str + len - 1);  //全部逆置
    	while (*str != '\0'){
    		char* pos = str;
    		while ((*str != ' ') && (*str != '\0')){
    			str++;
    		}
    		reverse(pos, str - 1);    //每个单词的逆置
    		if (*str != '\0'){
    			str++;
    		}
    	}
    }
    
    int main(){
    	char str[100];
    	printf("原字符串:");
    	scanf("%[^\n]", &str);
    	str_reverse(str);
    	printf("翻转后的字符串为:%s\n", str);
    
    	system("pause");
    	return 0;
    }
    

    C++版

    #include <iostream>
    #include <string>
    #include <algorithm>
    using namespace std;
    
    int main(){
        string str;
        getline(cin,str);
        // 全部逆置
        reverse(str.begin(),str.end());
        auto start = str.begin();
        // 单词逆置
        while(start < str.end()){
            auto end = start;
            while(end != str.end()&& *end != ' '){
                ++end;
            }
            reverse(start,end);
            if(end != str.end()){
                start = end+1;
            }else{
                start = end;
            }
        }
        cout<<str<<endl;
        return 0;
    }
    

    大牛版

    #include<iostream>
    #include<string>
    using namespace std;
    int main(){
    	string s1, s2;
    	//cin读取string时自动会被空格分隔开,用另一个字符串存储进行逆序输出
    	cin >> s2;
    	while (cin >> s1){
    		s2 = s1 + " " + s2;
    	}
    	cout << s2 << endl;
    	return 0;
    }
    

    python 版

    print(' '.join((input().strip().split()[::-1])))
    

    上面一行代码可以写成下面这样

    # 接收字符串,strip 的含义是去掉首位的空白字符
    str = input().strip()
    
    # 通过空格对字符串分割,并返回一个列表,
    str = str.split()
    
    # 逆置列表中的元素
    str = str[::-1]
    # 将列表转换为字符串,并输出
    print(' '.join(str))
    
    展开全文
  • 画出该二叉排序树。 (2)求在等概率下的查找成功的平均查找长度。 (3)求在等概率下的查找不成功的平均查找长度 二叉bai排序树的概念: ...二叉排序树的性质: 按中序遍历二叉排序树,所得到的中序遍历序列是一个递
  • 有序序列 1、如下图所示,在第2行单元格中输入1,选中1的位置,然后把鼠标放在格子的右下角,看到出来一个十字加号,按住往下拉,然后序列就出来了 2、在拖拽到想要填充序列单元格的末尾会出现如下图图标,点击...
  • 快速排序基本思想:通过一轮的排序将序列分割成独立的两部分,其中前一部分序列关键字(这里主要用值来表示)均比后一部分序列关键字关键字小(递增排序)或者大(递减排序)。然后继续分别两部分的序列进行...
  • 怎么记忆稳定性: 总过四大类排序:插入、选择、交换、归并(基数排序暂且不算) 比较高级一点的(时间复杂度低一点得)shell排序,堆排序,快速排序(除了归并排序)都是不稳定的...怎么记忆初始序列是否元素的比较
  • /*简单选择排序就是选出最小的放到最前边*/ #include<iostream> using namespace std; void fac(int a[],int n){...j++){ //这个循环是该算法的关键,他找到了无序序列中的最小的关键字 if(a[j]<a[k]) ...
  • 排序

    2017-06-09 10:23:40
    对关键字进行排序,就相当于对关键字对应的文件进行排序。(有点像数据库SQL中的主键。)   排序的稳定性 如果序列中有相同项,即有相同的关键字。那么就涉及到排序的稳定性的问题。   排序后,相同值的项...
  • 一、算法简介快速排序的基本步骤是... 分别两部分的数据继续进行排序(可递归进行)。 二、算法解析数据: 21, 30, 49, 23, 30, 21, 16, 9 一次排序过程为: 选择第一个数 21 为关键字,并保存为 tmp,定义两个指针
  • Volatile关键字

    2019-08-25 11:15:03
    文章目录Volatile关键字说明变量的可见性问题Java volatile可视性保证完整volatile可见性保证指令重新排序的挑战Java volatile关键字的Happens-Before保证volatile并不总是足够的什么时候使用volatile是足够的...
  • n数据序列指待排序的数据元素集合,排序是以关键字为基准进行的, n排序过程指将一个数据序列中的元素按照关键字值大小递增(或递减)的次序重新排列。 n升序(正序):按关键字从小到大排列得到的序列。 n...
  • 排序:把一个无序的元素序列按照元素的关键字递增或递减排列为有序的序列排序分为:插入排序、选择排序、交换排序和归并排序排序的元素的存储结构: 1.顺序存储 2.链式存储 3.静态存储 插入排序 插入排序的...
  • 假设含n个记录的序列为{ R1, R2, …, Rn }其相应的关键字序列为 { K1,K2, …,Kn }。经过排序确定一种排列{ Rp1≤Rp2≤…≤Rpn},使得它们的关键码满足如下递增或递减的关系 Kp1≤ Kp2 ≤…≤ Kp...
  • 思想:二叉排序树来说,其中序遍历序列为一个递增有序序列,因此,给定的二叉树进行中序遍历,如果始终能保持前一个值比后一个值小,则说明该二叉树是一棵二叉排序树。算法如下: KeyType predt=0; //predt为...
  • (11)内部排序

    2019-07-10 22:19:01
    进行数据处理时,经常需要进行查找操作 为了查得快找得准,通常要求待处理的数据按关键字大小...记录序列、关键字序列、下标序列 将有n个记录的序列按照关键字递增或者递减的关系进行排序,得到一个关键字有序的...
  • 对待排序记录的关键字两两进行比较,只要发现两个记录为逆序就进行交换,直到没有逆序的记录为止。 如果要将整个记录序列调整力递增序列,那么元素之间是递减关系即为逆序。 冒泡排序和快速排序就是典型的交换类...
  • 接下来我们来看快排的思路:首先我们在给定的序列中随机找一个基准数,别被这个基准数吓到,这个数仅仅是用来做一个参考数,快排的思路就是将小于基准数的值放到基准数的左边,将大于基准数的值放到序列的右边,举例...
  • 排序算法

    2020-11-20 15:14:01
    排序是按关键字的非递增或者非递减顺序一组记录重新进行整队的操作。 1.直接插入排序 基本思想:每次将一个待排序的记录按其关键字大小插入到前面已排好序的子序列中,直到全部记录插入完成。 直接插入算法的时间...
  • Rn}其相应的关键字序列为{K1,K2,Kn}重组记录之间的关系使记录的排列次序满足相应的关键字的递增或递减关系记录的集合也称为待排序序列若待排序序列完全存放在内存中则该排序称为内部排序若由于数据集合太大在排序...
  • 数据元素序列建立某种有序排列的过程,是把一个数据元素序列整理成按关键字递增(或递减)排列的过程。 学生成绩表 关键字 是要排序的数据元素集合中的一个域,排序是以关键字为基准进行的。 主关键字(key) ...
  • 排序基础知识排序的定义排序,就是重新排列表中的元素,使表中的元素满足按关键字递增或递减的过程。为了査找方便,通常要求计算机中的表是按关键字有序的。排序的确切定义如下:输入:n个记录R1,R2,R3…Rn,对应的...
  • 排序算法: 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减排列起来的操作。 交换排序:所谓交换,就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置,交换排序的...
  • 思路:将这n个人的第一关键字从小到大排序,如果第一关键字相等就让第二关键字从大到小排序(这里想想就能明白),排好之后就相当于在第二关键字序列中找一个最长的单调上升子序列~~~ 用O(n*n)算法会TLE, ...
  • 算法思路:已知在二叉排序树中,按照DLR的顺序遍历可以得到一个递增序列,因此按照RDL的顺序遍历,便可得到逆序序列。模仿中序递归的思想就可以做出来这个题目了。 注:可以看到连着的好几个二叉排序树的题目,都...
  • 稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序...
  • 采用最简单的选择方式,从头到尾扫描待排序列,找一个最小的记录(递增排序),和第一个记录交换位置,再从剩下的记录中继续反复这个过程,直到全部有序。 具体过程: 首先通过 n –1 次关键字比较,从 n 个...
  • 【数据结构之排序7】堆排序

    千次阅读 2013-10-21 17:27:36
    n个关键字序列Kl,K2,…,Kn称为堆,当且仅当该序列满足如下性质(简称为堆性质): 若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构,则堆实质上是满足如下性质的完全二叉树:树中任一非叶结点的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,667
精华内容 6,266
关键字:

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