一、使用二分法求一个无序数组中的最大值
(1)工作原理:
使用递归函数,将无序数组不断二分成左右两个部分,每次递归返回左右两侧最大的数,直到无法划分为止。递归过程类似er于后序遍历的压栈过程。
(2)代码表示:
/*二分法求无序数组arr[L……R]中的最大值*/
int process(int* arr, int L, int R)
{
if (L == R)
return arr[L];
int mid = L + ((R - L) >> 1);//求中点,这种写法可防溢出
int leftMax = process(arr, L, mid);
int rightMax = process(arr, mid + 1, R);
return leftMax > rightMax ? leftMax : rightMax;
}
int getMax(int* arr, int len)
{
return process(arr, 0, len - 1);
}
(3)重点代码解析
求中点的过程中若使用下面的写法,很容易导致溢出的现象发生:当L和R都足够大时,L+R会超出范围,若采用mid = L+(R-L)/2这种写法,可以避免出现L+R。
int mid = (L+R)/2;
二、递归函数的时间复杂度
(1)master公式
其中T(N)为母问题的规模(数据量),a为递归调用次数,T(N/b)为子问题的规模。
上例中符合master公式下a=2,b=2,d=0的情况,因为有2次递归(leftMax和rightMax),每次把数据量分为原来的一半,除递归调用外没有其他循环,时间复杂度为O(1)。
需要注意的是,若子问题规模不相等,master公式不成立。
(2)时间复杂度
时,时间复杂度为;
时,时间复杂度为
时,时间复杂度为
上例满足第二种情况,时间复杂度为O(N),时间复杂度的指标等同于遍历寻找最大值。
三、归并排序
(1)思路
采用分治法,将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
简单来说就是使左边有序,右边有序,然后使整体有序。
(2)代码实现
/*二路归并排序*/
void merge(int* arr, int L, int M, int R)//将左右两侧的数字按大小并入辅助数组help
{
int* help = (int*)malloc(sizeof(int) * (R - L + 1));
int i = 0;
int p1 = L, p2 = M + 1;
while (p1 <= M && p2 <= R)
help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
while (p1 <= M)
help[i++] = arr[p1++];
while (p2 <= R)
help[i++] = arr[p2++];
for (int k = 0; k < i; k++)
arr[L + k] = help[k];
}
void process(int* arr, int L, int R)//递归使mid左右两侧有序
{
if (L == R)
return;
int mid = L + ((R - L) >> 1);
//左右两侧进行递归拆分
process(arr, L, mid);
process(arr, mid + 1, R);
//再将arr中的左右两部分合并为有序的,L到mid为左侧部分,mid+1到R是右侧
merge(arr, L, mid, R);
}
void mergeSort(int* arr, int len)
{
if (arr == NULL && len < 2)
return;
process(arr, 0, len - 1);
for (int k = 0; k < len; k++)
printf("%d ", arr[k]);
}
(3)时间复杂度和空间复杂度
时间复杂度依据master公式可知为O(N*logN),空间复杂度为O(N),因为使用了辅助数组help。
四、归并法求解小和问题
(1)小和问题概念
在一个数组中,每一个数左边比当前数小的数累加起来,叫做这个数组的小和。要求使用二路归并的方法求一个数组的小和。
例子:
[1,3,4,2,5]
1左边比1小的数,没有;
3左边比3小的数,1;
4左边比4小的数,1、3;
2左边比2小的数,1;
5左边比5小的数,1、3、4、2;
所以小和为1+1+3+1+1+3+4+2=16
(2)代码实现
/*小和问题*/
int sortMerge(int* arr, int L, int mid, int R)
{
int* help = (int*)malloc(sizeof(int) * (R - L + 1));
int i = 0, p1 = L, p2 = mid + 1;
int res = 0;
while (p1 <= mid && p2 <= R)
{
res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= mid)
help[i++] = arr[p1++];
while (p2 <= R)
help[i++] = arr[p2++];
for (int k = 0; k < i; k++)
{
arr[L + k] = help[k];
}
return res;
}
int sortProcess(int* arr, int L, int R)
{
if (L == R)
return 0;
int mid = L + ((R - L) >> 1);
return sortProcess(arr, L, mid) + sortProcess(arr, mid + 1, R) + sortMerge(arr, L, mid, R);
//左侧排序并且求出小和的数量+右侧排序并且求出小和的数量+将左右侧合并时产生小和的数量
}
int smallSum(int* arr,int len)
{
if (arr == NULL || len < 2)
return 0;
return sortProcess(arr, 0, len - 1);
}
五、快速排序
(1)思路
参考http://t.csdn.cn/xGurn ,先找到一个基准数,然后把所有小于它的数放在左边,所有大于它的数放在右边,基准数放在中间,此时基准数的位置与最终得到的有序数组中该数的位置一样,然后分别对基准数左边和右边的数进行递归,最终所有数都会到达有序位置。
(2)代码实现
/*快速排序2.0*/
void quickSort(int* arr, int L, int R)
{
if (L >= R)
return;
int i, j, base, temp;
i = L;
j = R;
base = arr[L];//取最左侧的数为基准数
while (i < j)
{
while (arr[j] >= base && i < j)
j--;
while (arr[i] <= base && i < j)
i++;
if (i < j)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
arr[L] = arr[i];//基准数归位
arr[i] = base;
quickSort(arr, L, i - 1);//递归左侧(小于base)
quickSort(arr, i + 1, R);//递归右侧(大于base)
}
(3)快速排序优化
上面的代码是快速排序2.0版本,缺陷在于当数组本身有序时,无法实现对左侧和右侧两个子序列的递归,因为所有数都大于基准数,每次递归实际上就是对整个数组递归,最差的时间复杂度为;当基准数刚好是中位数时,左右两侧的子序列长度相等时,为最优时间复杂度。
快速排序3.0的做法是不直接指定基准数,而是在序列中随机选择一个数作为基准数,这样可以避免最差时间复杂度情况的发生,此时时间复杂度为
快速排序的空间复杂度是。其中最优的空间复杂度出现在base值刚好为中点时,为,最差的空间复杂度出现在base为最大值或最小值时,为,经过数学计算可以得到随机情况下空间复杂度收敛于。