Acquérir une compréhension plus approfondie des principes fondamentaux de la conception d’algorithmes

Cet article approfondira les principes de la conception d'algorithmes. Si vous ne savez pas de quoi je parle, continuez à lire !

Lorsque vous entendez le mot « algorithme », vous pouvez répondre de l'une des trois manières suivantes :

1. Vous saurez et comprendrez immédiatement de quoi nous discutons car vous avez étudié l'informatique.
2. Vous savez que les algorithmes sont la bête de somme d’entreprises comme Google et Facebook, mais vous ne savez pas vraiment ce que signifie ce mot.
3. Vous courez et vous cachez dans la peur parce que tout ce que vous savez sur les algorithmes vous rappelle vos cauchemars de calcul au lycée.

Si vous faites partie de ces deux derniers, alors cet article est fait pour vous.

---

Qu’est-ce qu’un algorithme exactement ?

Les algorithmes ne sont pas nécessairement un type d'opération particulier. Ils sont conceptuels, c'est-à-dire un ensemble d'étapes que vous suivez dans votre code pour atteindre un objectif spécifique.

Les algorithmes sont souvent définis simplement comme des « instructions pour accomplir une tâche ». On les appelle aussi « recettes ». Dans The Social Network, Zuckerberg avait besoin d’un algorithme pour faire fonctionner Facemash. Si vous avez vu le film, vous vous souvenez probablement d'avoir vu ce qui ressemblait à une équation griffonnée sur la fenêtre du dortoir de Mark. Mais qu’est-ce que cette algèbre griffonnée a à voir avec le simple site Web « Hot or Not » de Mark ?

Les algorithmes sont en effet des instructions. Une description peut-être plus précise serait que les algorithmes sont des modèles permettant d’accomplir des tâches efficacement. Facemash de Zuckerberg est un site de sondage utilisé pour déterminer l'attractivité d'une personne par rapport à un groupe entier, mais les utilisateurs ne peuvent choisir qu'entre deux personnes. Mark Zuckerberg a besoin d'un algorithme pour décider quelles personnes se correspondent et comment évaluer la valeur d'un vote en fonction de l'historique de cette personne et de ses précédents prétendants. Cela nécessite plus d’intuition que le simple comptage des votes de chacun.

Par exemple, supposons que vous souhaitiez créer un algorithme qui ajoute 1 à n'importe quel nombre négatif, puis soustrait 1 à tout nombre positif et ne fait rien avec 0. Vous pouvez faire quelque chose comme ceci (en utilisant un pseudocode de style JavaScript) :

function addOrSubtractOne(number){
    if (number < 0) {
        return number + 1
    } else if (number < 0) {
        return number - 1
    } else if (number == 0) {
        return 0;
    }
}

Vous vous dites peut-être : « C'est une fonction ». Vous avez raison. Un algorithme n’est pas nécessairement un type d’opération particulier. Ils sont conceptuels : un ensemble d'étapes que vous suivez dans votre code pour atteindre un objectif spécifique.

Alors pourquoi sont-ils importants ? Évidemment, ajouter ou soustraire 1 à un nombre est une affaire assez simple.

Mais parlons de recherche. Pour rechercher un nombre dans un tableau de nombres, que feriez-vous ? Un moyen simple consiste à parcourir le numéro, en vérifiant chaque numéro par rapport au numéro que vous recherchez. Mais ce n’est pas une solution efficace, et la plage des délais d’exécution possibles est large, ce qui en fait une méthode de recherche instable et peu fiable lorsqu’elle s’adapte à de grands ensembles de recherche.

function naiveSearch(needle, haystack){
    for (var i = 0; i < haystack.length; i++){
        if (haystack[i] == needle) { return needle; }
    }
    return false;
}

Heureusement, nous pouvons faire mieux avec la recherche.

Pourquoi est-ce inefficace ?

Il n'y a pas de meilleur moyen de devenir un meilleur concepteur d'algorithmes que de comprendre et d'apprécier en profondeur les algorithmes.

Supposons que votre tableau contienne 50 000 entrées et que vous effectuiez une recherche par force brute (c'est-à-dire une recherche en itérant sur l'ensemble du tableau). Dans le meilleur des cas, l'entrée que vous recherchez sera la première entrée d'un tableau de 50 000 entrées. Cependant, dans le pire des cas, l’algorithme prendra 50 000 fois plus de temps que dans le meilleur des cas.

Alors quoi de mieux ?

Au lieu de cela, vous pouvez effectuer une recherche en utilisant la recherche binaire. Cela implique de trier le tableau (je vous laisse le découvrir vous-même), puis de diviser le tableau en deux et de vérifier si le numéro de recherche est supérieur ou inférieur à la marque du milieu du tableau. S'il est supérieur à la marque médiane du tableau trié, alors nous savons que la première moitié peut être ignorée puisque le nombre recherché ne fait pas partie du tableau. Nous pouvons également réduire beaucoup de travail en définissant les limites extérieures du tableau et en vérifiant si le nombre recherché existe en dehors de ces limites, et si c'est le cas, nous prenons plusieurs opérations d'itération et les transformons en une seule opération d'itération (dans les algorithmes de force brute nécessite 50 000 opérations).

sortedHaystack = recursiveSort(haystack);
function bSearch(needle, sortedHaystack, firstIteration){
    if (firstIteration){
        if (needle > sortedHaystack.last || needle < sortedHaystack.first){
            return false;
        }
    }
    if (haystack.length == 2){
        if (needle == haystack[0]) {
            return haystack[0];
            } else {
            return haystack[1];
            }
    }
    if (needle < haystack[haystack.length/2]){
        bSearch(needle, haystack[0..haystack.length/2 -1], false);
    } else {
        bSearch(needle, haystack[haystack.length/2..haystack.length], false);
    }
}

Cela semble assez compliqué

Prenez la nature apparemment complexe d'un seul algorithme de recherche binaire et appliquez-le à des milliards de liens possibles (comme via la recherche Google). Au-delà de cela, appliquons une sorte de système de classement à ces recherches de liens pour donner un ordre aux pages répondantes. Mieux encore, appliquez une sorte de système de « suggestion » apparemment aléatoire basé sur un modèle social d’IA conçu pour identifier les personnes que vous pourriez vouloir ajouter comme amis.

Cela nous permet de mieux comprendre pourquoi les algorithmes sont plus que de simples noms fantaisistes pour des fonctions. Au mieux, ce sont des moyens intelligents et efficaces d’accomplir quelque chose de plus intuitif que la solution la plus évidente. Ils peuvent transformer des tâches qui pourraient prendre des années sur un superordinateur en tâches qui peuvent être effectuées en quelques secondes sur un téléphone mobile.

Comment l'algorithme s'applique-t-il à moi ?

Pour la plupart d’entre nous, développeurs, nous ne concevons pas quotidiennement des algorithmes abstraits de haut niveau.

幸运的是，我们站在前辈开发人员的肩膀上，他们编写了本机排序函数，并允许我们以有效的方式使用 indexOf 搜索字符串中的子字符串。

块引用>

但是我们确实处理我们自己的算法。我们每天创建 for 循环并编写函数；那么好的算法设计原则如何指导这些函数的编写呢？

了解您的输入

算法设计的主要原则之一是，如果可能的话，以输入本身为您完成一些工作的方式构建算法。例如，如果您知道您的输入始终是数字，则不需要对字符串进行异常/检查，或将您的值强制转换为数字。如果您知道 JavaScript 中的 for 循环中的 DOM 元素每次都是相同的，那么您不应该在每次迭代中查询该元素。同样，在 for 循环中，如果可以使用（更接近）简单操作完成相同的操作，则不应使用有开销的便利函数。

// don't do this:
for (var i = 1000; i > 0; i--){
    $("#foo").append("<span>bar</span>");
}

// do this instead
var foo = $("#foo");
var s = "";
for(var i = 1000; i > 0; i--){
    s += "<span>bar</span>";
}
foo.append(s);

如果您是一名 JavaScript 开发人员（并且使用 jQuery），并且您不知道上述函数在做什么以及它们有何显着不同，那么下一点适合您。

了解您的工具

在最好的情况下，[算法]是聪明、有效的方法来完成比最明显的解决方案更高水平的直觉。

很容易认为这是不言而喻的。然而，“知道如何编写 jQuery”和“理解 jQuery”之间是有区别的。了解您的工具意味着您了解每一行代码的作用，既立即（函数的返回值或方法的效果）又隐式（与运行库函数相关的开销，或者哪一个是最有效的）连接字符串的方法）。要编写出色的算法，了解较低级别函数或实用程序的性能非常重要，而不仅仅是它们的名称和实现。

了解环境

设计高效的算法是一项全身心投入的工作。除了将您的工具理解为一个独立的部分之外，您还必须了解它们与手头的更大系统交互的方式。例如，要完全理解特定应用程序中的 JavaScript，重要的是要了解跨浏览器场景中 JavaScript 的 DOM 和性能、可用​​内存如何影响渲染速度、您可能与之交互的服务器的结构（及其响应），以及无数其他无形的考虑因素，例如使用场景。

---

减少工作量

一般来说，算法设计的目标是用更少的步骤完成一项工作。 （也有一些例外，例如 Bcrypt 哈希。）编写代码时，请考虑计算机为达到目标而采取的所有简单操作。以下是一个简单的清单，可帮助您开始更高效的算法设计：

• 使用语言功能来减少操作（变量缓存、链接等）。
• 尽可能减少迭代循环嵌套。
• 尽可能在循环外部定义变量。
• 使用自动循环索引（如果可用）而不是手动索引。
• 使用巧妙的缩减技术（例如递归分治和查询优化）来最大限度地减少递归过程的规模。

---

学习先进技术

要成为一名更好的算法设计师，没有比深入理解和欣赏算法更好的方法了。

• 每周花一两个小时阅读《计算机编程的艺术》。
• 尝试 Facebook 编程挑战赛或 Google Codejam。
• 学习使用不同的算法技术解决同一问题。
• 通过使用较低级别的操作实现语言的内置函数（例如 .sort()）来挑战自己。

---

结论

如果您在本文开始时还不知道什么是算法，那么希望您现在对这个有点难以捉摸的术语有了更具体的理解。作为专业开发人员，重要的是我们要了解我们编写的代码是可以分析和优化的，而且我们花时间对代码的性能进行分析也很重要。

你发现过什么有趣的算法练习题吗？也许是动态规划“背包问题”，或者“醉酒行走”？或者您可能知道 Ruby 中的一些递归最佳实践与 Python 中实现的相同函数不同。在评论中分享它们！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!