历年笔试题目笔记

1. 允许程序直接访问内存，免去了各种抽象接口所造成的的额外开销。
2. 使用指针特性，允许直接操作内存地址，可以直接访问内存中的数据，而无需进行额外的拷贝操作。
3. 使用内联函数，允许编译器将部分函数代码直接插入到目标函数中，减少了函数调用的开销。
4. 允许编译器对代码进行优化，使用重排、循环展开、函数内联等方式提高了生成的机器代码的执行效率。
5. 提供低级语言特性，C语言提供了例如位操作、嵌入汇编等方式直接操作硬件，减少了代码的层次，提高了效率。
6. 精简了标准库，减少了生成的机器代码的大小，提高了执行效率。
7. 提供了宏功能(Macro)，允许用户使用宏函数等方法减少了函数调用，将部分运算(例如sizeof)直接在预处理期完成。

做P267的2015年第4题。

下列代码：

for(int i = 0; nums[i] != temp; i++)
{
    printf("%d", i);
}
复制

是什么程序结构？使用显示结构语言该如何表示？并标出条件跳转和强制跳转。

答案：
在黄迪明的《C语言程序设计》一书中，程序被划分为三种基本结构：

1. 顺序结构
2. 分支结构
3. 循环结构

因此该程序的结构为循环结构，当 nums[i] != temp 时执行循环，当 nums[i] == temp 时结束循环。

其流程图为：

显示表示为：

int i = 0;
L1:
if(nums[i] != temp)
    goto L2;        // 条件跳转
else
    goto L3;        // 条件跳转
L2:

printf("%d", i);

goto L1;            // 强制跳转

L3:
复制

假设 arr 为整形数组， num 和 item 为整形变量， 数组元素个数 。需要查找 item 是否在数组中，如果程序片段为：

for(num = N; arr[num] != item; num--)
	printf("%d", num);
复制

可能会引发什么异常？

答：

1. 该整形变量 num 从 元素个数 开始递减，直到 arr[num] == item 。
2. 其可能触发数组越界访问异常，因为若 arr 中不存在 item ，则 num 会不停递减，直到递减到 num = -1 时进行 arr[num] != item 表达式判断时触发异常。

给出两个字符串，判断第一个字符串中有几个内容等于第二个字符串的子串。
例如给定字符串A ababaaabbb ，字符串B ab 。

1. 窗口内存对比法(使用 memcmp 函数)

int calculate_substr(char *A, char *B)
{
    int len_A = strlen(A);   //计算字符串A、B的长度
    int len_B = strlen(B);
    int substr_num = 0;      //A的子串数量
    if(lenA < len_B)
        return substr_num;
    for(int i = 0; i < len_A - len_B + 1; i++)
    {
        if(!memcmp(&A[i], B, len_B)) //指针也可以使用字符串引索
            substr_num++;
    }
    return substr_num;
}
复制

2. 使用子字符串搜索(使用 strstr 函数)，如果需要简化边界条件则会增加搜索次数(如下)

int calculate_substr(char *A, char *B)
{
	int *start_pos = A;       //字符串A的起始搜索地址
    int len_B = strlen(B);    //计算字符串B的长度
    int substr_num = 0;       //A的子串数量
	while(start_pos = strstr(start_pos, B))
	{
		substr_num ++;
		start_pos ++;         //实际上可以加2，但是会使边界条件复杂化
	}
    return substr_num;
}
复制

给出一个英语文件作为输入，统计有多少不同单次还有每个单次的数量，要求使用结构体数组完成，可以用 strcmp 函数判断字符串是否已经存在。

数组法：

#define MAX_WORD_LEN  32
#define MAX_WORD_NUM  1024

#include <string.h>
#include <stdio.h>

typedef struct {
    char word[MAX_WORD_LEN];
    int show_times;
} word_t;

word_t library[MAX_WORD_NUM] = { 0 };

int search_word(char word[])
{
    for(int i = 0; i < MAX_WORD_NUM; i++)
    {
        if(library[i].show_times == 0)
        {
            return -1;
        } else if(!strcmp(library[i].word, word))
        {
            return i;
        }
    }
}

int count_word(char word[])
{
    int word_id = search_word(word);
    if(word_id > 0)
    {
        library[word_id].show_times++;
        return word_id;
    } else {
        for(int i = 0; i < MAX_WORD_NUM; i++)
        {
            if(library[i].show_times == 0)
            {
                strcpy(library[i], word);
                library[i].show_times = 1;
                return i;
            }
        }
        return -1
    }
}

int process_file(char path[])
{
    FILE *f = fopen(path, "r");
    if(f == NULL)
    {
        printf("open file: %s failed.\r\n", path);
        return -1;
    } else {
        char word[MAX_WORD_LEN] = { 0 };
        while(fgets(word, MAX_WORD_LEN, f))  //fgets函数当遇到换行符时会自动分割并返回word指针，遇到EOF时会返回NULL。
        {
            count_word(word);
            memset(word, 0x00, MAX_WORD_LEN);
        }
        return 0;
    }
}

// C语言的命令行参数中，第一个参数通常为可执行文件的路径，第二个参数开始才是命令行传入的参数
int main(int argc, char argv[])
{
    // load English file.
    if(!process_file(argv[1]))
        return -1;
    
    // A demostration of search a word "hello"
    char test_word[] = "hello";
    int index = search_word(test_word);
    if(index >= 0)
        printf("The show times of word %s is %d\r\n", test_word, library[index]);
    else
        printf("The show times of word %s is 0", test_word);
    return 0;
}
复制

结构体中存有学生姓名、学号、分数三个信息。要求：

1. 用冒泡排序将成绩从低到高排序
2. 用折半查找找到分数为 87 的所有学生的信息

#include <stdio.h>

typedef struct{
    char name[16];
    int id;
    int score;
} student_t;

// 冒泡排序所用比较函数，值为学生a的分数减去学生b的分数
int compare(const student_t *a, const student_t *b)
{
    return a->score - b->score;
}

// 冒泡排序的实现，传入student_t数组和数组大小n，以及比较函数的指针
void bubble_sort(student_t s[], int n, int *cmp(const void* a, const void* b))
{
    // 执行n-1趟
    for(int trips = 0; trips < n - 1, trips++)
    {
        // 将元素s[i]和元素s[i+1]做对比，i从0到n - trips - 1
        for(int i = 0; i < n - trips - 1; i++)
        {
            if(cmp(&s[i], &s[i+1]) > 0)
            {
                student_t temp = s[i];   // 可以直接使用swap(&s[i], &s[i+1])
                s[i] = s[i+1];
                s[i+1] = temp;
            }
        }
    }
}

// 二分查找，返回值为score的学生的index。但是只能查找到一个为score的学生
int binary_search(student_t s[], int n, int score)
{
    int l_index = 0, r_index = n - 1;
    while(l_index <= r_index)
    {
        int mid = (l_index + r_index) / 2;
        if(s[mid].score == score)
            return mid;
        else if(s[mid].score > score)
            l_index = mid + 1;
        else
            r_index = mid - 1;
    }
    return -1;
}

// 查找所有分数为score的学生，假设caller负责调用free函数
student_t *search_score(student_t s[], int n, int score, int* result_nums)
{
    int index = binary_search(s, n, socre);
    int l_index = index, r_index = index;
    *result_nums = 0;
    if(index < 0)
        return NULL;
    while(l_index > 0 && s[l_index - 1].score == score)
        l_index --;
    while(r_index < n - 1 && s[r_index + 1].score == score)
        r_index ++;
    *result_nums = r_index - l_index + 1;
    student_t *result = malloc(sizeof(student_t) * (*result_nums));
    memcpy(result, &s[l_index], sizeof(student_t) * (*result_nums));
    return result;
}

int main()
{
    int n = 100; // 给定学生数量
    int score = 89; // 目标分数
    // 假设题中所给学生数据由create_student_info提供。
    student_t *s_list = create_student_info(n);
    bubble_sort(s_list, n, compare);
	
    int result_nums = 0;
    student_t *result = search_score(s_list, n, score, &result_nums);
    for(int i = 0; i < result_nums; i++)
    {
        printf("name: %s, id: %d, score: %d", 
            (result + i) -> name, (result + i) -> id, (result + i) -> score);
    }
    return 0;
}
复制

1. 创建一个编号为 1 到 10 的链表
2. 取m次范围为1-10的随机数，并：
   1. 将编号为m的链表移动到最前端

#include <stdio.h>
#include <time.h>

typedef struct node {
    int id;
    struct node* next;
} node_t;

int get_rand()
{
    return rand()%10;
}

// 传入链表和目标id；使用含头结点的链表
void move_node_to_head(node_t* nodelist, int id)
{
    node_t* pre = NULL;
    node_t* cur = *nodelist;

    // find target
    while(cur -> next && cur -> id != id)
    {
        pre = cur;
        cur = cur -> next;
    }

    // move node to head;
    if(cur -> id == id)
    {
        pre -> next = cur -> next;
        cur -> next = nodelist -> next;
        nodelist -> next = cur;
        return;
    } else {
        // 移动失败，在合法调用时也不存在该情况。
        return;
    }
}

node_t* create_list()
{
    node_t* head = calloc(sizeof(node_t), 1);
    node_t* curr = head;
    for(int i = 1; i <= 10; i++)
    {
        curr -> next = calloc(sizeof(node_t), 1);
        curr = curr -> next;
        curr -> id = i;
    }
    return head;
}

// 递归free链表
void destory_list(node_t* list)
{
    if(list != NULL)
    {
        destory_list(list -> next);
        free(list);
    }
}

int main()
{
    //设置随机数种子
    srand(time());
	
    int m = abs(rand());
	
    node_t* list = create_list();
	
    for(int i = 0; i < m; i++)
    {
        move_node_to_head(list, get_rand());
    }
	
    destory_list(list);
	
    return 0;
}
复制

给定5个数，求这5个数的最小公倍数。

// 辗转相除法求最大公倍数，要求a 必须大于等于 b
int gcd(int a, int b)
{
    int mod = a % b;
    if(mod)
        return gcd(b, mod);
    else
        return b;
}

// 求两个数的最小公倍数
int lcm(int a, int b)
{
    if(a > b)
        return b * gcd(a, b);
    else
        return a * gcd(b, a);
}

// 求数组的最小公倍数，要求n>=2。
int LCM(int array[], int n)
{
    if(n < 2)
        return -1;

    // 先求前两个数的lcm
    int current_lcm = lcm(array[0], array[1]);

    // 求第三个数开始的lcm
    for(int i = 2; i < n; i++)
    {
        current_lcm = lcm(array[i], current_lcm);
    }
    return current_lcm;
}
复制

在字符串 a 的指定位置 pos 插入字符串 b 。

#include <string.h>

int insert_str(char a[], const char b[], int pos)
{
    // 先计算字符串a、b的长度
    int a_len = strlen(a);
    int b_len = strlen(b);

    // 将a字符串的pos位后的字符串后移，由于目标内存和源内存可能存在内存区域重合，故只可使用 `memmove` 而不可使用 `strcpy` 。
    memmove(a + pos + strlen(b) * sizeof(char), a + pos, strlen(b) * sizeof(char));
    // 将字符串b拷贝到字符串a的指定位置
    memcpy(b, a + pos, strlen(b) * sizeof(char));
    return 0;
}
复制

给定三个函数，回答：

1. 函数的功能
2. 函数的时间复杂度
3. 该方法存在的问题

函数1：

for(int i = 0; i < 100; i++)
{
	a[i] = rand() % 100 + 1;
	for(j = 0; j < i; j++)
		if(a[i] == a[j])
			i--;
}
复制

函数2：

int tag[100] = { 0 };
for(int i = 0; i < 100; i++)
{
	a[i] = rand() % 100 + 1;
	if(tag[a[i]] == 1)
		i--;
	else
		tag[a[i]] = 1;
}
复制

函数3：

for(int i = 0; i < n; i++)
{
	a[i] = i + 1;
	for(int j = 0; j < 100; j++)
		swap(&a[rand()%100], &a[rand()%100]);
}
复制

函数1：

1. 该函数的功能是向数组 a[100] 中输出值域为 [1, 100] 的随机数，并保证数组中没有重复元素。
2. 该函数生成第 个元素所需要进行的元素对比次数为 次，故时间复杂度为
3. 该函数所存在的问题是每进行一次生成都需要和前面所有已生成元素进行对比，效率较低。

函数2：

1. 该函数的功能与函数1相同。
2. 该函数生成第 个元素所需要生成随机数的次数的数学期望值为 故生成 个随机数的生成次数数学期望约为 次，故时间复杂度为 。
3. 该函数所存在的问题是为避免生成重复的随机数多调用了 次随机数生成函数，但最后生成的数又都只是 之间的整数的集合，只保留了每个整数对应的随机位置信息，浪费了每个整数对应的数值信息。

函数3：

1. 该函数的功能与函数1相同
2. 该函数只对数组中 个元素进行了 次交换，时间复杂度为 。
3. 该函数存在的问题是中间可能存在大量未被交换的元素，其元素值等于元素所在的位置。简要数学证明如下：
   1. 对于每个特定元素，每次交换被选中的概率为(减去两次选中的元素都是自己的情况)：
   2. 共计进行100次交换，则该元素从始至终未被有效操作的概率为
   3. 则在100次交换后，该数列中未被操作过的元素数量的期望值为

改错题，资料没给题干，故手写一遍。
先排序，再找中位数。
注意：

1. 返回值应为float
2. 当总大小为偶数时应返回两个数的均值
3. 记得处理 n = 0 的情况。

int compare(int *a, int *b)
    return a - b;

float calc_mid_num(int array[], int n)
{
    qsort(array, sizeof(int), n, compare);
    if(n == 0)
        return -1;
    if(n % 2)
        return array[n/2];
    else
        return (array[n/2] + array[(n/2) - 1]);
}
复制

给定结构体 student ，其中存有 score 、 age 、 height ，现在对其按照如下规则进行升序排序：

1. 先比较 score 。
2. 当 score 相等时比较 age 。
3. 当 score 和 age 均相等时比较 height 。

typedef struct student {
    int score;
    int age;
    int height;
} student_t;

int compare(student_t *a, student_t *b)
{
    if(a -> score != b -> score)
    {
        return a -> score - b -> score;
    } else if(a -> age != b -> age)
    {
        return a -> age - b -> age;
    } else {
        return a -> height - b -> height;
    }
}

int bubble_sort(student_t s[], int n, int (*cmp)(student_t *a, student_t *b))
{
    // 比较n-1趟
    for(int trips = 0; trips < n - 1; trips ++)
    {
        // 进行该趟的冒泡排序，将第i号引索元素和其后元素做对比，排序区间为 i \in [0, n - trips - 2]
        for(int i = 0; i < n - trips - 1; i ++)
        {
            if(cmp(&s[i], &s[i + 1]))
                swap(&s[i], &s[i + 1])
        }
    }
    return 0;
}

int sort_student(student_t s[], int n)
{
    return bubble_sort(s, n, compare);
}
复制

// 删除字符串str的第pos位开始的长度为len的子串，pos从0计数，删除内容包含pos位
char * del_substr(char *str, int pos, int len)
{
    int str_len = strlen(str);
    if(pos > str_len)
    {
        return str;
    } else if(pos + len >= str_len) {
        memset(str, 0x00, str_len - pos);
        return str;
    } else {
        memset(str, 0x00, len);
        memmove(str + pos, str + pos + len, str_len - pos - len);
        memset(str + str_len - len, 0x00, len);
        return str;
    }
}
复制

LeetCode 92
给定链表L，输入m，n。实现从链表的第m个节点到低n个节点逆序。

挺难，考虑类数组法。

typedef struct node
{
    int id;
    struct node* next;
} node_t;

// 无头结点的链表转置
node_t* reverse(node_t * const list)
{
    node_t *prev = NULL;
    node_t *curr = list;
    while(curr) {
        // 暂存下一节点
        node_t *next = curr -> next;
        // 将链表指针方向转置
        curr -> next = prev;
        // 移动窗口
        prev = curr;
        curr = next;
    }
    return prev;
}

// 翻转链表list的第start节点到第end节点的部分，使用带头结点的链表。
// start和end从1开始计算。
node_t* partical_reverse(node_t* const list, int start, int end)
{
    // 假设传入链表以及对应的start、end如下：
    // | 1 | -> ··· -> | a | -> | b | -> ··· -> | c | -> | d | -> ··· -> | e | -> NULL
    //   ↑                        ↑               ↑
    // list                     start            end
    // 则定义如下关系的指针：
    // | 1 | -> ··· -> | a | -> | b | -> ··· -> | c | -> | d | -> ··· -> | e | -> NULL
    //   ↑               ↑        ↑               ↑        ↑
    // list            prev     front            rear    after
    node_t *curr = list, *prev = NULL, *front = NULL, *rear = NULL, *after = NULL;

    // 随后获取上述指针的值，curr当作遍历指针
    int i = 0;
    while(curr)
    {
        // index从1开始
        i++;
        if(i == start - 1)
            prev = curr;
        if(i == start)
            front = curr;
        if(i == end)
            rear = curr;
        if(i == end + 1)
            after = curr;
        curr = curr -> next;
    }
    // 其中 prev 和 after 可能为 NULL 。

    // 截断 front 到 rear 的部分。
    rear -> next = NULL;
    reverse(front);

    // 拼回去
    front -> next = after;
    // 注意prev可能为null
    if(prev == NULL)
    {
        return rear;
    } else {
        prev -> next = rear;
        return list;
    }
}
复制

1. HTTP是建立在TCP/IP上的一个应用层协议，其拥有TCP协议的所有功能，但是相对于TCP协议会较为复杂。
2. 通常的网络数据传输使用TCP/IP协议更好一些，主要有以下考虑：
   1. 各类操作系统均内置了TCP/IP网络库而没有内置HTTP库，在开发难易性上TCP/IP占优。
   2. TCP/IP协议已经满足大部分程序间网络传输需求，无需使用更为复杂的HTTP协议。
3. 但是依赖于HTTP传输的需求最好还是选择HTTP协议，避免重复造轮子，例如实现一个HTTP服务器或网页爬虫等。
4. 综上所述，大部分简单的网络传输需求应该使用TCP协议，依赖于HTTP协议的需求应当使用HTTP协议，具体问题具体分析。

给定循环数组 Array[n] ，已知其有序，但不知其向哪有序，也不知队头在哪，求数组的最小值，并要求时间复杂度为否则不得分

与Leetcode 128类似

程序思路：

1. 先用O(1)的时间判断其有序方向，连续选取3个元素进行判断即可。
2. 使用类似于二分查找的方法确定队头和队尾
3. 再根据升降序进行判断

复制

求以下代码的输出：

void main()
{
	int a[] = { 1, 7, 12, 15 };
	int *p1 = a, *p2 = p1++;
	*p1 += *p2++;
	printf("%d %d", *p1, *p2);
}
复制

注意点：

1. *p2 = p1++ 是先赋值再自增
2. 几个优先级问题：
   1. a = *p++ ，后置自增优先级比解引用高，等价于条目2
   2. a = *(p++) ，先对 p 解引用取值，随后 p 自增
   3. a = (*p)++ ，对 p 解引用，并对 p 指向的对象自增

void main()
{
	int a[] = { 1, 7, 12, 15 };
	int *p1 = a;
	*p2 = p1++;    // 此时p1指向a[1]，p2指向a[0]
	*p1 += *p2++;  // a[1] += *p，p++
	printf("%d %d", *p1, *p2);
}
复制

判断语句下列代码是否正确：

typedef struct
{
    int age;
    int score;
} student_t;

int main()
{
    student_t stu;
    student_t *p = &stu;
    *p.age = 23;
    return 0;
}
复制

错误，因为 . 运算符取成员的优先级大于 * 解引用的优先级，故应更改为：

(*p).age = 23;
复制

1. 整数提升规则：较小的整数(如char、short)参与运算时，会被自动提升为 int 或 unsigned int ，尽可能避免表达式中精度丢失问题。
2. 算数类型转换规则：在有不同类型的操作数的表达式时，低精度的操作数会被隐式转换为高精度的操作数。
3. 赋值转换规则：在进行赋值操作时，会隐式的提高或降低变量的类型，可能会丢失精度。
4. 函数参数转换规则：当调用函数时，如果函数的参数类型与传递给它的实际参数的类型不匹配，则会进行函数参数转换。

有两种方法：

1. 直接利用float转long的截断舍入规则：

long var = (long)(float_value + 0.5);
复制

2. 使用C11规范提供的 double round(double); 函数，先将float值进行四舍五入转换double的整数，随后利用截断赋值给long。该函数声明位于 math.h 但该函数在部分编译器(如GCC)下不支持。

long var = round(float_value);
复制

数组越界是指访问数组时，访问到了该数组以外的内存空间，因此可以分为如下几类：

1. 读取、写入到了该程序允许读写的内存空间：一般会导致未定义的后果，例如错误写入到别的变量的内存区域，会导致该变量值异常，并在后续触发对应后果，一般该后果难以预测。
2. 写入到了该程序不允许写入的内存空间：一般将此类地址空间称为非法内存地址，会触发操作系统的异常中断，可能会导致操作系统弹出错误消息或者直接终止程序的执行。
3. 在无虚拟内存的操作系统(如嵌入式常用的FreeRTOS)中，可能会操作到其他进程甚至系统进程的内存，会导致其他进程或系统异常并崩溃。
4. 数组越界或指针经常会导致一些安全漏洞，攻击者可利用该特性绕过安全检查。

1. 值传递，在传递时拷贝一份副本给对应函数，在函数内对形参的操作不影响实参的值。
2. 地址传递，传递时是传递了该参数的地址，是该参数地址的值传递。在C语言中通常通过传递数据的指针来达到直接修改参数或减少大变量内存拷贝的消耗。
3. 引用传递：引用传递是C++中的特性，在C语言中并不支持。形参是实参的别名，指向同一地址，相比于地址传递多了类型检查(地址传递时不会检查改地址空间的参数类型是否为所要求的类型)。

1. "形参和实参都是数组元素" 使用值传递
2. "形参是指针，实参是数组地址" 使用地址传递，在函数传参时，数组会被当成指针处理。
3. "形参和实参都是数组地址" 使用地址传递。

见2017年题目3.3 找第k大的数。

做P267的2015年第4题。

题目要求：

1. 该题目会通过主函数传入两个字符串，一个字符串是待加密的原文(只由字幕构成)，一个字符串是字符串表示的整形变量(使用 atoi 函数)
2. 完成凯撒密码的加密过程

实现：

void encrypt(char *str, char *key)
{
	int offset = atoi(key);  // atoi为stdlib.h中定义的将字符串转为整形的一个方法。
	offset %= 256;           // 保证offset范围为[0, 255]
	while(*str != '\0')
	{
		if('A' <= *str && *str <= 'Z')
		{
			// 此时为大写字符
			*str = (*str + offset) % 'A';
		} else if('a' <= *str && *str <= 'z'){
			// 此时为小写字符
			*str = (*str + offset) % 'a';
		}
		str++;
	}
}
复制

同2018年简答4.1和简答4.2

• 历年笔试题目笔记 > 4 1 简述C语言隐式转换会发生的四种情况，并说明每种如何转换
• 历年笔试题目笔记 > 4 2 如何将float类型四舍五入为long类型

同2023简答题1.1

• 历年笔试题目笔记 > 1 1 简述一下C语言采取了哪些措施提高运行效率 10分

同2023简答1.3

• 历年笔试题目笔记 > 1 3 函数结构与显示语言表示 10分

同2015年第4题

• 历年笔试题目笔记 > 2 变量及内存布局问题

求级数前 项的值

double calculate(int n)
{
	// 直接计算第一项
	double sum = 1;
	// 每一项的阶乘分母
	double mul = 1;
	for(int i = 1; i <= n; i++)
	{
		mul *= i;
		double t = pow(-1, i) * pow(x, i) / mul;
		sum += t;
	}
	return sum;
}
复制

for(int i = 12; i < 999; i++)
{
	t = 0;
	for(x = 0; x < 10; x++)
		f[x] = 0;
	for(j = 345; j < 9999; j++)
	{
		__________;
		s[0] = a;
		s[1] = b;
		s[2] = c;
		for(x = 0; x < 3; x++)
		{
			y = s[x];
			__________ {
				int t = y % 10;
				f[t] ++;
				__________;
			}
			for(x = 0; x < 10; x++)
			{
				if(__________)
					t++;
			}
			__________;
			__________;
		}
	}
}
复制

题干：

int low = ___;
int high = ___;
do{
    i = low;
    _______;
    _______;
    do{
        _______;
        _______;
        _______;
    } while(___);
    _______;
    if(i == k)
        return ___;
    if(i > k)
        _______;
    if(i < k)
        _______;
} while(low < high);
return _______;
复制

要点：

1. 注意题目并没给函数体，故无法实现递归调用
2. 题目并不要求处理后数列有序，因此多余的递归分支可以不要，直接将递归展开
3. 参考答案中使用的数组index从0开始，记得从众，不然会判错。
4. 他给出的空不可能完成该任务，不如和大家一起背答案...

答案：

int low = 0;
int high = n - 1;
do{
    i = low;
    j = high;
    pivot = array[i];
    do{
        while(array[j--] > pivot);
        while(array[i++] < pivot);
        swap(&array[j], &array[i]);
    } while(i < j);
    array[i] = array[high];
    if(i == k)
        return array[i];
    if(i > k)
        high = i - 1;
    if(i < k)
        high = i + 1;
} while(low < high);
return a[low];
复制