一個簡單字串差異對比暴力演算法實現

阿新 • • 發佈：2022-04-06

　　如題：請求出兩個字串的差異部分，並以不同的顏色區分顯示到瀏覽器上。

演算法實現如下：（js實現）

<!DOCTYPE html>
<!DOCTYPE html>
<html>
<head>
    <title>diff function test</title>
    <script type="text/javascript">
        // 思路1: 使用雙指標暴力解法
        // 1. 先掃描a, 直到一個與b[j]相同的元素為止, 儲存為aQueue
        // 2. 再掃描b, 每次的查詢範圍為aQueue 

        // 3. 如果找到, 則進行接下來的最長匹配
        // 4. 如果沒有找到, 則讓a進行最長匹配
        // 5. 進入下一輪迴圈，直到a迴圈為止
        // 時間複雜度: a:m, b:n, a1:m, b1:m(m+1)/2*n, ∴ O(m²n)
        var logSwitch = 1;
        function diffWithWhitespace(a, b) {
            var aValues = a.split("");
            var bValues = b.split("");
             
var alen = aValues.length;
            var blen = bValues.length;
            var i = 0, j = 0;
            var equalLongest = [];
            var aDiffLongest = [];
            var aResult = [];
            var bResult = [];
            // 上一次比較結果, EQUAL:相等, ADIFF:A, BDIFF:B
            var lastDiffResultType  
= "EQUAL";
            while(i < alen || j < blen) {
                if(aValues[i] == bValues[j]) {
                    // todo: 記錄結果, 到a中，b中
                    if(lastDiffResultType != "EQUAL" 
                        || equalLongest.length == 0) {
                        equalLongest = [];
                        aDiffLongest = [];
                        lastDiffResultType = "EQUAL";
                        aResult.push({"item": equalLongest, "type":"equal"})
                        bResult.push({"item": equalLongest, "type":"equal"})
                    }
                    equalLongest.push(aValues[i]);
                    printLog("equal:<span style=\"background:#ffea00\">" + aValues[i] + "</span><br />");
                    i++;
                    j++;
                    continue;
                }
                var i2 = i, j2 = j;
                aDiffLongest = [];
                while((i2) < alen 
                        && aValues[i2] != bValues[j2]) {
                    aDiffLongest.push(aValues[i2]);
                    ++i2;
                }
                var aDiffTmp = [];
                var bDiffTmp = [];
                if(i2 > alen) {
                    // no equal find
                    // the last one
                }
                else if(i2 != alen && aValues[i2] == bValues[j]) {
                    aDiffLongest.push(aValues[i2]);
                }
                else{
                    if(j >= blen) {
                        aDiffTmp.push(aValues[i]);
                        // the last one
                        aResult.push({"item": aDiffTmp, "type":"diff"});
                        i++;
                        continue;
                    }
                    // a中未找到，全部退回到b中進行查詢
                    bDiffTmp.push(bValues[j]);
                    bResult.push({"item": bDiffTmp, "type":"diff"})
                    // 去重相同項，也同時跳過上一相同的項
                    while(++j2 < blen 
                            && bValues[j2] == bValues[j]) {
                        bDiffTmp.push(bValues[j2]);
                        j = j2;
                    }
                    printLog("bdiff:" + bDiffTmp + "<br />");
                    j++;
                    lastDiffResultType = "BDIFF";
                    continue;
                }
                var curMaxStep = aDiffLongest.length;
                var foundCloser = 0;
                while(++j2 < blen && curMaxStep-- > 0) {
                    var i3 = 0;
                    for (;i3 < aDiffLongest.length; i3++) {
                        if(bValues[j2] == aDiffLongest[i3]) {
                            // 相同段
                            foundCloser = 1;
                            break;
                        }
                    }
                    if(foundCloser == 1) {
                        for (var c = i; c < i + i3; c++) {
                            aDiffTmp.push(aValues[c]);
                        }
                        for (var c = j ; c < j2; c++) {
                            bDiffTmp.push(bValues[c]);
                        }
                        if(aDiffTmp.length > 0) {
                            aResult.push({"item": aDiffTmp, "type":"diff"});
                            printLog("adiff:" + aDiffTmp + "<p>");
                        }
                        if(bDiffTmp.length > 0) {
                            bResult.push({"item": bDiffTmp, "type":"diff"});
                            printLog("bdiff:" + bDiffTmp + "<p>");
                        }
                        var eqItem = bValues[j2];
                        if(lastDiffResultType != "EQUAL"
                            || equalLongest.length == 0) {
                            equalLongest = [];
                            aDiffLongest = [];
                            lastDiffResultType = "EQUAL";
                            aResult.push({"item": equalLongest, "type":"equal"})
                            bResult.push({"item": equalLongest, "type":"equal"})
                        }
                        equalLongest.push(eqItem);
                        printLog("equal:<span style=\"background:#ffea00\">" + eqItem +"</span><br />");
                        aDiffLongest.splice(0, 1);
                        i = i + i3;
                        j = j2;
                        i++;
                        j++;
                        break;
                    }
                    else {
                        if(aDiffLongest.length == 0) {
                            lastDiffResultType = "BDIFF";
                        }
                        else{
                            lastDiffResultType = "ADIFF";
                        }
                        lastDiffResultType = "DIFF";
                    }
                }
                if(!foundCloser) {
                    for (var c = aDiffLongest.length - 1; c > 0; c--) {
                        aDiffTmp.push(aDiffLongest[0]);
                        aDiffLongest.splice(0, 1);    
                    }
                    for (var c = j ; c < j2; c++) {
                        bDiffTmp.push(bValues[c]);
                    }
                    if(aDiffTmp.length > 0) {
                        aResult.push({"item": aDiffTmp, "type":"diff"})
                        printLog("adiff:" + aDiffTmp + "<p>");
                    }
                    if(bDiffTmp.length > 0) {
                        bResult.push({"item": bDiffTmp, "type":"diff"});
                        printLog("bdiff:" + bDiffTmp + "<p>");
                    }
                    var eqItem = aDiffLongest[0];
                    if(lastDiffResultType != "EQUAL"
                        || equalLongest.length == 0) {
                        equalLongest = [];
                        aDiffLongest = [];
                        bDiffLongest = [];
                        lastDiffResultType = "EQUAL";
                        aResult.push({"item": equalLongest, "type":"equal"})
                        bResult.push({"item": equalLongest, "type":"equal"})
                    }
                    equalLongest.push(eqItem);
                    printLog("equal:<span style=\"background:#ffea00\">" + eqItem +"</span><br />");
                    aDiffLongest.splice(0, 1);
                    i = i2 - i3;
                    j = j2;
                    i++;
                    j++;
                    lastDiffResultType = "ADIFF";
                    continue;
                }

            }
            return {"a": aResult, "b":bResult};
        }
        turnOffLogSwitch();
        var aText = "今天 是個 好天氣";
        var bText = "今天, 真是 一個 好陰天啊";
        diffWithWhitespaceAndAppendBody(aText, bText);

        aText = "ParseException";
        bText = "RuntimeException";
        diffWithWhitespaceAndAppendBody(aText, bText);


        function diffWithWhitespaceAndAppendBody(a, b) {
            printLog(aText);
            printLog("<p>");
            printLog(bText);
            printLog("<p>compare result: <p>");
            var diffResult = diffWithWhitespace(aText, bText);
            document.write("<p>A SIDE: <p>")
            diffResult.a.forEach(function (r) {
                writeDiffResult(r);
            });
            document.write("<p>B SIDE: <p>")
            diffResult.b.forEach(function (r) {
                writeDiffResult(r);
            });
        }
        function writeDiffResult(structText) {
            var item = structText.item.join("");
            if(structText.type != "equal") {
                item = "<span style=\"background:#ffea00\">" + item + "</span>";
            }
            document.write(item);
        }
        function printLog(msg) {
            if(logSwitch == 1) {
                document.write(msg);
            }
        }
        function turnOnLogSwitch() {
            logSwitch = 1;
        }
        function turnOffLogSwitch() {
            logSwitch = 0;
        }
    </script>
</head>
<body>

</body>
</html>

<!DOCTYPE html>
<!DOCTYPE html>
<html>
<head>
    <title>diff function test</title>
    <script type="text/javascript">
        // 思路1: 使用雙指標暴力解法
        // 1. 先掃描a, 直到一個與b[j]相同的元素為止, 儲存為aQueue
        // 2. 再掃描b, 每次的查詢範圍為aQueue
        // 3. 如果找到, 則進行接下來的最長匹配
        // 4. 如果沒有找到, 則讓a進行最長匹配
        // 5. 進入下一輪迴圈，直到a迴圈為止
        // 時間複雜度: a:m, b:n, a1:m, b1:m(m+1)/2*n, ∴ O(m²n)
        var logSwitch = 1;
        function diffWithWhitespace(a, b) {
            var aValues = a.split("");
            var bValues = b.split("");
            var alen = aValues.length;
            var blen = bValues.length;
            var i = 0, j = 0;
            var equalLongest = [];
            var aDiffLongest = [];
            var aResult = [];
            var bResult = [];
            // 上一次比較結果, EQUAL:相等, ADIFF:A, BDIFF:B
            var lastDiffResultType = "EQUAL";
            while(i < alen || j < blen) {
                if(aValues[i] == bValues[j]) {
                    // todo: 記錄結果, 到a中，b中
                    if(lastDiffResultType != "EQUAL" 
                        || equalLongest.length == 0) {
                        equalLongest = [];
                        aDiffLongest = [];
                        lastDiffResultType = "EQUAL";
                        aResult.push({"item": equalLongest, "type":"equal"})
                        bResult.push({"item": equalLongest, "type":"equal"})
                    }
                    equalLongest.push(aValues[i]);
                    printLog("equal:<span style=\"background:#ffea00\">" + aValues[i] + "</span><br />");
                    i++;
                    j++;
                    continue;
                }
                var i2 = i, j2 = j;
                aDiffLongest = [];
                while((i2) < alen 
                        && aValues[i2] != bValues[j2]) {
                    aDiffLongest.push(aValues[i2]);
                    ++i2;
                }
                var aDiffTmp = [];
                var bDiffTmp = [];
                if(i2 > alen) {
                    // no equal find
                    // the last one
                }
                else if(i2 != alen && aValues[i2] == bValues[j]) {
                    aDiffLongest.push(aValues[i2]);
                }
                else{
                    if(j >= blen) {
                        aDiffTmp.push(aValues[i]);
                        // the last one
                        aResult.push({"item": aDiffTmp, "type":"diff"});
                        i++;
                        continue;
                    }
                    // a中未找到，全部退回到b中進行查詢
                    bDiffTmp.push(bValues[j]);
                    bResult.push({"item": bDiffTmp, "type":"diff"})
                    // 去重相同項，也同時跳過上一相同的項
                    while(++j2 < blen 
                            && bValues[j2] == bValues[j]) {
                        bDiffTmp.push(bValues[j2]);
                        j = j2;
                    }
                    printLog("bdiff:" + bDiffTmp + "<br />");
                    j++;
                    lastDiffResultType = "BDIFF";
                    continue;
                }
                var curMaxStep = aDiffLongest.length;
                var foundCloser = 0;
                while(++j2 < blen && curMaxStep-- > 0) {
                    var i3 = 0;
                    for (;i3 < aDiffLongest.length; i3++) {
                        if(bValues[j2] == aDiffLongest[i3]) {
                            // 相同段
                            foundCloser = 1;
                            break;
                        }
                    }
                    if(foundCloser == 1) {
                        for (var c = i; c < i + i3; c++) {
                            aDiffTmp.push(aValues[c]);
                        }
                        for (var c = j ; c < j2; c++) {
                            bDiffTmp.push(bValues[c]);
                        }
                        if(aDiffTmp.length > 0) {
                            aResult.push({"item": aDiffTmp, "type":"diff"});
                            printLog("adiff:" + aDiffTmp + "<p>");
                        }
                        if(bDiffTmp.length > 0) {
                            bResult.push({"item": bDiffTmp, "type":"diff"});
                            printLog("bdiff:" + bDiffTmp + "<p>");
                        }
                        var eqItem = bValues[j2];
                        if(lastDiffResultType != "EQUAL"
                            || equalLongest.length == 0) {
                            equalLongest = [];
                            aDiffLongest = [];
                            lastDiffResultType = "EQUAL";
                            aResult.push({"item": equalLongest, "type":"equal"})
                            bResult.push({"item": equalLongest, "type":"equal"})
                        }
                        equalLongest.push(eqItem);
                        printLog("equal:<span style=\"background:#ffea00\">" + eqItem +"</span><br />");
                        aDiffLongest.splice(0, 1);
                        i = i + i3;
                        j = j2;
                        i++;
                        j++;
                        break;
                    }
                    else {
                        if(aDiffLongest.length == 0) {
                            lastDiffResultType = "BDIFF";
                        }
                        else{
                            lastDiffResultType = "ADIFF";
                        }
                        lastDiffResultType = "DIFF";
                    }
                }
                if(!foundCloser) {
                    for (var c = aDiffLongest.length - 1; c > 0; c--) {
                        aDiffTmp.push(aDiffLongest[0]);
                        aDiffLongest.splice(0, 1);    
                    }
                    for (var c = j ; c < j2; c++) {
                        bDiffTmp.push(bValues[c]);
                    }
                    if(aDiffTmp.length > 0) {
                        aResult.push({"item": aDiffTmp, "type":"diff"})
                        printLog("adiff:" + aDiffTmp + "<p>");
                    }
                    if(bDiffTmp.length > 0) {
                        bResult.push({"item": bDiffTmp, "type":"diff"});
                        printLog("bdiff:" + bDiffTmp + "<p>");
                    }
                    var eqItem = aDiffLongest[0];
                    if(lastDiffResultType != "EQUAL"
                        || equalLongest.length == 0) {
                        equalLongest = [];
                        aDiffLongest = [];
                        bDiffLongest = [];
                        lastDiffResultType = "EQUAL";
                        aResult.push({"item": equalLongest, "type":"equal"})
                        bResult.push({"item": equalLongest, "type":"equal"})
                    }
                    equalLongest.push(eqItem);
                    printLog("equal:<span style=\"background:#ffea00\">" + eqItem +"</span><br />");
                    aDiffLongest.splice(0, 1);
                    i = i2 - i3;
                    j = j2;
                    i++;
                    j++;
                    lastDiffResultType = "ADIFF";
                    continue;
                }

            }
            return {"a": aResult, "b":bResult};
        }
        turnOffLogSwitch();
        var aText = "今天 是個 好天氣";
        var bText = "今天, 真是 一個 好陰天啊";
        diffWithWhitespaceAndAppendBody(aText, bText);

        aText = "ParseException";
        bText = "RuntimeException";
        diffWithWhitespaceAndAppendBody(aText, bText);


        function diffWithWhitespaceAndAppendBody(a, b) {
            printLog(aText);
            printLog("<p>");
            printLog(bText);
            printLog("<p>compare result: <p>");
            var diffResult = diffWithWhitespace(aText, bText);
            document.write("<p>A SIDE: <p>")
            diffResult.a.forEach(function (r) {
                writeDiffResult(r);
            });
            document.write("<p>B SIDE: <p>")
            diffResult.b.forEach(function (r) {
                writeDiffResult(r);
            });
        }
        function writeDiffResult(structText) {
            var item = structText.item.join("");
            if(structText.type != "equal") {
                item = "<span style=\"background:#ffea00\">" + item + "</span>";
            }
            document.write(item);
        }
        function printLog(msg) {
            if(logSwitch == 1) {
                document.write(msg);
            }
        }
        function turnOnLogSwitch() {
            logSwitch = 1;
        }
        function turnOffLogSwitch() {
            logSwitch = 0;
        }
    </script>
</head>
<body>

</body>
</html>

　　演算法屬於暴力解法，簡單使用了雙指標法，沒有太多技巧，需要進一步優化。供參考。

一個簡單字串差異對比暴力演算法實現

　　如題：請求出兩個字串的差異部分，並以不同的顏色區分顯示到瀏覽器上。

用JAVA實現一個簡單LRU演算法

一個LRU演算法最簡單的有如下的功能：這裡我們先不考慮用雜湊表做優化實際上就是一個連結串列，通過連結串列來模擬實現

用java實現一個簡單的區塊鏈：UTXO交易模型

在上一篇用java實現一個簡單的區塊鏈中，我們主要講了什麼是區塊鏈（提示:區塊鏈就是談戀愛），以及區塊鏈是如何做到去中心化，不可篡改性的。然後就是通過解析國外一篇關於java區塊鏈的文章，用java實現了一個簡單的

用java實現一個簡單的區塊鏈

前言: 之前其實一直有考慮要不要寫一篇這篇文章，因為類似的文章在網上實在太多了，而且只要你細讀幾篇會發現，很多文章除了內容都是出奇的雷同之外，大多數都是源於國外大神的兩篇關於java區塊鏈的教程的生硬翻譯，

用 Java 實現一個簡單的虛擬機器器 ?

Learning By Doing. 最近開了個新坑,目的是用 Java 8 實現一個簡單的解釋型 JVM. 目前零零散散提交了 100 多 commits. 最終的目標是自舉.

?【Go 實踐】實現一個簡單的多人聊天室

簡介 Github 地址部落格原文本文使用 go 實現了一個多人聊天室，參考文章為 Writing a Chat Server in Go，點選檢視中文翻譯版。

N皇后問題暴力解和回溯解問題分析和演演算法實現-leetcode困難難度

n皇后問題是經典的回溯解題的案例，回溯一般用在有多個解的演演算法中，回溯的核心是窮舉，一般通過必要的減枝提高效率(減少重複計算等)，得到一個解後，把當前解進行儲存，然後將當前解標記為未解決，繼續嘗試下一個

動手實現一個簡單的Celery

簡介 Celery是一個由Python實現的分散式任務佇列，任務佇列通常有3個方面的功能。

MyBatis Plus構建一個簡單的專案的實現

開始吧 1、首先準備一張表“users”表。 2、建立一個springboot工程，“可以使用 Spring Initializer 快速初始化一個 Spring Boot 工程”，具體工程的建立這裡就不說了。大家都懂的。

SpringBoot+Logback實現一個簡單的鏈路追蹤功能

最近線上排查問題時候，發現請求太多導致日誌錯綜複雜，沒辦法把使用者在一次或多次請求的日誌關聯在一起，所以就利用SpringBoot+Logback手寫了一個簡單的鏈路追蹤，下面詳細介紹下。

200行程式碼輕鬆實現一個簡單的區塊鏈

英文原文：Lauri Hartikka 區塊鏈的基礎概念很簡單：一個分散式資料庫，儲存一個不斷加長的 list，list 中包含著許多有序的記錄。然而，在通常情況下，當我們談到區塊鏈的時候也會談起使用區塊鏈來解決的問題，這兩者

Python3實現配置檔案差異對比指令碼

應用場景：配置檔案由於升級改動了，我們想看看升級後的配置檔案相對於之前的改動了哪些配置項

詳解如何用python實現一個簡單下載器的服務端和客戶端

話不多說，先看程式碼：客戶端： import socket def main(): #creat: download_client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

python求一個字串的所有排列的實現方法

題目描述：設計一個程式，當輸入一個字串時，要求輸出這個字串的所有排列。

python使用梯度下降演算法實現一個多線性迴歸

python使用梯度下降演算法實現一個多線性迴歸，供大家參考，具體內容如下圖示：

使用Windows API實現一個簡單的串列埠助手

目錄使用window API開發一個具有字串收發功能的串列埠助手開發環境串列埠裝置相關的API步驟實現程式碼收發測試圖

通過Python實現一個簡單的html頁面

一、使用python寫CGI程式 CGI（Common Gateway Interface）也叫通用閘道器介面，它是一個web伺服器主機提供資訊服務的標準介面，只要遵循這個介面，web伺服器就能獲取客戶端提交的資訊，轉交給服務端的CGI程式進行處

Python實現一個簡單的畢業生資訊管理系統的示例程式碼

寫在前面：從昨晚的夢裡回憶起資料管理的作業：實現一個自己的選題---- 畢業生資訊管理系統，實現學生個人資訊基本的增刪改查，

動手實現一個簡單的 rpc 框架到入門 grpc (上)

rpc 全稱 Remote Procedure Call 遠端過程呼叫，即呼叫遠端方法。我們呼叫當前程式中的方法時很簡單，但是想要呼叫不同程式，甚至不同主機、不同語言中的方法時就需要藉助 rpc 來實現，下面我一步步實現一個簡單的 r

字串補0的一個簡單方法

問題描述字串補0是常見的需求，比如日期不足2位補0，數字精度不足補0等，需求是給一個數字和一個小數精度返回一個帶有特定精度的數字字串

一個簡單字串差異對比暴力演算法實現

相關推薦