目錄

??????????????

并查集

快速排序

字典序算法

二分搜索

開根號-牛頓開方法

求質(zhì)數(shù)

編輯距離

滑動窗口

異或求重

長除法

---

???????

并查集

并查集用于解決相同元素集合動態(tài)連接的快速構(gòu)建算法

例：求相等集合a=b,e=d,d=b

初始時，ab為一集合,ed為一集合,又d=b，故應(yīng)將abed變?yōu)橐患?#xff0c;之后e=a就是顯而易見的事了

并查集利用構(gòu)建樹形結(jié)構(gòu)的方式，每個元素有上級，上級有上級，最高級的上級為其本身，通過查看兩個元素的最高級是否相同來判斷兩元素是否屬于同一集合

即，每個集合為一棵樹，判斷兩個元素是否屬于同一個集合只用判斷其樹根是否相同即可

初始時有數(shù)組pre[],pre[i]表示元素i的上一級

find(int x)用于找出元素x的最高級，即樹根

?int find(int x){

? ? ? ? ? ? while(x!=pre[x]){

? ? ? ? ? ? ? ? x=pre[x];

? ? ? ? ? ? } ??

? ? ? ? ? ? return x;

? ? ? ? }

union(int x,int y)用于將x,y所代表的兩個集合合并

?void union(int x,int y){

? ? ? ? ? ? int a=find(x);

? ? ? ? ? ? int b=find(y);

? ? ? ? ? ? pre[b]=a;

? ? ? ? }

例題（leetcode-990）：

給定一個由表示變量之間關(guān)系的字符串方程組成的數(shù)組，每個字符串方程?equations[i]?的長度為?4，并采用兩種不同的形式之一："a==b"?或?"a!=b"。在這里，a 和 b 是小寫字母（不一定不同），表示單字母變量名。

只有當(dāng)可以將整數(shù)分配給變量名，以便滿足所有給定的方程時才返回?true，否則返回?false。?

示例 1：

輸入：["a==b","b!=a"] 輸出：false 解釋：如果我們指定，a = 1 且 b = 1，那么可以滿足第一個方程，但無法滿足第二個方程。沒有辦法分配變量同時滿足這兩個方程。

示例 3：

輸入：["a==b","b==c","a==c"] 輸出：true

示例 5：

輸入：["c==c","b==d","x!=z"] 輸出：true

提示：

1 <= equations.length <= 500

equations[i].length == 4

equations[i][0]?和?equations[i][3]?是小寫字母

equations[i][1]?要么是?'='，要么是?'!'

equations[i][2]?是?'='

class Solution {//使用一下傳統(tǒng)并查集private ?int[] pre=new int[2560];//存儲其上一級,最高級為其本身,成為代理人//發(fā)現(xiàn)x所在集合的最高代理人private int find(int x){while(x!=pre[x]){x=pre[x];} ??return x;}//兩者應(yīng)該屬于同一伙，合并，為使其成為樹狀結(jié)構(gòu)，加快查找速度，將最高代理人合并private void union(int x,int y){int a=find(x);int b=find(y);if(a!=b){pre[b]=a;}}public boolean equationsPossible(String[] equations) {for(int i=0;i<2560;i++){pre[i]=i;//初始化}for(String s:equations){int l=s.charAt(0);int r=s.charAt(3);if(s.charAt(1)=='='&&find(l)!=find(r)){union(l,r);}}for(String s:equations){int l=s.charAt(0);int r=s.charAt(3);if(s.charAt(1)=='!'&&find(l)==find(r)){return false;}}return true;}}

參考：https://blog.csdn.net/liujian20150808/article/details/50848646

快速排序

快速排序以分治法為基本思想，遞歸為基本表現(xiàn)形式。

對于一個數(shù)組nums，傳遞參數(shù)left,right,為范圍,以第一個數(shù)（nums[0]）為key,將所有<=key的數(shù)放在左邊，所有>key的數(shù)放在右邊。

i=left,j=right,向前推進(jìn)i直到找到第一個>key的數(shù)，向后推進(jìn)直到找到第一個<=key的數(shù)

交換i,j的數(shù)的位置直到i==j

退出循環(huán)，此時i==j,核查nums[i]與key,保證<=i的數(shù)全部<=key,>j的數(shù)全部>j。因為以nums[0]為基準(zhǔn),nums[0]不能在參加遞歸運算，交換nums[i]與nums[0]，繼續(xù)遞歸，范圍為[left,i-1],[j,right]

遞歸的結(jié)束條件即為left>=right

? ? private void sort(int[] nums,int left,int right){if(left>=right)return ;int i=left,j=right;int key=nums[left];while(i<j){while(i<j&&nums[j]>key){j--;}while(i<j&&nums[i]<=key){i++;}int tmp=nums[i];nums[i]=nums[j];nums[j]=tmp;}if(nums[i]<=key)j++;else i--;nums[left]=nums[i];nums[i]=key;//基準(zhǔn)數(shù)不再參與數(shù)據(jù)處理sort(nums,left,i-1);sort(nums,j,right);}

字典序算法

字典序即按照a-zA-Z0-9的順序?qū)τ蛇@些元素組成的串的從小到大的全排列。

如[1,2,3]進(jìn)行全排列，將1,2,3組成數(shù)字，字典序就相當(dāng)于按所有組成數(shù)字從小到大進(jìn)行排列。

123->132->213->231->312->321

字典序算法可用于全排列(n!)生成

字典序算法的步驟為:

• 1.從右至左找到第一個左鄰小于右鄰，記錄左鄰位置i
• 2.從右至左找到第一個大于左鄰的數(shù)，即位置為j，交換num[i],num[j]
• 3.對位置i之后的所有數(shù)進(jìn)行排列

例題(leetcode-31)

實現(xiàn)獲取下一個排列的函數(shù)，算法需要將給定數(shù)字序列重新排列成字典序中下一個更大的排列。

如果不存在下一個更大的排列，則將數(shù)字重新排列成最小的排列（即升序排列）。

必須原地修改，只允許使用額外常數(shù)空間。

以下是一些例子，輸入位于左側(cè)列，其相應(yīng)輸出位于右側(cè)列。
1,2,3?→?1,3,2
3,2,1?→?1,2,3
1,1,5?→?1,5,1

class Solution {public void nextPermutation(int[] nums) {//考察字典序算法，字典序可用于生成全排列//字典序算法步驟為://1.從右至左找到第一個左鄰小于右鄰，記錄左鄰位置i//2.從右至左找到第一個大于左鄰的數(shù)，即位置為j，交換num[i],num[j]//3.對位置i之后的所有數(shù)進(jìn)行排列//如果沒找到i則說明已經(jīng)是最大的排列數(shù)int a=-1;//1.從右至左找到第一個左鄰小于右鄰，記錄左鄰位置ifor(int i=nums.length-1;i>0;i--){if(nums[i-1]<nums[i]){a=i-1;break;}}if(a==-1){sort(nums,0,nums.length-1);return ;}//2.從右至左找到第一個大于左鄰的數(shù)，即位置為j，交換num[i],num[j]for(int i=nums.length-1;i>a;i--){if(nums[i]>nums[a]){int temp=nums[i];nums[i]=nums[a];nums[a]=temp;sort(nums,a+1,nums.length-1);return ;}}}private void sort(int[] nums,int left,int right){if(left>=right)return ;int i=left,j=right;int key=nums[left];while(i<j){while(i<j&&nums[j]>key){j--;}while(i<j&&nums[i]<=key){i++;}int tmp=nums[i];nums[i]=nums[j];nums[j]=tmp;}if(nums[i]<=key)j++;else i--;nums[left]=nums[i];nums[i]=key;//基準(zhǔn)數(shù)不再參與數(shù)據(jù)處理sort(nums,left,i-1);sort(nums,j,right);} }

二分搜索

太經(jīng)典了，看代碼即可,nums為已排序數(shù)組

? ? ? ? int left=0,right=nums.length-1;while(left<=right){int med=(left+right)/2;if(nums[med]==target)return med;else if(nums[med]<target){left=med+1;}else{right=med-1;}}

開根號-牛頓開方法

實際上就是完成一個sqrt()函數(shù)，計算機完成開根號的運算，大部分使用牛頓迭代法。

假設(shè)a為要開方的數(shù)，那么x就是答案,即求f(x)=0時,x為何值

選取函數(shù)上一點(t,t^2-a),對于該點，求切線，切線上在x軸方向上的零點必定逼近于結(jié)果

切線的斜率對原函數(shù)求導(dǎo)即可,k=2t,該切線經(jīng)過點(t,t^2-a),求切線在x軸方向上的零點，即(t^2+a)/2t

以該點繼續(xù)迭代即可不斷逼近與結(jié)果

? ? public int mySqrt(int x) {//牛頓迭代法//y=res^2-x,選取點(a,a^2-x)做切點//斜率即求導(dǎo)數(shù)k=2a,令y=2ares`+t//帶入化簡，零點為res`=(a^2+x)/2a,繼續(xù)迭代if(x==0)return 0;if(x<=3)return 1;long current=x/2;while(current*current>x){current=((current+x/current)/2);}return (int)current;}

當(dāng)然，原理上是這么算的，實際上想要運行的更快還有一些技巧

關(guān)于這個方法，還有一個神奇的數(shù)字

0x5f3759df

?雷神之錘

參看:https://www.cnblogs.com/pkuoliver/archive/2010/10/06/1844725.html

求質(zhì)數(shù)

有兩種方法

1.暴力求解，對每一個數(shù)進(jìn)行判斷，判斷到sqrt(n)

for(int i=2;i<=n;i++){for(int j=2;j<=sqrt(i);j++){if(i%j==0)==>i不是質(zhì)數(shù);break;}}

2.篩選法，對于2來說，2的倍數(shù)一定不是質(zhì)數(shù)，對于3來說，3的倍數(shù)一定不是質(zhì)數(shù)。。開一個int[n]的數(shù)組，對于2,3...n

2是質(zhì)數(shù)，但2的倍數(shù)不是，打表，每次先判斷當(dāng)前是否被打上去，如果是直接跳過，否則是質(zhì)數(shù)，打表。

boolean[] check=new boolean[n+1]int tot = 0;for (int i = 2; i <= n; ++i) {if (!check[i]){prime[tot++] = i;}for (int j = i+i; j <= n; j += i){check[j] = true;}}

編輯距離

? ? ? ? 有兩個具有相同性質(zhì)的物質(zhì)可以互相轉(zhuǎn)換，字符串A轉(zhuǎn)換成字符串B,A,B都由字符構(gòu)成,給定基本條件，求A能轉(zhuǎn)換成B所需要的最小步驟,這個問題比較抽象，而所用的就是編輯距離算法，實際上還是動態(tài)規(guī)劃算法。

? ? ? ? 編輯距離是針對兩個字符串（例如英文字）的差異程度的量化量測，量測方式是看至少需要多少次的處理才能將一個字符串變成另一個字符串。編輯距離可以用在自然語言處理中，例如拼寫檢查可以根據(jù)一個拼錯的字和其他正確的字的編輯距離，判斷哪一個（或哪幾個）是比較可能的字。DNA也可以視為用A、C、G和T組成的字符串，因此編輯距離也用在生物信息學(xué)中，判斷二個DNA的類似程度。(來自百度百科)

例題(leetcode-72)

給定兩個單詞?word1 和?word2，計算出將?word1?轉(zhuǎn)換成?word2 所使用的最少操作數(shù)?。

你可以對一個單詞進(jìn)行如下三種操作：

插入一個字符
刪除一個字符
替換一個字符
示例?1:

輸入: word1 = "horse", word2 = "ros"
輸出: 3
解釋:?
horse -> rorse (將 'h' 替換為 'r')
rorse -> rose (刪除 'r')
rose -> ros (刪除 'e')

假設(shè)dp[i][j]表示前i個字符轉(zhuǎn)換成前j個字符所需要的最短距離

對于當(dāng)前字符word1[i]與word2[j]來說，

如果word[i]==word[j],顯然 dp[i][j]=dp[i-1][j-1]

否則，有三種方法可以對當(dāng)前字符進(jìn)行處理。

• 1.在前i個字符前插入一個字符，顯然我們不知道插到哪里合適，但是如果插入一個字符與word2[j]相同，那么就至少是最小變換中的一種，因為如果插入到別的地方，當(dāng)前字符還是和word2[j]不同，還要執(zhí)行變換操作，而插入字符放在最前面，那么dp[i][j]=1+dp[i][j-1](因為插入字符和word2[j]相同)
• 2.在前i個字符中刪除一個字符，顯然，刪誰都是可以的，但是因為word1[i]和word2[j]不相同，那么刪除word1[i]至少是最小變換中的一種，即dp[i][j]=1+dp[i-1][j]
• 3.替換一個字符，替換word1[i]=word2[j]，則dp[i][j]=1+dp[i-1][j-1]

由以上推斷就可以寫動歸代碼，注意底層條件的初始設(shè)置。

class Solution {public int minDistance(String word1, String word2) {int[][] dp=new int[word1.length()+1][word2.length()+1];//初始化底層條件for(int i=1;i<=word1.length();i++){dp[i][0]=i;}for(int i=1;i<=word2.length();i++){dp[0][i]=i;}for(int i=0;i<word1.length();i++){for(int j=0;j<word2.length();j++){if(word1.charAt(i)==word2.charAt(j)){dp[i+1][j+1]=dp[i][j];}else{dp[i+1][j+1]=1+Math.min(Math.min(dp[i][j+1],dp[i+1][j]),dp[i][j]);}}}return dp[word1.length()][word2.length()];} }

滑動窗口

這是一個非常經(jīng)典的思想，常用于在給定的范圍中尋求包含的子范圍。

滑動窗口維護(hù)兩個指針:left,right

最開始left和right都處于最左邊，right向右滑動擴大窗口直到子窗口[left...right]已滿足條件

這時就要開始動左指針left,對于left當(dāng)前狀態(tài)對應(yīng)的元素，判斷是否能將其拋出，如果能left向右滑動，即縮小窗口，同時再次進(jìn)行判斷，如果不能則動右指針right擴大窗口。簡而言之，right擴大窗口,left縮小窗口，整個窗口一次遍歷時就能遍歷到所有符合條件的子窗口。

leetcode官方描述:

• 初始，left指針和right指針都指向SS的第一個元素.
• 將 right 指針右移，擴張窗口，直到得到一個可行窗口，亦即包含TT的全部字母的窗口。
• 得到可行的窗口后，將left指針逐個右移，若得到的窗口依然可行，則更新最小窗口大小。
• 若窗口不再可行，則跳轉(zhuǎn)至 22。

例題(leetcode-76)

給你一個字符串 S、一個字符串 T，請在字符串 S 里面找出：包含 T 所有字母的最小子串。

示例：

輸入: S = "ADOBECODEBANC", T = "ABC"
輸出: "BANC"
說明：

如果 S 中不存這樣的子串，則返回空字符串 ""。
如果 S 中存在這樣的子串，我們保證它是唯一的答案。

class Solution {public String minWindow(String s, String t) {//暴力法O(n*2*m),超時//使用滑動窗口，left縮減窗口,right擴大窗口，窗口大小可動態(tài)變化Map<Character,Integer>t2=new HashMap<>();for(char c:t.toCharArray()){t2.put(c,t2.getOrDefault(c,0)+1);}if(!check(getMap(s),t2))return ""; int left=0;int right=t.length()-1;int ls=0;int rs=s.length()-1;//t1也跟著動態(tài)變化Map<Character,Integer>t1=new HashMap<>();for(char c:s.substring(0,t.length()).toCharArray()){t1.put(c,t1.getOrDefault(c,0)+1);}while(right<s.length()){if(check(t1,t2)){//滑動窗口包含t，收縮滑動窗口if(right-left<rs-ls){rs=right;ls=left;}t1.put(s.charAt(left),t1.get(s.charAt(left))-1);left++;continue;}//不包含，擴展滑動窗口right++;if(right<s.length())t1.put(s.charAt(right),t1.getOrDefault(s.charAt(right),0)+1);}return s.substring(ls,rs+1);}private Map<Character,Integer> getMap(String s){Map<Character,Integer>t1=new HashMap<>();for(char c:s.toCharArray()){t1.put(c,t1.getOrDefault(c,0)+1);}return t1;}//t1完全包含t2private boolean check(Map<Character,Integer>t1,Map<Character,Integer>t2){for(char c:t2.keySet()){if(!t1.containsKey(c))return false;if(t1.get(c)<t2.get(c))return false;}return true;} }

異或求重

? ? 異或的性質(zhì)：

? ? 1、交換律：a^b = b^a；

? ? 2、結(jié)合律：(a^b)^c = a^(b^c)；

? ? 3、對于任意的a：a^a=0，a^0=a，a^(-1)=~a

? ? ? ? 由以上性質(zhì)可以得出一個重要推導(dǎo):a^b^c^d^a^k =?b^c^d^k^(a^a) =?b^c^d^k^0 =?b^c^d^k，即如果有多個數(shù)異或，其中有重復(fù)的數(shù)，則無論這些重復(fù)的數(shù)是否相鄰，都可以根據(jù)異或的性質(zhì)將其這些重復(fù)的數(shù)消去。如果有偶數(shù)個數(shù)則異或后為0，如果為奇數(shù)個，則異或后只剩一個。（引用于:https://blog.csdn.net/ns_code/article/details/27568975）

?1、1-1000放在含有1001個元素的數(shù)組中，只有唯一的一個元素值重復(fù)，其它均只出現(xiàn)一次。每個數(shù)組元素只能訪問一次，設(shè)計一個算法，將它找出來；不用輔助存儲空間，能否設(shè)計一個算法實現(xiàn)？

????當(dāng)然，這道題，可以用最直觀的方法來做，將所有的數(shù)加起來，減去1+2+3+...+1000的和，得到的即是重復(fù)的那個數(shù)，該方法很容易理解，而且效率很高，也不需要輔助空間，唯一的不足時，如果范圍不是1000，而是更大的數(shù)字，可能會發(fā)生溢出。

????我們考慮用異或操作來解決該問題。現(xiàn)在問題是要求重復(fù)的那個數(shù)字，我們姑且假設(shè)該數(shù)字式n吧，如果我們能想辦法把1-1000中除n以外的數(shù)字全部異或兩次，而數(shù)字n只異或一次，就可以把1-1000中出n以外的所有數(shù)字消去，這樣就只剩下n了。我們首先把所有的數(shù)字異或，記為T，可以得到如下：

T = 1^2^3^4...^n...^n...^1000 = 1^2^3...^1000（結(jié)果中不含n）

????而后我們再讓T與1-1000之間的所有數(shù)字（僅包含一個n）異或，便可得到該重復(fù)數(shù)字n。如下所示：

T^(a^2^3^4...^n...^1000) = T^(T^n) = 0^n = n

????2、一個數(shù)組中只有一個數(shù)字出現(xiàn)了一次，其他的全部出現(xiàn)了兩次，求出這個數(shù)字。

????明白了上面題目的推導(dǎo)過程，這個就很容易了，將數(shù)組中所有的元素全部異或，最后出現(xiàn)兩次的元素會全部被消去，而最后會得到該只出現(xiàn)一次的數(shù)字。

長除法

用于大精度除法求小數(shù)

模擬除法中，小數(shù)上的商可以重復(fù)，或陷入無限循環(huán)（小數(shù)循環(huán)節(jié)），而商實際上是由上一次剩下的模數(shù)來決定的，商可以重復(fù)而模數(shù)不能重復(fù)，一旦模數(shù)開始重復(fù)就代表循環(huán)節(jié)開始出現(xiàn)

例題:leetcoed分?jǐn)?shù)到小數(shù)

給定兩個整數(shù)，分別表示分?jǐn)?shù)的分子?numerator 和分母 denominator，以字符串形式返回小數(shù)。

如果小數(shù)部分為循環(huán)小數(shù)，則將循環(huán)的部分括在括號內(nèi)。

示例 1:

輸入: numerator = 1, denominator = 2 輸出: "0.5"

示例?2:

輸入: numerator = 2, denominator = 1 輸出: "2"

示例?3:

輸入: numerator = 2, denominator = 3 輸出: "0.(6)" class Solution {public String fractionToDecimal(int numerato, int denominato) {//模擬除法，由題意判斷不會出現(xiàn)無限不循環(huán)小數(shù)//***********模擬長除法：（商的）小數(shù)循環(huán)節(jié)出現(xiàn)則每次除下的模數(shù)也會重復(fù)出現(xiàn)//原理：模數(shù)一旦重復(fù)則代表要出現(xiàn)循環(huán)節(jié)if(numerato==0)return "0";char flag='+';if((numerato>0&&denominato<0)||(numerato<0&&denominato>0))flag='-';long numerator=Math.abs((long)numerato);//不用long會溢出long denominator=Math.abs((long)denominato);String res="";//能夠整除if(numerator>=denominator&&numerator%denominator==0){return flag=='+'?String.valueOf(numerator/denominator):'-'+String.valueOf(numerator/denominator);}//不能夠整除,注意符號Map<Long,Integer>map=new HashMap<>();//記錄模數(shù)與每次除下的商所在的位置res+=numerator/denominator+".";numerator%=denominator;while(true){//結(jié)束條件:能夠除盡或者陷入無限循環(huán)(模數(shù)重復(fù)出現(xiàn))if(map.containsKey(numerator)){res=res.substring(0,map.get(numerator))+"("+res.substring(map.get(numerator))+")";break;}map.put(numerator,res.length());//放模數(shù)numerator*=10;res+=numerator/denominator;//System.out.println(numerator+" "+denominator);numerator%=denominator;//模數(shù)更新if(numerator==0){break;}}return flag=='+'?res:'-'+res;}}

注意對于int除法來說為保證能求得準(zhǔn)確精度應(yīng)該使用long類型，否則模數(shù)一直*10后面可能會溢出

總結(jié)

以上是生活随笔為你收集整理的经典算法-并查集、快速排序、字典序算法、二分搜索、牛顿开方法、求质数(筛选法)、编辑距离、滑动窗口、异或求重、长除法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。