c++sort
C语言算法讲解
C语言算法讲解
C语言是一种通用的高级编程语言，广泛应用于软件开发和系统编程。在C语言中，算法是实现具体功能和解决问题的关键。本文将为您介绍一
些常见的C语言算法。
排序算法是在C语言中经常用到的算法之一、在排序算法中，数据按
照特定的顺序进行排列，以便于后续的查找、插入和删除操作。常见的排
序算法有冒泡排序、选择排序、插入排序、快速排序等。其中，快速排序
是基于递归的算法实现，它可以将一个大问题划分为多个子问题进行解决，然后将子问题的解合并起来得到最终结果。下面是一个快速排序算法的示
例代码：
```c
void quickSort(int arr[], int low, int high)
int i = low;
int j = high;
int pivot = arr[(low + high) / 2];
while (i <= j)
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j)
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
if (low < j)
quickSort(arr, low, j);
if (i < high)
quickSort(arr, i, high);
```
算法也是C语言中常用的算法之一、在算法中，我们需要根据给定的条件在一组数据中查找满足条件的元素。常见的算法有线性、二分、哈希等。下面是一个二分算法的示例代码：
c语言sort函数
c语言sort函数
c语言中的sort函数是一种用于对数组进行排序的函数。它使用的是一种称为“快速排序”的算法，这种算法是一种基于比较的排序算法，具有较高的效率和性能。
sort函数的声明如下：
```c
```
参数解释：
- base: 指向要排序的数组的指针。
- nitems: 数组中的元素个数。
- size: 每个元素的字节数。
sort函数使用递归的方式进行排序，其基本思想是选择一个基准元素，将数组分为左右两部分，左边的元素小于等于基准元素，右边的元素大于等于基准元素，然后对左右两部分递归调用sort函数，直到每个部分只有一个元素为止。
在这个排序算法中，我们需要传入一个比较函数，该函数用于比较两个元素的大小。比较函数应该返回一个整数值，当第一个元素小于第二个元素时返回负数，当两个元素相等时返回0，当第一个元素大于第二个元素时返回正数。根据比较结果，sort函数将适当地调整元素的位置，以实现排序的目的。
下面是一个使用sort函数对一个整型数组进行升序排序的示例：
```c
#include <stdio.h>
#include <stdlib.h>
return (*(int*)a - *(int*)b);
int mai
int arr[] = {5, 2, 8, 6, 3, 1, 7, 9, 4};
int n = sizeof(arr) / sizeof(arr[0]);
printf("升序排序后的数组：");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
2021CSP-J2-第二轮比赛-C++试题
2021CCF非专业级软件能力认证
CSP-J/S2021第二轮认证
入门组
时间：2021年10月23日08:30∼12:00
题目名称分糖果插入排序网络连接小熊的果篮
题目类型传统型传统型传统型传统型
目录candy sort network fruit
可执行文件名candy sort network fruit
输入文件名candy.in sort.in network.in fruit.in
输出文件名candy.out sort.out network.out fruit.out
每个测试点时限 1.0秒 1.0秒 1.0秒 1.0秒
内存限制512MiB512MiB512MiB512MiB
子任务数目10252010
测试点是否等分否是是是提交源程序文件名
对于C++语言candy.cpp sort.cpp network.cpp fruit.cpp
对于C语言candy.c sort.c network.c fruit.c
对于Pascal语言candy.pas sort.pas network.pas fruit.pas 编译选项
对于C++语言‐O2‐lm
对于C语言‐O2‐lm
对于Pascal语言‐O2
.注.意.事.项（.请.仔.细.阅.读）
1.文件名（程序名和输入输出文件名）必须使用英文小写。
2.C/C++中函数main()的返回值类型必须是int，程序正常结束时的返回值必须
是0。
3.提交的程序代码文件的放置位置请参考各省的具体要求。
4.因违反以上三点而出现的错误或问题，申述时一律不予受理。
5.若无特殊说明，结果的比较方式为全文比较（过滤行末空格及文末回车）。
C语言3
以下程序中函数sort的功能是对a所指数组中的数据进行由大到小的排序。void sort(int a[],int n){int i,j,t;for(i=0;ifor(j=i+1;jif(a[i]}main(){int aa[10]={1,2,3,4,5,6,7,8,9,10},i;sort(&aa[3],5);for(i=0;i<10;i++) printf("%d,",aa[i]);printf("\n");}程序运行后的输出结果是____A__。A . 1,2,3,8,7,6,5,4,9,10,B . 10,9,8,7,6,5,4,3,2,1,C . 1,2,3,4,5,6,7,8,9,10,D . 1,2,10,9,8,7,6,5,4,3,本题的考查点是对数组的操作。本题并不是对数组的所有元素进行排序，而是对从a[3]开始往后的4个元素进行排序。故本题答案为A。设x、y、t均为int型变量，则执行语句:x=y=3;t=++x||++y;后，y的值为___C___。A.1 B.2 C.3 D.4C语言中做逻辑或运算时，自左向右判断各个参加或运算的表达式，一旦运算到某式的值为非零时，表明整个表达式定为真，余下的语句则不再进行运算。本题中，++x的值为真，则++y并没有进行运算，所以y值不变。本题答案为C。有以下程序typedef struct{int b,p;}A;void f(A c) /* 注意：c是结构变量名 */{ int j;c.b+=1; c.p+=2;}main(){ int i;A a={1,2};f(a);printf("%d,%d\n",a.b,a.p);}程序运行后的输出结果是___A___。A.1,2 B.2,4 C.1,4 D.2,3本题考查的是变量作为函数的参数和函数的调用。C语言规定，在函数调用时变量作为参数传递是进行值传递，在函数体中对形参变量的修改不会影响对应的实参变量。本题定义了一个函数f()，用变量作为形参，在main()函数中调用了一次f()函数，形参进行计算：c.b+=1=1+1=2，c.p+=2=2+2=4，由于变量作为参数进行传递不会影响到实参的的值，所以a.b，a.p依旧是原来的值，即：1,2。故本题答案选A。有以下程序main(){ int i=1,j=1,k=2;if((j++||k++)&&i++) printf("%d,%d,%d\n",i,j,k);}执行后输出的结果是__A____。A.2,2,2 B.2,2,1 C.1,1,2 D.2,2,3本题的考查点是逻辑表达式。形如(表达式 1)&&(表达式 2)&&...的逻辑表达式在计算时，先计算表达式1，如果其值是逻辑"真"或非0，就接着计算表达式2，直至计算到第一个为逻辑"假"的表达式时，就可判定整个逻辑表达式为逻辑"假"，其后的表达式将不被计算。形如(表达式 1)||(表达式 2)||...的逻辑表达式在计算时，先计算表达式1，如果其值是逻辑"假"或0，就接着计算表达式2，直到计算到第一个为逻辑"真"的表达式时，就可判定整个逻辑表达式为逻辑"真"，其后的表达式将不被计算。根据以上的描述可知，本题中j++值为2，为真，k++不被计算，然后计算i++为2，所以i=2,j=2,k=2。故本题答案为A。下面各语句行中，能正确进行给字符串赋
c++ sort函数用法
c++ sort函数用法
sort函数是STL库里的一个算法函数，用来对数组、容器中的元素进行排序。本文将介绍sort函数的用法及注意点。
sort有多种重载形式，这里介绍两种最常用的：
1）sort(first, last)
用来对[first, last)区间内的元素进行排序，其中[first, last)表示左闭右开区间的迭代器。
cmp是一个可调用对象，用来比较两个元素的大小。cmp(a, b)返回true表示a应该排在b的前面，如果cmp(a,b)返回false，则a排在b后面。
2. sort函数的特点
sort函数是一个原地（in-place）排序算法，不需要额外的空间开销；时间复杂度为O(nlogn)。
sort排序是一种稳定排序，即排序后相等元素的相对位置不改变。比如，如果a和b 相等，在排序前a在b前面，则排序后a仍在b前面。
sort函数可以用于排序数组、容器等数据结构。以下是sort的使用范例：
（1）对数组进行排序
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
（3）自定义比较函数
sort函数默认按照升序进行排序，但我们也可以根据自己的需要定义比较函数。
举例来说，如果我们要按照字符串长度降序排列：
bool cmp(const string& s1, const string& s2) //自定义比较函数
{
return s1.size() > s2.size(); //按照字符串长度由大到小排序
统计文件中出现的单词次数
统计⽂件中出现的单词次数
这⾥以kevin.txt⽂件内容（单词由⼀个或多个空格字符分隔）为例进⾏简单说明
[root@centos6-test06 ~]# cat /root/kevin.txt
the world kevin is the
is world grace the kevin
art the kevin the is kevin
统计kevin.txt⽂件中出现的单词次数
第⼀种⽅法：结合grep和awk编写shell脚本
脚本内容如下：
[root@centos6-test06 ~]# cat count.sh
#! /bin/bash
# solution 1
if [ $# -eq 0 ]
then
echo "Usage:$0 args error"
exit 0
fi
if [ $# -ge 2 ]
then
echo "analyse the first file $1"
fi
#get the first file
filename=$1
grep -E -o "\b[[:alpha:]]+\b" $filename | awk ' { count[$0]++ }
END{printf("%-20s%s\n","Word","Count");
for(word in count)
{printf("%-20s%s\n",word,count[word])}
}'
=======================================================================
脚本参数说明：
c语言数组数据比较算法
c语言数组数据比较算法
概述
在C语言中，数组是一种常见的数据结构，用于存储一系列相同数据类型的元素。在实际编程中，经常需要对数组进行比较操作，以找到数组中的最大值、最小值、排序等。本文将详细介绍C语言中常用的数组数据比较算法。
一、数组元素比较
1.1 逐个元素比较法
逐个元素比较法是最简单的数组比较方法，其基本思想是将两个数组中的对应元素逐个进行比较，找出差异或相同之处。具体步骤如下：
1.声明两个数组a和b；
2.逐个比较数组a和数组b的对应元素；
3.如果找到不同的元素，输出差异；
4.如果所有对应元素都相同，则输出相同。
1.2 利用循环遍历比较法
逐个元素比较法虽然简单，但需要逐个比较所有元素，效率较低。利用循环遍历比较法可以通过循环结构实现更高效的数组比较。具体步骤如下： 1. 声明两个数组a和b； 2. 使用循环结构遍历数组a和数组b的对应元素； 3. 逐个比较数组a 和数组b的对应元素； 4. 如果找到不同的元素，输出差异； 5. 如果所有对应元素都相同，则输出相同。
二、数组排序算法
2.1 冒泡排序法
冒泡排序是一种简单的排序算法，其基本思想是多次遍历数组，每次遍历都将相邻的两个元素进行比较并交换位置，从而实现将最大（或最小）元素逐渐移到数组的末尾（或开头）。具体步骤如下： 1. 声明一个数组a； 2. 外层循环遍历数组元
素，从第一个元素到倒数第二个元素； 3. 内层循环遍历数组元素，从第一个元素到当前外层循环变量所指示的位置； 4. 逐个比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置； 5. 继续下一轮的遍历，直到所有元素排序完成。
c语言数组降序排列
c语言数组降序排列
C语言是一种广泛使用的编程语言，拥有强大的数组功能。今天，让我们来看看如何使用C语言将数组按照降序排列。
首先，我们需要定义一个数组。这个数组可以包含任意类型的元素，例如整数、浮点数、字符等等。假设我们定义了一个int类型的数组，名为numbers：
```
int numbers[10] = {2, 4, 1, 5, 3, 9, 8, 7, 6, 0};
```
这个数组包含了10个整数，我们需要将它们按照降序排列。实现这个功能的一种简单方法是使用冒泡排序算法。
冒泡排序算法的基本思想是比较相邻的元素，如果它们的顺序不正确就交换它们的位置，直到整个数组都被扫描过。实际上，这个算法对于较小的数组来说是非常有效的，但对于大数组来说则效率较低。
下面是使用C语言实现冒泡排序算法的代码：
```
void bubble_sort(int arr[], int len) {
int i, j, temp;
for (i = 0; i < len - 1; i++) {
for (j = 0; j < len - i - 1; j++) {
if (arr[j] < arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
```
这个函数接受一个数组和它的长度作为参数，然后对数组进行升序排列。如果我们要进行降序排列，只需要将如下语句：
```
if (arr[j] < arr[j + 1]) {
```
C语言 课后作业题
C语言作业题
【输出形式】用户在下一行显示输出结果
【样例输入】3.47
【样例输出】3
【样例说明】与输入值3.47接近的整数为3和4，3.47比3.5小，舍掉小数部分，结果为3。
【评分标准】结果完全正确得20分，每个测试点4分。提交程序名为：c0104.c。
当前编程题：第一次作业--- 计算空格换行个数
5. 【问题描述】
编写一程序，分别计算所输入的字符串中空格，换行符的个数。
【输入形式】
输入可以是键盘上的任意字符。
【输出形式】
分别输出空格，换行符的个数，输出的结果一行显示，数字之间以空格格开。
【输入样例】
bb ss pp=
fz
【输出样例】
2 1
【样例说明】
字符b与s之间有一个空格，s与p之间有一个空格，p与f之间有一个换行。
【评分标准】
结果完全正确得20分，每个测试点4分。提交程序名为：c0105.c。
当前编程题：第一次作业--- 整数组合(选做题)
6. 【问题描述】
假设unsigned short类型占16位，x、y、z都是short类型。编写一程序，从键盘输入x,y 的值（十进制形式），然后将x的高8位作为z的高8位，y的高8位作为z的低8位，最后输出z的值（十进制形式）。
【输入形式】
以十进制形式输入x和y的值，以空格隔开。
【输出形式】
以十进制形式在新的一行上输出z值。
【输入样例】
840 2177
【输出样例】
776
【样例说明】
840的二进制形式为：0000 0011 0100 1000
2177的二进制形式为：0000 1000 1000 0001
将840的高8位作为结果的高8位，2177的高8位作为结果的低8位，
csort函数
csort函数
C语言中的sort(函数是一个非常重要的函数，它可以用来对数组进行排序操作。sort(函数是一个标准库函数，可以在C语言的stdlib.h头文件中找到。
sort(函数的原型如下：
其中，参数说明如下：
- base：指向待排序数组的起始地址。
- nitems：数组中元素的个数。
- size：每个元素的大小，单位是字节。
sort(函数使用的排序算法是快速排序（Quick Sort）。它是一种高效的排序算法，平均时间复杂度为O(nlogn)，其中n是待排序元素的个数。
使用sort(函数进行排序需要编写一个用来比较两个元素的函数。比较函数的原型如下：
其中，参数说明如下：
-a：指向第一个元素的指针。
-b：指向第二个元素的指针。
比较函数返回一个整数，表示a和b的大小关系：
-如果返回值小于0，表示a小于b。
-如果返回值等于0，表示a等于b。
-如果返回值大于0，表示a大于b。
下面是一个示例代码，演示了如何使用sort(函数对整型数组进行递增排序：
```C
#include <stdio.h>
#include <stdlib.h>
int num1 = *(int*)a;
int num2 = *(int*)b;
if (num1 < num2)
return -1;
} else if (num1 > num2)
return 1;
}
return 0;
int mai
int arr[] = {4, 2, 8, 6, 1, 5, 9, 3, 7};
int n = sizeof(arr) / sizeof(arr[0]);
(最新整理)C语言常见英语词汇
C语言常见英语词汇
编辑整理：
尊敬的读者朋友们：
这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（C语言常见英语词汇）的内容能够给您的工作和学习带来便利。同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。
本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为C语言常见英语词汇的全部内容。
运算符与表达式：
1.constant 常量
2. variable 变量
3. identify 标识符
4. keywords 关键字
5。 sign 符号
6。 operator 运算符
7. statement语句
8. syntax 语法
9。 expression 表达式
10。 initialition 初始化
11。 number format 数据格式
12 declaration 说明
13。 type conversion 类型转换
14。define 、definition 定义
条件语句：
1.select 选择
2. expression 表达式
3. logical expression 逻辑表达式
4. Relational expression 关系表达式5。priority优先
6. operation运算
7.structure 结构
循环语句：
1。circle 循环
2. condition 条件
3. variant 变量
4. process过程
5。priority优先
C#中的List.Sort（）--集合排序方法全面解析
C#中的List.Sort（）--集合排序⽅法全⾯解析
在C#中，List.Sort() 不仅为我们提供了默认的排序⽅法，还为我们提供了4种⾃定义排序的⽅法，通过默认排序⽅法，我们⽆需重写任何Sort()⽅法的实现代码，就能对单参数类型的List数据进⾏单⼀规则的排序，如果通过对这些⽅法进⾏改进我们可以轻松做到对多参数、多规则的复杂排序。
下⾯是C#⾃定义排序的4种⽅法：
List<T>.Sort();
List<T>.Sort(IComparer<T> Comparer);
List<T>.Sort(int index, int count, IComparer<T> Comparer);
List<T>.Sort(Comparison<T> comparison);
实现⽬标
假设存在⼀个People类，包含Name、Age属性，在客户端中创建List保存多个实例，希望对List中的内容根据Name和Age参数进⾏排序，排序规则为，先按姓名升序排序，如果姓名相同再按年龄的升序排序：
class People
{
public People(string name, int age) { Name = name; Age = age; }
public string Name { get; set; } //姓名
public int Age { get; set; } //年龄
}
// 客户端
class Client
{
static void Main(string[] args)
简单选择排序c语言代码
简单选择排序c语言代码
简单选择排序c语言代码
简单选择排序是一种基础的排序算法，它的思想是找到未排序部分中最小元素，然后将其放到已排序部分的末尾。重复这个过程，直到所有元素都被排好序。下面是简单选择排序的C语言代码实现。
代码实现
```c
void select_sort(int a[], int n)
{
int i, j, min, tmp;
for (i = 0; i < n - 1; i++) {
min = i;
for (j = i + 1; j < n; j++) {
if (a[j] < a[min]) {
min = j;
}
}
if (min != i) {
tmp = a[i];
a[i] = a[min];
a[min] = tmp;
}
}
}
```
代码解析
这段代码中，我们定义了一个名为select_sort的函数来实现简单选择排序。函数有两个参数：一个整型数组a和数组长度n。
在函数体内，我们使用了两个for循环嵌套来实现对数组a的遍历和
比较。外层循环从0开始，一直遍历到n-2。内层循环从外层循环当
前位置+1开始，一直遍历到数组末尾。
在内层循环中，我们使用if语句来判断当前位置是否为最小值。如果是，则将min变量更新为当前位置；否则，不做任何操作。
在外层循环中，我们使用if语句来判断min是否等于i。如果不相等，则说明最小值在未排序部分中，需要将其与已排序部分的末尾交换位置。交换操作使用了一个临时变量tmp来存储已排序部分的末尾元素。
时间复杂度
简单选择排序的时间复杂度为O(n^2)，其中n为数组长度。因为每次需要遍历未排序部分中的所有元素，找到最小值并进行交换操作，所以时间复杂度是n*(n-1)/2，即O(n^2)。
c语言中sort的用法详解
c语言中sort的用法详解
c语言中sort的用法的用法sort是STL中提供的算法，头文件为#include以及using namespace std; 函数原型如下：?12345template void sort ( RandomAccessIterator first, RandomAccessIterator last );template void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );使用第一个版本是对[first,last)进行升序排序，默认操作符为""则为降序排序，分别对int、float、char以及结构体排序例子如下:?12345678910111213141516171819202122232425262728293031323 33435363738394041424344454647484950515253545556575859606162 636465666768697071#include#include#includeusing namespace std;struct product{char name[16];float price;};int array_int[5]={4,1,2,5,3};char array_char[5]={'a','c','b','e','d'};double array_double[5]={1.2,2.3,5.2,4.6,3.5};//结构比较函数（按照结构中的浮点数值进行排序）bool compare_struct_float(const product &a,const product &b){return a.price如果每次都自己写个冒泡之类的O(n^2)排序，不但程序容易超时，而且浪费宝贵的比赛时间，还很有可能写错。
c语言常用算法
c语言常用算法
一、前言
C语言是一种高效、快速的编程语言，被广泛应用于各种领域。在C 语言中，算法是非常重要的部分，因为它们能够帮助我们解决许多实际问题。本文将介绍C语言中常用的算法。
二、排序算法
1.冒泡排序
冒泡排序是一种简单的排序算法，它通过不断交换相邻两个元素的位置来将最大的元素放到最后。具体实现如下：
```
void bubble_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
}
}
}
}
```
2.选择排序
选择排序也是一种简单的排序算法，它通过不断选择最小元素并放到前面来完成排序。具体实现如下：
```
void selection_sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int min_index = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
int temp = arr[i];
arr[i] = arr[min_index];
}
}
```
3.插入排序
插入排序是一种简单的排序算法，它通过将元素逐个插入到已排好序的序列中来完成排序。具体实现如下：
c最快排序方法
c最快排序方法
以下是C语言中几种常见的排序方法及其时间复杂度：
1. 冒泡排序：时间复杂度为O(n^2)，是一种稳定的排序算法。
2. 快速排序：时间复杂度在最坏情况下为O(n^2)，平均情况下为
O(nlogn)，是一种不稳定的排序算法。
3. 归并排序：时间复杂度为O(nlogn)，是一种稳定的排序算法。
4. 堆排序：时间复杂度为O(nlogn)，是一种不稳定的排序算法。
5. 插入排序：时间复杂度为O(n^2)，是一种稳定的排序算法。
请注意，以上时间复杂度只是理论上的，实际应用中，排序算法的效率还会受到其他因素的影响，如数据分布、内存使用等因素。因此，在实际应用中，需要根据具体情况选择合适的排序算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
sort()函数是C++中的排序函数其头文件为：#include
1、sort()
sort 对给定区间所有元素进行排序
stable_sort 对给定区间所有元素进行稳定排序
partial_sort 对给定区间所有元素部分排序
partial_sort_copy 对给定区间复制并排序
nth_element 找出给定区间的某个位置对应的元素
is_sorted 判断一个区间是否已经排好序
partition 使得符合某个条件的元素放在前面
stable_partition 相对稳定的使得符合某个条件的元素放在前面
语法描述为：
（1）sort(begin,end)，表示一个范围，例如：
#include "stdafx.h"
#include
#include
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
int a[10]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<10;i++)
cout< cout< sort(a,a+5); for(i=0;i<10;i++) cout< system("pause"); return 0; 输出结果将是把数组a按升序排序，说到这里可能就有人会问怎么样用它降序排列呢？这就是下一个讨论的内容。 （2）sort(begin,end,compare) 一种是自己编写一个比较函数来实现，接着调用三个参数的sort： sort(begin,end,compare)就成了。 对于list容器，这个方法也适用，把compare作为sort的参数就可以了，即：sort(compare)。 1）自己编写compare函数： bool compare(int a,int b) { return a } int _tmain(int argc, _TCHAR* argv[]) { int a[10]={2,4,1,23,5,76,0,43,24,65},i; for(i=0;i<10;i++) cout< cout< sort(a,a+10,compare); for(i=0;i<10;i++) cout< system("pause"); return 0; } 2）更进一步，让这种操作更加能适应变化。也就是说，能给比较函数一个参数，用来指示是按升序还是按降序排,这回轮到函数对象出场了。 为了描述方便，我先定义一个枚举类型EnumComp用来表示升序和降序。很简单：enum Enumcomp{ASC,DESC}; class compare { private: Enumcomp comp; public: compare(Enumcomp c):comp(c) {}; bool operator () (int num1,int num2) { switch(comp) { case ASC: return num1 case DESC: return num1>num2; } } }; int main() { int a[20]={2,4,1,23,5,76,0,43,24,65},i; for(i=0;i<10;i++) cout< cout< sort(a,a+20,compare(DESC)); for(i=0;i<10;i++) cout< return 0; } 3)其实对于这么简单的任务（类型支持“<”、“>”等比较运算符），完全没必要自己写一个类出来。标准库里已经有现成的了，就在functional里，include进来就行了。functional提供了一堆基于模板的比较函数对象。它们是（看名字就知道意思了）：equal_to 升序：sort(begin,end,less 降序：sort(begin,end,greater #include "stdafx.h" #include #include #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) { int a[10]={2,4,1,23,5,76,0,43,24,65},i; for(i=0;i<10;i++) cout< cout< sort(a,a+10,greater for(i=0;i<10;i++) cout< system("pause"); return 0; }