Dapatkan pemahaman yang lebih mendalam tentang asas reka bentuk algoritma-tutorial js-php.cn

Dapatkan pemahaman yang lebih mendalam tentang asas reka bentuk algoritma

Artikel ini akan menyelidiki prinsip reka bentuk algoritma. Jika anda tidak tahu apa yang saya maksudkan, teruskan membaca!

Apabila anda mendengar perkataan "algoritma," anda mungkin bertindak balas dalam salah satu daripada tiga cara:

Anda akan segera mengetahui dan memahami apa yang kami bincangkan kerana anda belajar sains komputer.
Anda tahu bahawa algoritma adalah tenaga kerja syarikat seperti Google dan Facebook, tetapi anda tidak pasti maksud perkataan itu.
Anda berlari dan bersembunyi dalam ketakutan kerana semua yang anda tahu tentang algoritma mengingatkan anda tentang mimpi ngeri kalkulus sekolah menengah anda.

Jika anda salah seorang daripada dua yang terakhir, maka artikel ini adalah untuk anda.

Apakah sebenarnya algoritma?

Algoritma tidak semestinya jenis operasi yang istimewa. Ia adalah konseptual, satu set langkah yang anda ambil dalam kod anda untuk mencapai matlamat tertentu.

Algoritma selalunya ditakrifkan hanya sebagai "arahan untuk menyelesaikan tugas." Mereka juga dipanggil "resipi". Dalam Rangkaian Sosial, Zuckerberg memerlukan algoritma untuk membuat Facemash berfungsi. Jika anda telah menonton filem itu, anda mungkin masih ingat melihat apa yang kelihatan seperti persamaan yang diconteng pada tingkap asrama Mark. Tetapi apakah kaitan algebra yang diconteng ini dengan tapak web mudah "Panas atau Tidak" Mark?

Algoritma sememangnya arahan. Mungkin penerangan yang lebih tepat ialah algoritma ialah corak untuk menyelesaikan tugasan dengan cekap. Facemash Zuckerberg ialah tapak pengundian yang digunakan untuk menentukan daya tarikan seseorang berbanding keseluruhan kumpulan, tetapi pengguna hanya boleh memilih antara dua orang. Mark Zuckerberg memerlukan algoritma untuk memutuskan orang yang sepadan antara satu sama lain dan cara menilai nilai undian berdasarkan sejarah terdahulu orang itu dan pesaing terdahulu. Ini memerlukan lebih intuisi daripada hanya mengira undi semua orang.

Sebagai contoh, andaikan anda ingin mencipta algoritma yang menambah 1 kepada sebarang nombor negatif, kemudian menolak 1 daripada sebarang nombor positif dan tidak melakukan apa-apa dengan 0. Anda boleh melakukan sesuatu seperti ini (menggunakan pseudokod gaya JavaScript):

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

Salin selepas log masuk

Anda mungkin berkata kepada diri sendiri: "Ini adalah satu fungsi." Algoritma tidak semestinya jenis operasi khas. Ia adalah konseptual - satu set langkah yang anda ambil dalam kod anda untuk mencapai matlamat tertentu.

Jadi mengapa mereka penting? Jelas sekali, menambah atau menolak 1 kepada nombor adalah perkara yang agak mudah.

Tetapi mari kita bercakap tentang carian. Untuk mencari nombor dalam susunan nombor, apakah yang akan anda lakukan? Cara mudah ialah dengan mengulang nombor, menyemak setiap nombor dengan nombor yang anda cari. Tetapi ini bukan penyelesaian yang cekap, dan julat masa penyiapan yang mungkin adalah luas, menjadikannya kaedah carian yang tidak stabil dan tidak boleh dipercayai apabila menskalakan kepada set carian yang besar.

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

Salin selepas log masuk

Nasib baik, kami boleh melakukan lebih baik dengan carian.

Mengapa ia tidak cekap?

Tiada cara yang lebih baik untuk menjadi pereka algoritma yang lebih baik daripada memahami dan menghargai algoritma dengan mendalam.

Andaikan tatasusunan anda mempunyai 50,000 entri dan anda melakukan carian brute force (iaitu carian dengan mengulangi keseluruhan tatasusunan). Dalam kes terbaik, entri yang anda cari akan menjadi entri pertama dalam tatasusunan 50,000 entri. Walau bagaimanapun, dalam kes yang paling teruk, algoritma akan mengambil masa 50,000 kali lebih lama untuk disiapkan berbanding dalam kes terbaik.

Jadi apa yang lebih baik?

Sebaliknya, anda boleh mencari menggunakan carian binari. Ini melibatkan pengisihan tatasusunan (saya akan biarkan anda memikirkannya sendiri), kemudian bahagikan tatasusunan kepada separuh dan semak sama ada nombor carian lebih besar atau kurang daripada tanda tengah dalam tatasusunan. Jika ia lebih besar daripada tanda tengah tatasusunan yang diisih, maka kita tahu bahawa separuh pertama boleh dibuang kerana nombor yang dicari bukan sebahagian daripada tatasusunan. Kami juga boleh mengurangkan banyak kerja dengan mentakrifkan sempadan luar tatasusunan dan menyemak sama ada nombor yang dicari wujud di luar sempadan ini, dan jika ia berlaku, kami mengambil berbilang lelaran dan mengubahnya menjadi satu lelaran (dalam Algoritma Brute Force memerlukan 50,000 operasi).

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);
    }
}

Salin selepas log masuk

Kedengarannya agak rumit

Ambil sifat kompleks algoritma carian binari tunggal dan gunakannya pada berbilion-bilion pautan yang mungkin (seperti melalui carian Google). Selain itu, mari kita gunakan beberapa jenis sistem kedudukan pada carian pautan ini untuk memberikan susunan halaman yang bertindak balas. Lebih baik lagi, gunakan beberapa jenis sistem "cadangan" yang kelihatan rawak berdasarkan model sosial AI yang direka untuk mengenal pasti orang yang mungkin anda ingin tambahkan sebagai rakan.

Ini memberi kita pemahaman yang lebih jelas tentang sebab algoritma bukan sekadar nama mewah untuk fungsi. Pada yang terbaik, mereka adalah cara yang bijak dan cekap untuk mencapai sesuatu yang lebih intuitif daripada penyelesaian yang paling jelas. Mereka boleh menukar tugas yang mungkin mengambil masa bertahun-tahun pada superkomputer kepada tugas yang boleh dilakukan dalam beberapa saat pada telefon mudah alih.

Bagaimanakah algoritma digunakan untuk saya?

Bagi kebanyakan kami pembangun, kami tidak mereka bentuk algoritma abstrak peringkat tinggi setiap hari.

幸运的是，我们站在前辈开发人员的肩膀上，他们编写了本机排序函数，并允许我们以有效的方式使用 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);
Salin selepas log masuk
如果您是一名 JavaScript 开发人员（并且使用 jQuery），并且您不知道上述函数在做什么以及它们有何显着不同，那么下一点适合您。

了解您的工具

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

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

了解环境

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

减少工作量

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

使用语言功能来减少操作（变量缓存、链接等）。

尽可能减少迭代循环嵌套。

尽可能在循环外部定义变量。

使用自动循环索引（如果可用）而不是手动索引。

使用巧妙的缩减技术（例如递归分治和查询优化）来最大限度地减少递归过程的规模。

学习先进技术

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

每周花一两个小时阅读《计算机编程的艺术》。

尝试 Facebook 编程挑战赛或 Google Codejam。

学习使用不同的算法技术解决同一问题。

通过使用较低级别的操作实现语言的内置函数（例如 .sort()）来挑战自己。

结论

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

你发现过什么有趣的算法练习题吗？也许是动态规划“背包问题”，或者“醉酒行走”？或者您可能知道 Ruby 中的一些递归最佳实践与 Python 中实现的相同函数不同。在评论中分享它们！
Atas ialah kandungan terperinci Dapatkan pemahaman yang lebih mendalam tentang asas reka bentuk algoritma. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!