排序算法（希尔排序、归并排序、快速排序、堆排序）、KMP算法

1、希尔排序

1.1排序原理

1.2代码实现

int shell_sort(int* data, int length) {
	int gap = 0;
	int temp;
	int i = 0, j = 0;
	for (gap = length / 2; gap >= 1; gap /= 2) {   //分组 对应步长
		for (i = gap; i < length; i++) {
			temp = data[i];    //用临时变量存储
			for (j = i - gap; j >= 0 && temp < data[j]; j = j - gap) {   // 内层循环的
				data[j + gap] = data[j];
			}
			data[j + gap] = temp;
		}
	}
	return 0;
}

2 归并排序

2.1 实现原理

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

2.2 实现代码

排序函数

void merge_sort(int *data, int start, int end, int *result)
{
    if(1 == end - start)//如果区间中只有两个元素，则对这两个元素进行排序
    {
        if(data[start] > data[end])
        {
            int temp  = data[start];
            data[start] = data[end];
            data[end] = temp;
        }
        return;
    }
    else if(0 == end - start)//如果只有一个元素，则不用排序
        return;
    else
    {
        //继续划分子区间，分别对左右子区间进行排序
        merge_sort(data,start,(end-start+1)/2+start,result);
        merge_sort(data,(end-start+1)/2+start+1,end,result);
        //开始归并已经排好序的start到end之间的数据
        merge(data,start,end,result);
        //把排序后的区间数据复制到原始数据中去
        for(int i = start;i <= end;++i)
            data[i] = result[i];
    }
}

merge过程

void merge(int *data,int start,int end,int *result)
{
    int left_length = (end - start + 1) / 2 + 1;//左部分区间的数据元素的个数
    int left_index = start;
    int right_index = start + left_length;
    int result_index = start;
    while(left_index < start + left_length && right_index < end+1)
    {
        //对分别已经排好序的左区间和右区间进行合并
        if(data[left_index] <= data[right_index])
            result[result_index++] = data[left_index++];
        else
            result[result_index++] = data[right_index++];
    }
    while(left_index < start + left_length)
        result[result_index++] = data[left_index++];
    while(right_index < end+1)
        result[result_index++] = data[right_index++];
}

//测试案例
int main()
{
    int data[] = {9,6,7,22,20,33,16,20};
    const int length = 8;
    int result[length];
    cout << "Before sorted:" << endl;
    for(int i = 0;i < length;++i)
        cout << data[i] << "  ";
    cout << endl;
    cout << "After sorted:" << endl;
    merge_sort(data,0,length-1,result);
    for(int i = 0;i < length;++i)
        cout << data[i] << "  ";
    cout << endl;

    return 0;
}

3 快速排序

3.1 实现原理

3.2 实现代码

//快速排序
int sort1(int* data, int left, int right)
{
	if (right < left) return -1;
	int i = left;
	int j = right;
	int key = data[left];

	while (i != j) {
		while (i < j && key <= data[j]) {
			j--;
		}
		data[i] = data[j];
		while (i < j && key >= data[i]) {
			i++;
		}
		data[j] = data[i];
	}
	data[i] = key;
	sort1(data, left, i - 1);
	sort1(data, i + 1, right);
	return 0;
}    //end sort1();

 

void quick_sort(int* data, int length) 
{
	sort1(data, 0, length - 1);
}

4 堆排序

4.1 堆排序实现原理

4.2 实现代码

//面试过程中需要熟悉的算法
冒泡排序、选择排序、插入排序
希尔排序、归并排序、快速排序、堆排序

面试基本考基础，成熟公司基本面基础
表1 不同算法复杂度

KMP算法

字符串匹配算法
识别一个字符串样本里面，查找一个小的字符串

void make_next(const char* pattern, int* next) {

	int q, k;
	int m = strlen(pattern);

	next[0] = 0;
	for (q = 1, k = 0; q < m; q++) {

		while (k > 0 && pattern[q] != pattern[k])
			k = next[k - 1];

		if (pattern[q] == pattern[k]) {
			k++;
		}

		next[q] = k;

	}

}


int kmp(const char* text, const char* pattern, int* next) {

	int n = strlen(text);
	int m = strlen(pattern);

	make_next(pattern, next);

	int i, q;
	for (i = 0, q = 0; i < n; i++) {

		while (q > 0 && pattern[q] != text[i]) {
			q = next[q - 1];
		}

		if (pattern[q] == text[i]) {
			q++;
		}

		if (q == m) {
			//printf("Pattern occurs with shift: %d\n", (i-m+1));
			break;
		}
	}

	return i - q + 1;
}

这边文章将KMP算法讲得很好

https://blog.csdn.net/v_JULY_v/article/details/7041827

思考题

实现一个时间轮定时器，采用堆排序
一个定时器，实现若干个定时器任务。
timer
select