《程序员编程艺术面试和算法心得》第二部分算法心得.docx
- 文档编号:29507659
- 上传时间:2023-07-24
- 格式:DOCX
- 页数:32
- 大小:255.86KB
《程序员编程艺术面试和算法心得》第二部分算法心得.docx
《《程序员编程艺术面试和算法心得》第二部分算法心得.docx》由会员分享,可在线阅读,更多相关《《程序员编程艺术面试和算法心得》第二部分算法心得.docx(32页珍藏版)》请在冰豆网上搜索。
《程序员编程艺术面试和算法心得》第二部分算法心得
第四章查找匹配
4.1有序数组的查找
题目描述
给定一个有序的数组,查找某个数是否在数组中,请编程实现。
分析与解法
一看到数组本身已经有序,我想你可能反应出了要用二分查找,毕竟二分查找的适用条件就是有序的。
那什么是二分查找呢?
二分查找可以解决(预排序数组的查找)问题:
只要数组中包含T(即要查找的值),那么通过不断缩小包含T的范围,最终就可以找到它。
其算法流程如下:
∙一开始,范围覆盖整个数组。
∙将数组的中间项与T进行比较,如果T比数组的中间项要小,则到数组的前半部分继续查找,反之,则到数组的后半部分继续查找。
∙如此,每次查找可以排除一半元素,范围缩小一半。
就这样反复比较,反复缩小范围,最终就会在数组中找到T,或者确定原以为T所在的范围实际为空。
对于包含N个元素的表,整个查找过程大约要经过log
(2)N次比较。
此时,可能有不少读者心里嘀咕,不就二分查找么,太简单了。
然《编程珠玑》的作者JonBentley曾在贝尔实验室做过一个实验,即给一些专业的程序员几个小时的时间,用任何一种语言编写二分查找程序(写出高级伪代码也可以),结果参与编写的一百多人中:
90%的程序员写的程序中有bug(我并不认为没有bug的代码就正确)。
也就是说:
在足够的时间内,只有大约10%的专业程序员可以把这个小程序写对。
但写不对这个小程序的还不止这些人:
而且高德纳在《计算机程序设计的艺术第3卷排序和查找》第6.2.1节的“历史与参考文献”部分指出,虽然早在1946年就有人将二分查找的方法公诸于世,但直到1962年才有人写出没有bug的二分查找程序。
你能正确无误的写出二分查找代码么?
不妨一试,关闭所有网页,窗口,打开记事本,或者编辑器,或者直接在本文评论下,不参考上面我写的或其他任何人的程序,给自己十分钟到N个小时不等的时间,立即编写一个二分查找程序。
要准确实现二分查找,首先要把握下面几个要点:
∙关于right的赋值
oright=n-1=>while(left<=right)=>right=middle-1;
oright=n=>while(left
∙middle的计算不能写在while循环外,否则无法得到更新。
以下是一份参考实现:
intBinarySearch(intarray[],intn,intvalue)
{
intleft=0;
intright=n-1;
//如果这里是intright=n的话,那么下面有两处地方需要修改,以保证一一对应:
//1、下面循环的条件则是while(left //2、循环内当array[middle]>value的时候,right=mid while(left<=right)//循环条件,适时而变 { intmiddle=left+((right-left)>>1);//防止溢出,移位也更高效。 同时,每次循环都需要更新。 if(array[middle]>value) { right=middle-1;//right赋值,适时而变 } elseif(array[middle] { left=middle+1; } else returnmiddle; //可能会有读者认为刚开始时就要判断相等,但毕竟数组中不相等的情况更多 //如果每次循环都判断一下是否相等,将耗费时间 } return-1; } 总结 编写二分查找的程序时 ∙如果令`left<=right,则right=middle-1; ∙如果令left 换言之,算法所操作的区间,是左闭右开区间,还是左闭右闭区间,这个区间,需要在循环初始化。 且在循环体是否终止的判断中,以及每次修改left,right区间值这三个地方保持一致,否则就可能出错。 4.2行列递增矩阵的查找 题目描述 在一个m行n列二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。 请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 例如下面的二维数组就是每行、每列都递增排序。 如果在这个数组中查找数字6,则返回true;如果查找数字5,由于数组不含有该数字,则返回false。 分析与解法 解法一、分治法 这种行和列分别递增的矩阵,有一个专有名词叫做杨氏矩阵,由剑桥大学数学家杨表在1900年推提出,在这个矩阵中的查找,俗称杨氏矩阵查找。 以查找数字6为例,因为矩阵的行和列都是递增的,所以整个矩阵的对角线上的数字也是递增的,故我们可以在对角线上进行二分查找,如果要找的数是6介于对角线上相邻的两个数4、10,可以排除掉左上和右下的两个矩形,而在左下和右上的两个矩形继续递归查找,如下图所示: 解法二、定位法 首先直接定位到最右上角的元素,再配以二分查找,比要找的数(6)大就往左走,比要找数(6)的小就往下走,直到找到要找的数字(6)为止,这个方法的时间复杂度O(m+n)。 如下图所示: 关键代码如下所示: #defineROW4 #defineCOL4 boolYoungMatrix(intarray[][COL],intsearchKey){ inti=0,j=COL-1; intvar=array[i][j]; while(true){ if(var==searchKey) returntrue; elseif(var var=array[++i][j]; elseif(var>searchKey&&j>0) var=array[i][--j]; else returnfalse; } } 举一反三 1、给定n×n的实数矩阵,每行和每列都是递增的,求这n^2个数的中位数。 2、我们已经知道杨氏矩阵的每行的元素从左到右单调递增,每列的元素从上到下也单调递增的矩阵。 那么,如果给定从1-n这n个数,我们可以构成多少个杨氏矩阵呢? 例如n=4的时候,我们可以构成1行4列的矩阵: 1234 2个2行2列的矩阵: 12 34 和 13 24 还有一个4行1列的矩阵 1 2 3 4 因此输出4。 4.3出现次数超过一半的数字 题目描述 题目: 数组中有一个数字出现的次数超过了数组长度的一半,找出这个数字。 分析与解法 一个数组中有很多数,现在我们要找出其中那个出现次数超过总数一半的数字,怎么找呢? 大凡当我们碰到某一个杂乱无序的东西时,我们人的内心本质期望是希望把它梳理成有序的。 所以,我们得分两种情况来讨论,无序和有序。 解法一 如果无序,那么我们是不是可以先把数组中所有这些数字先进行排序(至于排序方法可选取最常用的快速排序)。 排完序后,直接遍历,在遍历整个数组的同时统计每个数字的出现次数,然后把那个出现次数超过一半的数字直接输出,题目便解答完成了。 总的时间复杂度为O(nlogn+n)。 但如果是有序的数组呢,或者经过排序把无序的数组变成有序后的数组呢? 是否在排完序O(nlogn)后,还需要再遍历一次整个数组? 我们知道,既然是数组的话,那么我们可以根据数组索引支持直接定向到某一个数。 我们发现,一个数字在数组中的出现次数超过了一半,那么在已排好序的数组索引的N/2处(从零开始编号),就一定是这个数字。 自此,我们只需要对整个数组排完序之后,然后直接输出数组中的第N/2处的数字即可,这个数字即是整个数组中出现次数超过一半的数字,总的时间复杂度由于少了最后一次整个数组的遍历,缩小到O(n*logn)。 然时间复杂度并无本质性的改变,我们需要找到一种更为有效的思路或方法。 解法二 既要缩小总的时间复杂度,那么可以用查找时间复杂度为O (1)的hash表,即以空间换时间。 哈希表的键值(Key)为数组中的数字,值(Value)为该数字对应的次数。 然后直接遍历整个hash表,找出每一个数字在对应的位置处出现的次数,输出那个出现次数超过一半的数字即可。 解法三 Hash表需要O(n)的空间开销,且要设计hash函数,还有没有更好的办法呢? 我们可以试着这么考虑,如果每次删除两个不同的数(不管是不是我们要查找的那个出现次数超过一半的数字),那么,在剩下的数中,我们要查找的数(出现次数超过一半)出现的次数仍然超过总数的一半。 通过不断重复这个过程,不断排除掉其它的数,最终找到那个出现次数超过一半的数字。 这个方法,免去了排序,也避免了空间O(n)的开销,总得说来,时间复杂度只有O(n),空间复杂度为O (1),貌似不失为最佳方法。 举个简单的例子,如数组a[5]={0,1,2,1,1}; 很显然,若我们要找出数组a中出现次数超过一半的数字,这个数字便是1,若根据上述思路4所述的方法来查找,我们应该怎么做呢? 通过一次性遍历整个数组,然后每次删除不相同的两个数字,过程如下简单表示: 01211=>211=>1 最终1即为所找。 但是数组如果是{5,5,5,5,1},还能运用上述思路么? 很明显不能,咱们得另寻良策。 解法四 更进一步,考虑到这个问题本身的特殊性,我们可以在遍历数组的时候保存两个值: 一个candidate,用来保存数组中遍历到的某个数字;一个nTimes,表示当前数字的出现次数,其中,nTimes初始化为1。 当我们遍历到数组中下一个数字的时候: ∙如果下一个数字与之前candidate保存的数字相同,则nTimes加1; ∙如果下一个数字与之前candidate保存的数字不同,则nTimes减1; ∙每当出现次数nTimes变为0后,用candidate保存下一个数字,并把nTimes重新设为1。 直到遍历完数组中的所有数字为止。 举个例子,假定数组为{0,1,2,1,1},按照上述思路执行的步骤如下: ∙1.开始时,candidate保存数字0,nTimes初始化为1; ∙2.然后遍历到数字1,与数字0不同,则nTimes减1变为0; ∙3.因为nTimes变为了0,故candidate保存下一个遍历到的数字2,且nTimes被重新设为1; ∙4.继续遍历到第4个数字1,与之前candidate保存的数字2不同,故nTimes减1变为0; ∙5.因nTimes再次被变为了0,故我们让candidate保存下一个遍历到的数字1,且nTimes被重新设为1。 最后返回的就是最后一次把nTimes设为1的数字1。 思路清楚了,完整的代码如下: //a代表数组,length代表数组长度 intFindOneNumber(int*a,intlength) { intcandidate=a[0]; intnTimes=1; for(inti=1;i { if(nTimes==0) { candidate=a[i]; nTimes=1; } else { if(candidate==a[i]) nTimes++; else nTimes--; } } returncandidate; } 即针对数组{0,1,2,1,1},套用上述程序可得: i=0,candidate=0,nTimes=1; i=1,a[1]! =candidate,nTimes--,=0; i=2,candidate=2,nTimes=1; i=3,a[3]! =candidate,nTimes--,=0; i=4,candidate=1,nTimes=1; 如果是0,1,2,1,1,1的话,那么i=5,a[5]==candidate,nTimes++,=2;...... 举一反三 加强版水王: 找出出现次数刚好是一半的数字 分析: 我们知道,水王问题: 有N个数,其中有一个数出现超过一半,要求在线性时间求出这个数。 那么,我的问题是,加强版水王: 有N个数,其中有一个数刚好出现一半次数,要求在线性时间内求出这个数。 因为,很明显,如果是刚好出现一半的话,如此例: 0,1,2,1: 遍历到0时,candidate为0,times为1 遍历到1时,与candidate不同,times减为0 遍历到2时,times为0,则candidate更新为2,times加1 遍历到1时,与candidate不同,则times减为0;我们需要返回所保存candidate(数字2)的下一个数字,即数字1。 第五章动态规划 5.0本章导读 学习一个算法,可分为3个步骤: 首先了解算法本身解决什么问题,然后学习它的解决策略,最后了解某些相似算法之间的联系。 例如图算法中, ∙广搜是一层一层往外遍历,寻找最短路径,其策略是采取队列的方法。 ∙最小生成树是最小代价连接所有点,其策略是贪心,比如Prim的策略是贪心+权重队列。 ∙Dijkstra是寻找单源最短路径,其策略是贪心+非负权重队列。 ∙Floyd是多结点对的最短路径,其策略是动态规划。 而贪心和动态规划是有联系的,贪心是“最优子结构+局部最优”,动态规划是“最优独立重叠子结构+全局最优”。 一句话理解动态规划,则是枚举所有状态,然后剪枝,寻找最优状态,同时将每一次求解子问题的结果保存在一张“表格”中,以后再遇到重叠的子问题,从表格中保存的状态中查找(俗称记忆化搜索)。 5.1最大连续乘积子串 题目描述 给一个浮点数序列,取最大乘积连续子串的值,例如-2.5,4,0,3,0.5,8,-1,则取出的最大乘积连续子串为3,0.5,8。 也就是说,上述数组中,30.58这3个数的乘积30.58=12是最大的,而且是连续的。 分析与解法 此最大乘积连续子串与最大乘积子序列不同,请勿混淆,前者子串要求连续,后者子序列不要求连续。 也就是说,最长公共子串(LongestCommonSubstring)和最长公共子序列(LongestCommonSubsequence,LCS)是: ∙子串(Substring)是串的一个连续的部分, ∙子序列(Subsequence)则是从不改变序列的顺序,而从序列中去掉任意的元素而获得的新序列; 更简略地说,前者(子串)的字符的位置必须连续,后者(子序列LCS)则不必。 比如字符串“acdfg”同“akdfc”的最长公共子串为“df”,而它们的最长公共子序列LCS是“adf”,LCS可以使用动态规划法解决。 解法一 或许,读者初看此题,可能立马会想到用最简单粗暴的方式: 两个for循环直接轮询。 doublemaxProductSubstring(double*a,intlength) { doublemaxResult=a[0]; for(inti=0;i { doublex=1; for(intj=i;j { x*=a[j]; if(x>maxResult) { maxResult=x; } } } returnmaxResult; } 但这种蛮力的方法的时间复杂度为O(n^2),能否想办法降低时间复杂度呢? 解法二 考虑到乘积子序列中有正有负也还可能有0,我们可以把问题简化成这样: 数组中找一个子序列,使得它的乘积最大;同时找一个子序列,使得它的乘积最小(负数的情况)。 因为虽然我们只要一个最大积,但由于负数的存在,我们同时找这两个乘积做起来反而方便。 也就是说,不但记录最大乘积,也要记录最小乘积。 假设数组为a[],直接利用动态规划来求解,考虑到可能存在负数的情况,我们用maxend来表示以a[i]结尾的最大连续子串的乘积值,用minend表示以a[i]结尾的最小的子串的乘积值,那么状态转移方程为: maxend=max(max(maxend*a[i],minend*a[i]),a[i]); minend=min(min(maxend*a[i],minend*a[i]),a[i]); 初始状态为maxend=minend=a[0]。 参考代码如下: doubleMaxProductSubstring(double*a,intlength) { doublemaxEnd=a[0]; doubleminEnd=a[0]; doublemaxResult=a[0]; for(inti=1;i { doubleend1=maxEnd*a[i],end2=minEnd*a[i]; maxEnd=max(max(end1,end2),a[i]); minEnd=min(min(end1,end2),a[i]); maxResult=max(maxResult,maxEnd); } returnmaxResult; } 动态规划求解的方法一个for循环搞定,所以时间复杂度为O(n)。 举一反三 1、给定一个长度为N的整数数组,只允许用乘法,不能用除法,计算任意(N-1)个数的组合中乘积最大的一组,并写出算法的时间复杂度。 分析: 我们可以把所有可能的(N-1)个数的组合找出来,分别计算它们的乘积,并比较大小。 由于总共有N个(N-1)个数的组合,总的时间复杂度为O(N2),显然这不是最好的解法。 5.2字符串编辑距离 题目描述 给定一个源串和目标串,能够对源串进行如下操作: 1.在给定位置上插入一个字符 2.替换任意字符 3.删除任意字符 写一个程序,返回最小操作数,使得对源串进行这些操作后等于目标串,源串和目标串的长度都小于2000。 分析与解法 此题常见的思路是动态规划,假如令dp[i][j]表示源串S[0…i]和目标串T[0…j]的最短编辑距离,其边界: dp[0][j]=j,dp[i][0]=i,那么我们可以得出状态转移方程: ∙dp[i][j]=min{ odp[i-1][j]+1,S[i]不在T[0…j]中 odp[i-1][j-1]+1/0,S[i]在T[j] odp[i][j-1]+1,S[i]在T[0…j-1]中 } 接下来,咱们重点解释下上述3个式子的含义 ∙关于dp[i-1][j]+1,s.t.s[i]不在T[0…j]中的说明 os[i]没有落在T[0…j]中,即s[i]在中间的某一次编辑操作被删除了。 因为删除操作没有前后相关性,不妨将其在第1次操作中删除。 除首次操作时删除外,后续编辑操作是将长度为i-1的字符串,编辑成长度为j的字符串: 即dp[i-1][j]。 o因此: dp[i][j]=dp[i-1][j]+1。 ∙关于dp[i-1][j-1]+0/1,s.t.s[i]在T[j]的说明 o若s[i]经过编辑,最终落在T[j]的位置。 o则要么s[i]==t[j],s[i]直接落在T[j]。 这种情况,编辑操作实际上是将长度为i-1的S’串,编辑成长度为j-1的T’串: 即dp[i-1][j-1]; o要么s[i]≠t[j],s[i]落在T[j]后,要将s[i]修改成T[j],即在上一种情况的基础上,增加一次修改操作: 即dp[i-1][j-1]+1。 ∙关于dp[i][j-1]+1,s.t.s[i]在T[0…j-1]中的说明 o若s[i]落在了T[1…j-1]的某个位置,不妨认为是k,因为最小编辑步数的定义,那么,在k+1到j-1的字符,必然是通过插入新字符完成的。 因为共插入了(j-k)个字符,故编辑次数为(j-k)次。 而字符串S[1…i]经过编辑,得到了T[1…k],编辑次数为dp[i][k]。 故: dp[i][j]=dp[i][k]+(j-k)。 o由于最后的(j-k)次是插入操作,可以讲(j-k)逐次规约到dp[i][k]中。 即: dp[i][k]+(j-k)=dp[i][k+1]+(j-k-1)规约到插入操作为1次,得到dp[i][k]+(j-k)=dp[i][k+1]+(j-k-1)=dp[i][k+2]+(j-k-2)=…=dp[i][k+(j-k-1)]+(j-k)-(j-k-1)=dp[i][j-1]+1。 上述的解释清晰规范,但为啥这样做呢? 换一个角度,其实就是字符串对齐的思路。 例如把字符串“ALGORITHM”,变成“ALTRUISTIC”,那么把相关字符各自对齐后,如下图所示: 把图中上面的源串S[0…i]=“ALGORITHM”编辑成下面的目标串T[0…j]=“ALTRUISTIC”,我们枚举字符串S和T最后一个字符s[i]、t[j]对应四种情况: (字符-空白)(空白-字符)(字符-字符)(空白-空白)。 由于其中的(空白-空白)是多余的编辑操作。 所以,事实上只存在以下3种情况: ∙下面的目标串空白,即S+字符X,T+空白,S变成T,意味着源串要删字符 odp[i-1,j]+1 ∙上面的源串空白,S+空白,T+字符,S变成T,最后,在S的最后插入“字符”,意味着源串要添加字符 odp[i,j-1]+1 ∙上面源串中的的字符跟下面目标串中的字符不一样,即S+字符X,T+字符Y,S变成T,意味着源串要修改字符 odp[i-1,j-1]+(s[i]==t[j]? 0: 1) 综上,可以写出简单的DP状态方程: //dp[i,j]表示表示源串S[0…i]和目标串T[0…j]的最短编辑距离 dp[i,j]=min{dp[i-1,j]+1,dp[i,j-1]+1,dp[i-1,j-1]+(s[i]==t[j]? 0: 1)} //分别表示: 删除1个,添加1个,替换1个(相同就不用替换)。 参考代码如下: //dp[i][j]表示源串source[0-i)和目标串target[0-j)的编辑距离 intEditDistance(char*pSource,char*pTarget) { intsrcLength=strlen(pSource); inttargetLength=strlen(pTarget); inti,j; //边界dp[i][0]=i,dp[0][j]=j for(i=1;i<=srcLength;++i) { dp[i][0]=i; } for(j=1;j<=targetLength;++j) { dp[0][j]=j; } for(i=1;i<=srcLength;++i) { for(j=1;j<=targetLength;++j) { if(pSource[i
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 程序员编程艺术面试和算法心得 程序员 编程 艺术 面试 算法 心得 第二 部分