Hey Habr! ຂ້າ​ພະ​ເຈົ້າ​ນໍາ​ສະ​ເຫນີ​ໃຫ້​ທ່ານ​ສົນ​ໃຈ​ການ​ແປ​ພາ​ສາ​ຂອງ​ບົດ​ຄວາມ​ໄດ້​
"ຖານຂໍ້ມູນທີ່ກ່ຽວຂ້ອງເຮັດວຽກແນວໃດ".

ໃນເວລາທີ່ມັນມາກັບຖານຂໍ້ມູນທີ່ກ່ຽວຂ້ອງຂ້າພະເຈົ້າບໍ່ສາມາດຊ່ວຍໄດ້ແຕ່ຄິດວ່າບາງສິ່ງບາງຢ່າງຫາຍໄປ. ພວກມັນຖືກນໍາໃຊ້ຢູ່ທົ່ວທຸກແຫ່ງ. ມີຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນຫຼາຍທີ່ມີຢູ່, ຈາກ SQLite ຂະຫນາດນ້ອຍແລະເປັນປະໂຫຍດເຖິງ Teradata ທີ່ມີປະສິດທິພາບ. ແຕ່ມີພຽງແຕ່ບົດຄວາມຈໍານວນຫນ້ອຍທີ່ອະທິບາຍວິທີການເຮັດວຽກຂອງຖານຂໍ້ມູນ. ທ່ານສາມາດຄົ້ນຫາຕົວເອງໂດຍໃຊ້ "howdoesarelationaldatabasework" ເພື່ອເບິ່ງວ່າມີຜົນໄດ້ຮັບຫຼາຍປານໃດ. ຍິ່ງໄປກວ່ານັ້ນ, ບົດຄວາມເຫຼົ່ານີ້ແມ່ນສັ້ນ. ຖ້າທ່ານກໍາລັງຊອກຫາເທກໂນໂລຍີ buzzy ຫລ້າສຸດ (BigData, NoSQL ຫຼື JavaScript), ທ່ານຈະພົບເຫັນບົດຄວາມທີ່ເລິກເຊິ່ງອະທິບາຍວິທີການເຮັດວຽກ.

ຖານຂໍ້ມູນທີ່ກ່ຽວຂ້ອງແມ່ນເກົ່າເກີນໄປແລະຫນ້າເບື່ອເກີນໄປທີ່ຈະອະທິບາຍຢູ່ນອກຫຼັກສູດວິທະຍາໄລ, ເອກະສານການຄົ້ນຄວ້າແລະຫນັງສື?

ໃນຖານະເປັນນັກພັດທະນາ, ຂ້ອຍກຽດຊັງການໃຊ້ສິ່ງທີ່ຂ້ອຍບໍ່ເຂົ້າໃຈ. ແລະຖ້າຖານຂໍ້ມູນໄດ້ຖືກນໍາໃຊ້ຫຼາຍກວ່າ 40 ປີ, ຕ້ອງມີເຫດຜົນ. ໃນຊຸມປີມໍ່ໆມານີ້, ຂ້າພະເຈົ້າໄດ້ໃຊ້ເວລາຫຼາຍຮ້ອຍຊົ່ວໂມງເພື່ອເຂົ້າໃຈຢ່າງແທ້ຈິງກ່ຽວກັບກ່ອງສີດໍາທີ່ແປກປະຫຼາດທີ່ຂ້າພະເຈົ້າໃຊ້ທຸກໆມື້. ຖານຂໍ້ມູນທີ່ກ່ຽວຂ້ອງ ຫນ້າສົນໃຈຫຼາຍເພາະວ່າພວກເຂົາ ອີງໃສ່ແນວຄວາມຄິດທີ່ເປັນປະໂຫຍດ ແລະໃຊ້ຄືນໄດ້. ຖ້າຫາກວ່າທ່ານມີຄວາມສົນໃຈໃນຄວາມເຂົ້າໃຈຖານຂໍ້ມູນ, ແຕ່ບໍ່ເຄີຍມີເວລາຫຼື inclination ກັບ delve ເຂົ້າໄປໃນຫົວຂໍ້ກ້ວາງນີ້, ທ່ານຄວນມີຄວາມສຸກບົດຄວາມນີ້.

ເຖິງແມ່ນວ່າຫົວຂໍ້ຂອງບົດຄວາມນີ້ຈະຊັດເຈນ, ຈຸດປະສົງຂອງບົດຄວາມນີ້ແມ່ນບໍ່ເຂົ້າໃຈວິທີການນໍາໃຊ້ຖານຂໍ້ມູນ. ດັ່ງນັ້ນ, ທ່ານຄວນຮູ້ວິທີການຂຽນຄໍາຮ້ອງຂໍການເຊື່ອມຕໍ່ແບບງ່າຍດາຍແລະການສອບຖາມພື້ນຖານ ດິບ; ຖ້າບໍ່ດັ່ງນັ້ນທ່ານອາດຈະບໍ່ເຂົ້າໃຈບົດຄວາມນີ້. ນັ້ນແມ່ນສິ່ງດຽວທີ່ເຈົ້າຕ້ອງການຮູ້, ຂ້ອຍຈະອະທິບາຍສ່ວນທີ່ເຫຼືອ.

ຂ້ອຍຈະເລີ່ມຕົ້ນດ້ວຍບາງພື້ນຖານວິທະຍາສາດຄອມພິວເຕີ, ເຊັ່ນ: ຄວາມຊັບຊ້ອນເວລາຂອງສູດການຄິດໄລ່ (BigO). ຂ້ອຍຮູ້ວ່າບາງຄົນຂອງເຈົ້າກຽດຊັງແນວຄິດນີ້, ແຕ່ຖ້າບໍ່ມີມັນເຈົ້າຈະບໍ່ສາມາດເຂົ້າໃຈຄວາມຊັບຊ້ອນພາຍໃນຖານຂໍ້ມູນ. ເນື່ອງຈາກວ່ານີ້ແມ່ນຫົວຂໍ້ໃຫຍ່, ຂ້ອຍຈະສຸມໃສ່ ສິ່ງທີ່ຂ້ອຍຄິດວ່າເປັນສິ່ງສໍາຄັນ: ວິທີການຖານຂໍ້ມູນຂະບວນການ SQL ການສອບຖາມ. ຂ້າພະເຈົ້າພຽງແຕ່ຈະແນະນໍາ ແນວຄວາມຄິດພື້ນຖານຂອງຖານຂໍ້ມູນດັ່ງນັ້ນໃນຕອນທ້າຍຂອງບົດຄວາມທີ່ທ່ານມີຄວາມຄິດຂອງສິ່ງທີ່ເກີດຂຶ້ນພາຍໃຕ້ການ hood ໄດ້.

ເນື່ອງຈາກວ່ານີ້ແມ່ນບົດຄວາມທີ່ຍາວນານແລະດ້ານວິຊາການທີ່ກ່ຽວຂ້ອງກັບຫຼາຍ algorithms ແລະໂຄງສ້າງຂໍ້ມູນ, ໃຊ້ເວລາຂອງທ່ານເພື່ອອ່ານມັນ. ບາງແນວຄວາມຄິດອາດຈະເຂົ້າໃຈຍາກ; ທ່ານສາມາດຂ້າມພວກມັນໄດ້ແລະຍັງໄດ້ຮັບຄວາມຄິດທົ່ວໄປ.

ສໍາລັບຄວາມຮູ້ຫຼາຍໃນບັນດາທ່ານ, ບົດຄວາມນີ້ແບ່ງອອກເປັນ 3 ສ່ວນ:

• ພາບລວມຂອງອົງປະກອບຖານຂໍ້ມູນລະດັບຕ່ໍາແລະລະດັບສູງ
• ພາບລວມຂອງຂະບວນການເພີ່ມປະສິດທິພາບແບບສອບຖາມ
• ພາບລວມຂອງທຸລະກໍາແລະການຄຸ້ມຄອງສະນຸກເກີ Buffer

ກັບໄປຫາພື້ນຖານ

ປີກ່ອນຫນ້ານີ້ (ໃນ galaxy ໄກ, ໄກ ...), ນັກພັດທະນາຕ້ອງຮູ້ຢ່າງແນ່ນອນວ່າຈໍານວນການດໍາເນີນງານທີ່ເຂົາເຈົ້າກໍາລັງເຂົ້າລະຫັດ. ເຂົາເຈົ້າຮູ້ວິທີ ແລະໂຄງສ້າງຂໍ້ມູນຂອງເຂົາເຈົ້າດ້ວຍຫົວໃຈ ເພາະວ່າເຂົາເຈົ້າບໍ່ສາມາດເສຍ CPU ແລະຫນ່ວຍຄວາມຈໍາຂອງຄອມພິວເຕີຊ້າຂອງເຂົາເຈົ້າ.

ໃນສ່ວນນີ້, ຂ້າພະເຈົ້າຈະເຕືອນທ່ານກ່ຽວກັບບາງແນວຄວາມຄິດເຫຼົ່ານີ້ຍ້ອນວ່າພວກເຂົາເປັນສິ່ງຈໍາເປັນທີ່ຈະເຂົ້າໃຈຖານຂໍ້ມູນ. ຂ້າພະເຈົ້າຍັງຈະແນະນໍາແນວຄວາມຄິດ ດັດຊະນີຖານຂໍ້ມູນ.

O(1) vs O(n2)

ໃນປັດຈຸບັນ, ນັກພັດທະນາຈໍານວນຫຼາຍບໍ່ສົນໃຈກັບຄວາມສັບສົນຂອງເວລາຂອງ algorithms ... ແລະພວກເຂົາຖືກຕ້ອງ!

ແຕ່ເມື່ອທ່ານກໍາລັງຈັດການກັບຂໍ້ມູນຈໍານວນຫລາຍ (ຂ້ອຍບໍ່ໄດ້ເວົ້າຫລາຍພັນຄົນ) ຫຼືຖ້າທ່ານມີຄວາມຫຍຸ້ງຍາກໃນ milliseconds, ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະເຂົ້າໃຈແນວຄວາມຄິດນີ້. ແລະຕາມທີ່ທ່ານສາມາດຈິນຕະນາການ, ຖານຂໍ້ມູນຕ້ອງຈັດການກັບທັງສອງສະຖານະການ! ຂ້າ​ພະ​ເຈົ້າ​ຈະ​ບໍ່​ເຮັດ​ໃຫ້​ທ່ານ​ໃຊ້​ເວ​ລາ​ເກີນ​ຄວາມ​ຈໍາ​ເປັນ​ເພື່ອ​ໃຫ້​ໄດ້​ຮັບ​ຈຸດ​ໃນ​ທົ່ວ. ນີ້ຈະຊ່ວຍໃຫ້ພວກເຮົາເຂົ້າໃຈແນວຄວາມຄິດຂອງການເພີ່ມປະສິດທິພາບໂດຍອີງໃສ່ຄ່າໃຊ້ຈ່າຍຕໍ່ມາ (ຄ່າໃຊ້ຈ່າຍ ອີງ ທີ່ດີທີ່ສຸດ).

ແນວຄິດ

ຄວາມສັບສົນຂອງເວລາຂອງສູດການຄິດໄລ່ ໃຊ້ເພື່ອເບິ່ງວ່າ algorithm ຈະໃຊ້ເວລາດົນປານໃດເພື່ອໃຫ້ສໍາເລັດສໍາລັບຈໍານວນຂໍ້ມູນທີ່ກໍານົດໄວ້. ເພື່ອອະທິບາຍຄວາມຊັບຊ້ອນນີ້, ພວກເຮົາໃຊ້ຕົວເລກທາງຄະນິດສາດໃຫຍ່ O. ໝາຍເຫດນີ້ຖືກໃຊ້ກັບຟັງຊັນທີ່ອະທິບາຍເຖິງການດຳເນີນງານທີ່ອັນກຣິທຶມຕ້ອງການສຳລັບຈຳນວນວັດສະດຸປ້ອນເຂົ້າ.

ຕົວຢ່າງ, ເມື່ອຂ້ອຍເວົ້າວ່າ "ສູດການຄິດໄລ່ນີ້ມີຄວາມຊັບຊ້ອນ O(some_function())", ມັນຫມາຍຄວາມວ່າ algorithm ຕ້ອງການ some_function(a_certain_amount_of_data) ເພື່ອປະມວນຜົນຂໍ້ມູນຈໍານວນທີ່ແນ່ນອນ.

ດັ່ງນັ້ນຈຶ່ງ ມັນ​ບໍ່​ແມ່ນ​ຈໍາ​ນວນ​ຂອງ​ຂໍ້​ມູນ​ທີ່​ສໍາ​ຄັນ **, ຖ້າບໍ່ດັ່ງນັ້ນ ** ຈໍານວນຂອງການດໍາເນີນງານເພີ່ມຂຶ້ນກັບປະລິມານຂໍ້ມູນເພີ່ມຂຶ້ນ. ຄວາມສັບສົນເວລາບໍ່ໄດ້ສະຫນອງຈໍານວນການປະຕິບັດທີ່ແນ່ນອນ, ແຕ່ເປັນວິທີທີ່ດີທີ່ຈະຄາດຄະເນເວລາປະຕິບັດ.

ໃນກາຟນີ້ທ່ານສາມາດເບິ່ງຈໍານວນການດໍາເນີນງານທຽບກັບຈໍານວນຂໍ້ມູນການປ້ອນຂໍ້ມູນສໍາລັບປະເພດທີ່ແຕກຕ່າງກັນຂອງຄວາມສັບສົນເວລາ algorithm. ຂ້ອຍໃຊ້ຂະໜາດ logarithmic ເພື່ອສະແດງພວກມັນ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຈໍານວນຂໍ້ມູນເພີ່ມຂຶ້ນຢ່າງໄວວາຈາກ 1 ຫາ 1 ຕື້. ພວກເຮົາສາມາດເຫັນໄດ້ວ່າ:

• O(1) ຫຼືຄວາມສັບສົນຄົງທີ່ຄົງທີ່ (ຖ້າບໍ່ດັ່ງນັ້ນມັນຈະບໍ່ຖືກເອີ້ນວ່າຄວາມສັບສົນຄົງທີ່).
• O(log(n)) ຍັງຄົງຕໍ່າເຖິງແມ່ນວ່າມີຂໍ້ມູນຫຼາຍຕື້.
• ຄວາມ​ຫຍຸ້ງ​ຍາກ​ທີ່​ສຸດ - O(n2), ບ່ອນທີ່ຈໍານວນຂອງການດໍາເນີນງານເພີ່ມຂຶ້ນຢ່າງໄວວາ.
• ອາການແຊກຊ້ອນອີກສອງອັນເພີ່ມຂຶ້ນຢ່າງໄວວາ.

ຕົວຢ່າງ

ດ້ວຍຂໍ້ມູນຈຳນວນໜ້ອຍ, ຄວາມແຕກຕ່າງລະຫວ່າງ O(1) ແລະ O(n2) ແມ່ນມີຄວາມລະເລີຍ. ຕົວຢ່າງ, ໃຫ້ເວົ້າວ່າທ່ານມີ algorithm ທີ່ຕ້ອງການປະມວນຜົນ 2000 ອົງປະກອບ.

• O(1) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 1 ການດໍາເນີນງານ
• O(log(n)) algorithm ຈະເຮັດໃຫ້ທ່ານມີ 7 ການດໍາເນີນງານ
• O(n) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 2 ການດໍາເນີນງານ
• O(n*log(n)) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 14 ການດໍາເນີນງານ
• O(n2) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 4 ການດໍາເນີນງານ

ຄວາມແຕກຕ່າງລະຫວ່າງ O(1) ແລະ O(n2) ເບິ່ງຄືວ່າໃຫຍ່ (4 ລ້ານການດໍາເນີນງານ) ແຕ່ທ່ານຈະສູນເສຍການສູງສຸດ 2 ms, ພຽງແຕ່ໃຊ້ເວລາທີ່ຈະກະພິບຕາຂອງທ່ານ. ແທ້ຈິງແລ້ວ, ໂຮງງານຜະລິດທີ່ທັນສະໄຫມສາມາດປຸງແຕ່ງ ຫຼາຍຮ້ອຍລ້ານການດໍາເນີນງານຕໍ່ວິນາທີ. ນີ້ແມ່ນເຫດຜົນທີ່ວ່າການປະຕິບັດແລະການເພີ່ມປະສິດທິພາບບໍ່ແມ່ນບັນຫາໃນຫຼາຍໆໂຄງການ IT.

ດັ່ງທີ່ຂ້າພະເຈົ້າເວົ້າ, ມັນຍັງມີຄວາມສໍາຄັນທີ່ຈະຮູ້ແນວຄວາມຄິດນີ້ໃນເວລາທີ່ເຮັດວຽກກັບຂໍ້ມູນຈໍານວນຫລາຍ. ຖ້າເວລານີ້ algorithm ຕ້ອງປະມວນຜົນ 1 ອົງປະກອບ (ເຊິ່ງບໍ່ແມ່ນຫຼາຍສໍາລັບຖານຂໍ້ມູນ):

• O(1) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 1 ການດໍາເນີນງານ
• O(log(n)) algorithm ຈະເຮັດໃຫ້ທ່ານມີ 14 ການດໍາເນີນງານ
• O(n) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 1 ການດໍາເນີນງານ
• O(n*log(n)) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 14 ການດໍາເນີນງານ.
• O(n2) algorithm ຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ 1 ການດໍາເນີນງານ.

ຂ້າ​ພະ​ເຈົ້າ​ບໍ່​ໄດ້​ເຮັດ​ຄະ​ນິດ​ສາດ​, ແຕ່​ຂ້າ​ພະ​ເຈົ້າ​ຈະ​ເວົ້າ​ວ່າ​ດ້ວຍ O(n2) algorithm ທ່ານ​ມີ​ເວ​ລາ​ທີ່​ຈະ​ດື່ມ​ກາ​ເຟ (ແມ້​ແຕ່​ສອງ​!). ຖ້າທ່ານເພີ່ມ 0 ອື່ນໃສ່ປະລິມານຂໍ້ມູນ, ເຈົ້າຈະມີເວລານອນຫຼັບ.

ໃຫ້ເລິກໄປກວ່ານີ້

ສໍາລັບການອ້າງອິງ:

• ການຊອກຫາຕາຕະລາງ hash ທີ່ດີຊອກຫາອົງປະກອບໃນ O(1).
• ການຊອກຫາຕົ້ນໄມ້ທີ່ມີຄວາມສົມດູນດີຈະໃຫ້ຜົນໄດ້ຮັບໃນ O(log(n)).
• ການຊອກຫາ array ສ້າງຜົນໄດ້ຮັບໃນ O(n).
• ຂັ້ນຕອນການຈັດຮຽງທີ່ດີທີ່ສຸດມີຄວາມຊັບຊ້ອນ O(n*log(n)).
• ຂັ້ນຕອນການຈັດຮຽງທີ່ບໍ່ດີມີຄວາມຊັບຊ້ອນ O(n2).

ຫມາຍເຫດ: ໃນພາກສ່ວນຕໍ່ໄປນີ້ພວກເຮົາຈະເຫັນ algorithms ແລະໂຄງສ້າງຂໍ້ມູນເຫຼົ່ານີ້.

ມີຫຼາຍປະເພດຂອງຄວາມສັບສົນເວລາ algorithm:

• ກໍລະນີສະເລ່ຍ
• ກໍລະນີທີ່ດີທີ່ສຸດ
• ແລະສະຖານະການກໍລະນີຮ້າຍແຮງທີ່ສຸດ

ຄວາມສັບສົນເວລາມັກຈະເປັນກໍລະນີທີ່ຮ້າຍແຮງທີ່ສຸດ.

ຂ້າ​ພະ​ເຈົ້າ​ພຽງ​ແຕ່​ເວົ້າ​ກ່ຽວ​ກັບ​ຄວາມ​ສັບ​ສົນ​ຂອງ​ເວ​ລາ​ຂອງ​ວິ​ທີ​ການ​, ແຕ່​ຄວາມ​ສັບ​ສົນ​ຍັງ​ນໍາ​ໃຊ້​ກັບ​:

• ການບໍລິໂພກຄວາມຊົງຈໍາຂອງ algorithm
• ຂັ້ນຕອນການບໍລິໂພກດິສກ໌ I/O

ແນ່ນອນ, ມີອາການແຊກຊ້ອນທີ່ຮ້າຍແຮງກວ່າ n2, ຕົວຢ່າງ:

• n4: ອັນນີ້ຂີ້ຮ້າຍ! ບາງ algorithms ທີ່ໄດ້ກ່າວມາມີຄວາມຊັບຊ້ອນນີ້.
• 3n: ອັນນີ້ຍິ່ງຮ້າຍແຮງ! ຫນຶ່ງໃນ algorithms ທີ່ພວກເຮົາຈະເຫັນຢູ່ເຄິ່ງກາງຂອງບົດຄວາມນີ້ມີຄວາມສັບສົນນີ້ (ແລະຕົວຈິງແລ້ວມັນຖືກນໍາໃຊ້ໃນຫຼາຍຖານຂໍ້ມູນ).
• factorial n: ທ່ານຈະບໍ່ເຄີຍໄດ້ຮັບຜົນໄດ້ຮັບຂອງທ່ານເຖິງແມ່ນວ່າມີຂໍ້ມູນຈໍານວນນ້ອຍໆ.
• nn: ຖ້າເຈົ້າພົບຄວາມຊັບຊ້ອນນີ້ ເຈົ້າຄວນຖາມຕົວເອງວ່າ ນີ້ແມ່ນກິດຈະກຳຂອງເຈົ້າແທ້ໆບໍ...

ຫມາຍເຫດ: ຂ້າພະເຈົ້າບໍ່ໄດ້ໃຫ້ຄໍານິຍາມທີ່ແທ້ຈິງຂອງການອອກແບບ O ໃຫຍ່, ພຽງແຕ່ຄວາມຄິດ. ທ່ານສາມາດອ່ານບົດຄວາມນີ້ໄດ້ທີ່ Wikipedia ສໍາລັບຄໍານິຍາມທີ່ແທ້ຈິງ (asymptotic).

MergeSort

ເຈົ້າເຮັດຫຍັງເມື່ອທ່ານຕ້ອງການຈັດຮຽງຄໍເລັກຊັນ? ແມ່ນ​ຫຍັງ? ເຈົ້າເອີ້ນຟັງຊັນ sort()... ໂອເຄ, ຄຳຕອບທີ່ດີ... ແຕ່ສຳລັບຖານຂໍ້ມູນ, ເຈົ້າຕ້ອງເຂົ້າໃຈວິທີການເຮັດວຽກຂອງ sort() ນີ້.

ມີຫຼາຍວິທີການຈັດຮຽງທີ່ດີ, ສະນັ້ນຂ້ອຍຈະເນັ້ນໃສ່ສິ່ງທີ່ສຳຄັນທີ່ສຸດ: ຮວມການຈັດລຽງ. ທ່ານອາດຈະບໍ່ເຂົ້າໃຈວ່າເປັນຫຍັງການຈັດລຽງຂໍ້ມູນຈຶ່ງເປັນປະໂຫຍດໃນປັດຈຸບັນ, ແຕ່ທ່ານຄວນຫຼັງຈາກພາກສ່ວນການເພີ່ມປະສິດທິພາບການສອບຖາມ. ຍິ່ງໄປກວ່ານັ້ນ, ຄວາມເຂົ້າໃຈການຈັດລຽງການລວມກັນຈະຊ່ວຍໃຫ້ພວກເຮົາເຂົ້າໃຈໃນພາຍຫລັງການເຂົ້າຮ່ວມຖານຂໍ້ມູນທົ່ວໄປທີ່ເອີ້ນວ່າ ລວມ ເຂົ້າຮ່ວມ (ການ​ຮ່ວມ​ມື​ສະ​ມາ​ຄົມ​).

ຮວມ

ເຊັ່ນດຽວກັນກັບສູດການຄິດໄລ່ທີ່ເປັນປະໂຫຍດຫຼາຍ, ການຈັດລຽງການລວມແມ່ນອີງໃສ່ trick: ການລວມ 2 arrays ທີ່ຈັດຮຽງຂະຫນາດ N/2 ເຂົ້າໄປໃນ N-element array ທີ່ມີຄ່າໃຊ້ຈ່າຍພຽງແຕ່ N ການດໍາເນີນງານ. ການດໍາເນີນງານນີ້ເອີ້ນວ່າການລວມເຂົ້າກັນ.

ໃຫ້ເບິ່ງວ່ານີ້ຫມາຍຄວາມວ່າແນວໃດກັບຕົວຢ່າງງ່າຍໆ:

ຕົວ​ເລກ​ນີ້​ສະ​ແດງ​ໃຫ້​ເຫັນ​ວ່າ​ເພື່ອ​ສ້າງ​ອາ​ເຣ 8 ອົງ​ປະ​ກອບ​ທີ່​ຈັດ​ລຽງ​ລໍາ​ດັບ​ສຸດ​ທ້າຍ​, ທ່ານ​ພຽງ​ແຕ່​ຕ້ອງ​ການ​ທີ່​ຈະ iterate ຄັ້ງ​ດຽວ​ໃນ​ໄລ​ຍະ 2 4 arrays​. ເນື່ອງຈາກທັງສອງ 4-element arrays ຖືກຈັດຮຽງແລ້ວ:

• 1​) ທ່ານ​ສົມ​ທຽບ​ທັງ​ສອງ​ອົງ​ປະ​ກອບ​ໃນ​ປະ​ຈຸ​ບັນ​ໃນ​ສອງ​ອາ​ເຣ (ໃນ​ຕອນ​ຕົ້ນ​ປະ​ຈຸ​ບັນ = ຄັ້ງ​ທໍາ​ອິດ​)
• 2) ຫຼັງຈາກນັ້ນເອົາອັນນ້ອຍທີ່ສຸດມາໃສ່ໃນ 8 ອົງປະກອບ array
• 3) ແລະຍ້າຍໄປອົງປະກອບຕໍ່ໄປໃນ array ບ່ອນທີ່ທ່ານເອົາອົງປະກອບທີ່ນ້ອຍທີ່ສຸດ
• ແລະເຮັດຊ້ຳ 1,2,3 ຈົນກວ່າເຈົ້າຈະໄປຮອດອົງປະກອບສຸດທ້າຍຂອງໜຶ່ງໃນອາເຣ.
• ຫຼັງຈາກນັ້ນ, ທ່ານເອົາອົງປະກອບທີ່ຍັງເຫຼືອຂອງ array ອື່ນໆເພື່ອໃຫ້ພວກເຂົາເຂົ້າໄປໃນ 8 ອົງປະກອບ array.

ນີ້ເຮັດວຽກເພາະວ່າທັງສອງ array 4 ອົງປະກອບຖືກຈັດຮຽງແລະດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງ "ກັບຄືນ" ໃນ array ເຫຼົ່ານັ້ນ.

ໃນປັດຈຸບັນທີ່ພວກເຮົາເຂົ້າໃຈ trick, ນີ້ແມ່ນ pseudocode ຂອງຂ້ອຍສໍາລັບການລວມ:

array mergeSort(array a)
   if(length(a)==1)
      return a[0];
   end if

   //recursive calls
   [left_array right_array] := split_into_2_equally_sized_arrays(a);
   array new_left_array := mergeSort(left_array);
   array new_right_array := mergeSort(right_array);

   //merging the 2 small ordered arrays into a big one
   array result := merge(new_left_array,new_right_array);
   return result;

Merge sort breaks a problem into smaller problems and then find the results of the smaller problems to get the result of the original problems (ຫມາຍ​ເຫດ: ປະເພດຂອງ algorithm ນີ້ເອີ້ນວ່າການແບ່ງແລະ conquer). ຖ້າທ່ານບໍ່ເຂົ້າໃຈ algorithm ນີ້, ຢ່າກັງວົນ; ຂ້ອຍບໍ່ເຂົ້າໃຈມັນເທື່ອທໍາອິດທີ່ຂ້ອຍເຫັນມັນ. ຖ້າມັນສາມາດຊ່ວຍເຈົ້າໄດ້, ຂ້ອຍເຫັນ algorithm ນີ້ແມ່ນ algorithm ສອງໄລຍະ:

• ໄລຍະການແບ່ງ, ບ່ອນທີ່ array ຖືກແບ່ງອອກເປັນ array ນ້ອຍກວ່າ
• ໄລຍະການຈັດລຽງແມ່ນບ່ອນທີ່ອາເຣຂະຫນາດນ້ອຍຖືກລວມເຂົ້າກັນ (ໂດຍນໍາໃຊ້ສະຫະພາບ) ເພື່ອສ້າງເປັນອາເຣທີ່ໃຫຍ່ກວ່າ.

ໄລຍະການແບ່ງ

ໃນຂັ້ນຕອນການແບ່ງ, array ຖືກແບ່ງອອກເປັນ array unitary ໃນ 3 ຂັ້ນຕອນ. ຈໍານວນຂັ້ນຕອນຢ່າງເປັນທາງການແມ່ນບັນທຶກ(N) (ນັບຕັ້ງແຕ່ N=8, ບັນທຶກ(N) = 3).

ຂ້ອຍຮູ້ເລື່ອງນີ້ໄດ້ແນວໃດ?

ຂ້ອຍເປັນຄົນອັດສະລິຍະ! ໃນຄໍາສັບໃດຫນຶ່ງ - ຄະນິດສາດ. ຄວາມຄິດແມ່ນວ່າແຕ່ລະຂັ້ນຕອນແບ່ງຂະຫນາດຂອງອາເລຕົ້ນສະບັບໂດຍ 2. ຈໍານວນຂັ້ນຕອນແມ່ນຈໍານວນເວລາທີ່ທ່ານສາມາດແບ່ງອາເຣຕົ້ນສະບັບເປັນສອງ. ນີ້ແມ່ນຄໍານິຍາມທີ່ແນ່ນອນຂອງ logarithm (ຖານ 2).

ໄລຍະການຈັດລຽງ

ໃນ​ໄລ​ຍະ​ການ​ຈັດ​ລຽງ​ລໍາ​ດັບ​, ທ່ານ​ເລີ່ມ​ຕົ້ນ​ດ້ວຍ​ອາ​ເຣ unitary (ອົງ​ປະ​ກອບ​ດຽວ​)​. ໃນ​ລະ​ຫວ່າງ​ແຕ່​ລະ​ຂັ້ນ​ຕອນ​ທີ່​ທ່ານ​ນໍາ​ໃຊ້​ການ​ດໍາ​ເນີນ​ງານ​ລວມ​ຫຼາຍ​ແລະ​ຄ່າ​ໃຊ້​ຈ່າຍ​ທັງ​ຫມົດ​ແມ່ນ N = 8 ການ​ດໍາ​ເນີນ​ງານ​:

• ໃນ​ຂັ້ນ​ຕອນ​ທໍາ​ອິດ​ທີ່​ທ່ານ​ມີ 4 ລວມ​ທີ່​ມີ​ລາ​ຄາ​ຖືກ 2 ການ​ດໍາ​ເນີນ​ງານ​ແຕ່​ລະ​
• ໃນຂັ້ນຕອນທີສອງ, ທ່ານມີ 2 ຜະສົມຜະສານທີ່ມີຄ່າໃຊ້ຈ່າຍ 4 ການດໍາເນີນງານແຕ່ລະຄົນ
• ໃນ​ຂັ້ນ​ຕອນ​ທີ​ສາມ​ທີ່​ທ່ານ​ມີ 1 merge ທີ່​ມີ​ຄ່າ​ໃຊ້​ຈ່າຍ 8 ການ​ດໍາ​ເນີນ​ງານ​

ເນື່ອງ​ຈາກ​ວ່າ​ມີ​ບັນ​ທຶກ (N​) ຂັ້ນ​ຕອນ​, ຄ່າ​ໃຊ້​ຈ່າຍ​ທັງ​ຫມົດ N * log(N) ການດໍາເນີນງານ.

ຂໍ້ໄດ້ປຽບຂອງການຈັດລຽງລວມ

ເປັນຫຍັງສູດການຄິດໄລ່ນີ້ຈຶ່ງມີພະລັງຫຼາຍ?

ເນື່ອງຈາກວ່າ:

• ທ່ານ​ສາ​ມາດ​ປ່ຽນ​ແປງ​ມັນ​ເພື່ອ​ຫຼຸດ​ຜ່ອນ​ຮອຍ​ຄວາມ​ຊົງ​ຈໍາ​ດັ່ງ​ນັ້ນ​ທ່ານ​ບໍ່​ໄດ້​ສ້າງ​ອາ​ເຣ​ໃຫມ່​ແຕ່​ການ​ແກ້​ໄຂ array ການ​ປ້ອນ​ຂໍ້​ມູນ​ໂດຍ​ກົງ​.

ຫມາຍເຫດ: ປະເພດຂອງສູດການຄິດໄລ່ນີ້ເອີ້ນວ່າ in-ສະຖານທີ່ (ຈັດຮຽງໂດຍບໍ່ມີຄວາມຊົງຈໍາເພີ່ມເຕີມ).

• ທ່ານ​ສາ​ມາດ​ປ່ຽນ​ມັນ​ເພື່ອ​ນໍາ​ໃຊ້​ພື້ນ​ທີ່​ແຜ່ນ​ແລະ​ຈໍາ​ນວນ​ຂະ​ຫນາດ​ນ້ອຍ​ຂອງ​ຫນ່ວຍ​ຄວາມ​ຈໍາ​ໃນ​ເວ​ລາ​ດຽວ​ກັນ​ໂດຍ​ບໍ່​ມີ​ການ​ເກີດ​ອຸ​ປະ​ກອນ I/O ແຜ່ນ​ທີ່​ສໍາ​ຄັນ​. ແນວຄວາມຄິດແມ່ນເພື່ອໂຫລດເຂົ້າໄປໃນຫນ່ວຍຄວາມຈໍາພຽງແຕ່ພາກສ່ວນທີ່ກໍາລັງດໍາເນີນການໃນປະຈຸບັນ. ນີ້ເປັນສິ່ງສໍາຄັນໃນເວລາທີ່ທ່ານຕ້ອງການຈັດລຽງຕາຕະລາງຫຼາຍກິກາໄບທີ່ມີພຽງແຕ່ 100-megabyte buffer ຫນ່ວຍຄວາມຈໍາ.

ຫມາຍເຫດ: ປະເພດຂອງສູດການຄິດໄລ່ນີ້ເອີ້ນວ່າ ການຈັດລຽງພາຍນອກ.

• ທ່ານສາມາດປ່ຽນມັນໃຫ້ແລ່ນໃນຫຼາຍຂະບວນການ/ກະທູ້/ເຊີບເວີ.

ຕົວຢ່າງ, ການຈັດລຽງການລວມທີ່ແຈກຢາຍແມ່ນຫນຶ່ງໃນອົງປະກອບທີ່ສໍາຄັນ Hadoop (ເຊິ່ງເປັນໂຄງສ້າງໃນຂໍ້ມູນໃຫຍ່).

• ສູດການຄິດໄລ່ນີ້ສາມາດປ່ຽນນໍາໄປສູ່ຄໍາ (ແທ້ໆ!).

ສູດການຮຽງລໍາດັບນີ້ຖືກນໍາໃຊ້ໃນຖານຂໍ້ມູນສ່ວນໃຫຍ່ (ຖ້າບໍ່ແມ່ນທັງຫມົດ), ແຕ່ມັນບໍ່ແມ່ນອັນດຽວ. ຖ້າທ່ານຕ້ອງການຮູ້ເພີ່ມເຕີມ, ທ່ານສາມາດອ່ານໄດ້ ວຽກຄົ້ນຄ້ວາ, ເຊິ່ງປຶກສາຫາລືຂໍ້ດີແລະຂໍ້ເສຍຂອງລະບົບການຈັດຮຽງຖານຂໍ້ມູນທົ່ວໄປ.

ຕາຕະລາງ Array, Tree ແລະ Hash

ໃນປັດຈຸບັນທີ່ພວກເຮົາເຂົ້າໃຈແນວຄວາມຄິດຂອງຄວາມສັບສົນທີ່ໃຊ້ເວລາແລະການຈັດລຽງ, ຂ້າພະເຈົ້າຄວນບອກທ່ານກ່ຽວກັບ 3 ໂຄງສ້າງຂໍ້ມູນ. ນີ້ແມ່ນສິ່ງສໍາຄັນເພາະວ່າພວກເຂົາ ແມ່ນພື້ນຖານຂອງຖານຂໍ້ມູນທີ່ທັນສະໄຫມ. ຂ້າພະເຈົ້າຍັງຈະແນະນໍາແນວຄວາມຄິດ ດັດຊະນີຖານຂໍ້ມູນ.

ອາເລ

array ສອງມິຕິແມ່ນໂຄງສ້າງຂໍ້ມູນທີ່ງ່າຍທີ່ສຸດ. ຕາຕະລາງສາມາດຄິດວ່າເປັນ array. ຍົກ​ຕົວ​ຢ່າງ:

ອາເຣ 2 ມິຕິນີ້ແມ່ນຕາຕະລາງທີ່ມີແຖວ ແລະຖັນ:

• ແຕ່ລະແຖວສະແດງເຖິງນິຕິບຸກຄົນ
• ຖັນເກັບຮັກສາຄຸນສົມບັດທີ່ອະທິບາຍເຖິງນິຕິບຸກຄົນ.
• ແຕ່ລະຖັນເກັບຂໍ້ມູນຂອງປະເພດສະເພາະ (ຈຳນວນເຕັມ, ສະຕຣິງ, ວັນທີ...).

ນີ້ແມ່ນສະດວກສໍາລັບການເກັບຮັກສາແລະການເບິ່ງເຫັນຂໍ້ມູນ, ຢ່າງໃດກໍຕາມ, ໃນເວລາທີ່ທ່ານຈໍາເປັນຕ້ອງຊອກຫາມູນຄ່າສະເພາະໃດຫນຶ່ງ, ນີ້ບໍ່ເຫມາະສົມ.

ສໍາລັບຕົວຢ່າງ, ຖ້າທ່ານຕ້ອງການຊອກຫາຜູ້ຊາຍທັງຫມົດທີ່ເຮັດວຽກຢູ່ໃນອັງກິດ, ທ່ານຈໍາເປັນຕ້ອງເບິ່ງແຕ່ລະແຖວເພື່ອກໍານົດວ່າແຖວນັ້ນເປັນຂອງອັງກິດ. ມັນຈະເຮັດໃຫ້ທ່ານມີຄ່າໃຊ້ຈ່າຍ N ການເຮັດທຸລະກໍາບ່ອນທີ່ N - ຈໍາ​ນວນ​ຂອງ​ສາຍ​, ຊຶ່ງ​ບໍ່​ແມ່ນ​ບໍ່​ດີ​, ແຕ່​ວ່າ​ຈະ​ມີ​ວິ​ທີ​ທີ່​ໄວ​ກວ່າ​? ດຽວນີ້ເຖິງເວລາແລ້ວທີ່ພວກເຮົາຈະທຳຄວາມຮູ້ຈັກກັບຕົ້ນໄມ້.

ຫມາຍເຫດ: ຖານຂໍ້ມູນທີ່ທັນສະໄຫມສ່ວນໃຫຍ່ສະຫນອງ arrays ຂະຫຍາຍສໍາລັບການເກັບຮັກສາຕາຕະລາງຢ່າງມີປະສິດທິພາບ: heap-organizedtables ແລະ index-organizedtables. ແຕ່ນີ້ບໍ່ໄດ້ປ່ຽນບັນຫາຂອງການຊອກຫາເງື່ອນໄຂສະເພາະໃດຫນຶ່ງໃນກຸ່ມຂອງຖັນຢ່າງໄວວາ.

ຕົ້ນໄມ້ຖານຂໍ້ມູນແລະດັດຊະນີ

ຕົ້ນໄມ້ຄົ້ນຫາໄບນາຣີແມ່ນຕົ້ນໄມ້ຄູ່ທີ່ມີຄຸນສົມບັດພິເສດ, ກຸນແຈໃນແຕ່ລະ node ຈະຕ້ອງເປັນ:

• ໃຫຍ່ກວ່າກະແຈທັງໝົດທີ່ເກັບໄວ້ໃນຕົ້ນໄມ້ຍ່ອຍຊ້າຍ
• ໜ້ອຍກວ່າກະແຈທັງໝົດທີ່ເກັບໄວ້ໃນຕົ້ນໄມ້ຍ່ອຍທີ່ຖືກຕ້ອງ

ໃຫ້ເຮົາເບິ່ງວ່າອັນນີ້ຫມາຍຄວາມວ່າແນວໃດ

Idea

ຕົ້ນໄມ້ນີ້ມີ N = 15 ອົງປະກອບ. ໃຫ້ເວົ້າວ່າຂ້ອຍກໍາລັງຊອກຫາ 208:

• ຂ້ອຍເລີ່ມຕົ້ນທີ່ຮາກທີ່ລະຫັດແມ່ນ 136. ນັບຕັ້ງແຕ່ 136<208, ຂ້ອຍເບິ່ງຢູ່ໃນຫົວຂໍ້ຍ່ອຍທີ່ຖືກຕ້ອງຂອງ node 136.
• 398> 208 ດັ່ງນັ້ນຂ້ອຍກໍາລັງເບິ່ງຕົ້ນໄມ້ຍ່ອຍຊ້າຍຂອງ node 398
• 250> 208 ດັ່ງນັ້ນຂ້ອຍກໍາລັງເບິ່ງຕົ້ນໄມ້ຍ່ອຍຊ້າຍຂອງ node 250
• 200<208, ສະນັ້ນຂ້າພະເຈົ້າກໍາລັງຊອກຫາຢູ່ໃນ subtree ສິດທິຂອງ node 200. ແຕ່ 200 ບໍ່ມີ subtree ສິດ, ຄ່າບໍ່ມີຢູ່ (ເພາະວ່າຖ້າມັນມີຢູ່, ມັນຈະຢູ່ໃນຕົ້ນໄມ້ຍ່ອຍທີ່ຖືກຕ້ອງ 200).

ຕອນນີ້ໃຫ້ເວົ້າວ່າຂ້ອຍກໍາລັງຊອກຫາ 40

• ຂ້ອຍເລີ່ມຕົ້ນທີ່ຮາກທີ່ລະຫັດແມ່ນ 136. ຕັ້ງແຕ່ 136 > 40, ຂ້ອຍເບິ່ງຢູ່ໃນແຖບຍ່ອຍຊ້າຍຂອງ node 136.
• 80 > 40, ເພາະສະນັ້ນ, ຂ້ອຍກໍາລັງເບິ່ງຕົ້ນໄມ້ຍ່ອຍຊ້າຍຂອງ node 80
• 40= 40, node ມີຢູ່. ຂ້ອຍດຶງເອົາ ID ແຖວພາຍໃນ node (ບໍ່ສະແດງຢູ່ໃນຮູບ) ແລະເບິ່ງຢູ່ໃນຕາຕະລາງສໍາລັບ ID ແຖວທີ່ໃຫ້.
• ການຮູ້ ID ແຖວເຮັດໃຫ້ຂ້ອຍຮູ້ແນ່ນອນວ່າຂໍ້ມູນຢູ່ໃນຕາຕະລາງ, ດັ່ງນັ້ນຂ້ອຍສາມາດດຶງຂໍ້ມູນໄດ້ທັນທີ.

ໃນທີ່ສຸດ, ການຄົ້ນຫາທັງສອງຈະເຮັດໃຫ້ຂ້ອຍມີຈໍານວນລະດັບພາຍໃນຕົ້ນໄມ້. ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ອ່ານ​ພາກ​ສ່ວນ​ກ່ຽວ​ກັບ​ການ​ຈັດ​ລຽງ​ລວມ​ລະ​ມັດ​ລະ​ວັງ​, ທ່ານ​ຄວນ​ຈະ​ເບິ່ງ​ວ່າ​ມີ​ລະ​ດັບ log(N​)​. ມັນ turns ອອກ, ບັນທຶກຄ່າໃຊ້ຈ່າຍໃນການຄົ້ນຫາ (N), ບໍ່​ດີ!

ໃຫ້ກັບຄືນໄປຫາບັນຫາຂອງພວກເຮົາ

ແຕ່ນີ້ແມ່ນບໍ່ມີຕົວຕົນຫຼາຍ, ສະນັ້ນໃຫ້ພວກເຮົາກັບຄືນໄປຫາບັນຫາຂອງພວກເຮົາ. ແທນ​ທີ່​ຈະ​ເປັນ​ຈໍາ​ນວນ​ເຕັມ​ງ່າຍ​ດາຍ​, ຈິນ​ຕະ​ນາ​ການ​ສະ​ຕ​ຣິງ​ທີ່​ເປັນ​ຕົວ​ແທນ​ຂອງ​ປະ​ເທດ​ຂອງ​ຜູ້​ໃດ​ຜູ້​ຫນຶ່ງ​ໃນ​ຕາ​ຕະ​ລາງ​ກ່ອນ​ຫນ້າ​ນີ້​. ໃຫ້ເວົ້າວ່າທ່ານມີຕົ້ນໄມ້ທີ່ປະກອບດ້ວຍພາກສະຫນາມ "ປະເທດ" (ຄໍລໍາ 3) ຂອງຕາຕະລາງ:

• ຖ້າທ່ານຕ້ອງການຮູ້ວ່າຜູ້ທີ່ເຮັດວຽກຢູ່ໃນອັງກິດ
• ທ່ານເບິ່ງຕົ້ນໄມ້ເພື່ອໃຫ້ໄດ້ຮັບຂໍ້ທີ່ເປັນຕົວແທນຂອງ Great Britain
• ພາຍໃນ "UKnode" ທ່ານຈະພົບເຫັນສະຖານທີ່ຂອງບັນທຶກພະນັກງານອັງກິດ.

ການຄົ້ນຫານີ້ຈະມີຄ່າໃຊ້ຈ່າຍຕໍ່ການດໍາເນີນງານ log(N) ແທນທີ່ຈະດໍາເນີນການ N ຖ້າທ່ານໃຊ້ array ໂດຍກົງ. ສິ່ງທີ່ທ່ານພຽງແຕ່ນໍາສະເຫນີແມ່ນ ດັດຊະນີຖານຂໍ້ມູນ.

ທ່ານ​ສາ​ມາດ​ສ້າງ​ຕົ້ນ​ໄມ້​ດັດ​ຊະ​ນີ​ສໍາ​ລັບ​ກຸ່ມ​ຂອງ​ພາກ​ສະ​ຫນາມ​ໃດ​ຫນຶ່ງ (string​, ຈໍາ​ນວນ​, 2 ສາຍ​, ຈໍາ​ນວນ​ແລະ​ສະ​ຕ​ຣິງ​, ວັນ​ທີ ... ) ຕາບ​ໃດ​ທີ່​ທ່ານ​ມີ​ຫນ້າ​ທີ່​ເພື່ອ​ປຽບ​ທຽບ​ກະ​ແຈ (ເຊັ່ນ​: ກຸ່ມ​ພາກ​ສະ​ຫນາມ​) ດັ່ງ​ນັ້ນ​ທ່ານ​ສາ​ມາດ​ກໍາ​ນົດ ສັ່ງລະຫວ່າງກະແຈ (ເຊິ່ງເປັນກໍລະນີສໍາລັບປະເພດພື້ນຖານໃດໆໃນຖານຂໍ້ມູນ).

B+TreeIndex

ໃນຂະນະທີ່ຕົ້ນໄມ້ນີ້ເຮັດວຽກໄດ້ດີສໍາລັບການໄດ້ຮັບຄ່າສະເພາະ, ມີບັນຫາໃຫຍ່ໃນເວລາທີ່ທ່ານຕ້ອງການ ໄດ້ຮັບຫຼາຍອົງປະກອບລະຫວ່າງສອງຄ່າ. ນີ້ຈະມີຄ່າໃຊ້ຈ່າຍ O(N) ເພາະວ່າທ່ານຈະຕ້ອງເບິ່ງແຕ່ລະ node ໃນຕົ້ນໄມ້ແລະກວດເບິ່ງວ່າມັນຢູ່ລະຫວ່າງສອງຄ່ານີ້ຫຼືບໍ່ (ເຊັ່ນ: ມີການສັ່ງຂ້າມຕົ້ນໄມ້). ຍິ່ງ​ໄປ​ກວ່າ​ນັ້ນ​, ການ​ດໍາ​ເນີນ​ງານ​ນີ້​ບໍ່​ແມ່ນ​ແຜ່ນ I / O ເປັນ​ມິດ​ເນື່ອງ​ຈາກ​ວ່າ​ທ່ານ​ຕ້ອງ​ໄດ້​ອ່ານ​ຕົ້ນ​ໄມ້​ທັງ​ຫມົດ​. ພວກເຮົາຈໍາເປັນຕ້ອງຊອກຫາວິທີທີ່ຈະປະຕິບັດຢ່າງມີປະສິດທິພາບ ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ລະ​ດັບ​. ເພື່ອແກ້ໄຂບັນຫານີ້, ຖານຂໍ້ມູນທີ່ທັນສະໄຫມໃຊ້ສະບັບດັດແກ້ຂອງຕົ້ນໄມ້ກ່ອນຫນ້ານີ້ທີ່ເອີ້ນວ່າ B + Tree. ຢູ່ໃນຕົ້ນໄມ້ B + Tree:

• ພຽງແຕ່ຂໍ້ຕ່ໍາສຸດ (ໃບ) ເກັບຮັກສາຂໍ້ມູນ (ສະຖານທີ່ຂອງແຖວໃນຕາຕະລາງທີ່ກ່ຽວຂ້ອງ)
• ສ່ວນທີ່ເຫຼືອຂອງ nodes ຢູ່ທີ່ນີ້ ສໍາລັບເສັ້ນທາງ ກັບ node ທີ່ຖືກຕ້ອງ ໃນລະຫວ່າງການຄົ້ນຫາ.

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ມີຂໍ້ຫຼາຍຢູ່ທີ່ນີ້ (ສອງຄັ້ງ). ແທ້ຈິງແລ້ວ, ທ່ານມີ nodes ເພີ່ມເຕີມ, "nodes ການຕັດສິນໃຈ", ທີ່ຈະຊ່ວຍໃຫ້ທ່ານຊອກຫາ node ທີ່ຖືກຕ້ອງ (ເຊິ່ງເກັບຮັກສາສະຖານທີ່ຂອງແຖວໃນຕາຕະລາງທີ່ກ່ຽວຂ້ອງ). ແຕ່​ຄວາມ​ສັບ​ສົນ​ຂອງ​ການ​ຄົ້ນ​ຫາ​ແມ່ນ​ຍັງ O(log(N)) (ມີ​ພຽງ​ແຕ່​ລະ​ດັບ​ຫນຶ່ງ​ຫຼາຍ​)​. ຄວາມແຕກຕ່າງອັນໃຫຍ່ຫຼວງແມ່ນວ່າ nodes ໃນລະດັບຕ່ໍາແມ່ນເຊື່ອມຕໍ່ກັບຜູ້ສືບທອດຂອງພວກເຂົາ.

ດ້ວຍ B+Tree ນີ້, ຖ້າທ່ານກໍາລັງຊອກຫາຄ່າລະຫວ່າງ 40 ແລະ 100:

• ທ່ານພຽງແຕ່ຕ້ອງການຊອກຫາ 40 (ຫຼືມູນຄ່າທີ່ໃກ້ຄຽງທີ່ສຸດຫຼັງຈາກ 40 ຖ້າ 40 ບໍ່ມີ) ຄືກັບທີ່ທ່ານໄດ້ເຮັດກັບຕົ້ນໄມ້ທີ່ຜ່ານມາ.
• ຫຼັງຈາກນັ້ນ, ເກັບກໍາ 40 heirs ໂດຍນໍາໃຊ້ການເຊື່ອມຕໍ່ heir ໂດຍກົງຈົນກ່ວາທ່ານບັນລຸ 100.

ໃຫ້ເວົ້າວ່າເຈົ້າຊອກຫາຜູ້ສືບທອດ M ແລະຕົ້ນໄມ້ມີ N nodes. ຊອກຫາ node ສະເພາະຄ່າໃຊ້ຈ່າຍ log(N) ຄືກັບຕົ້ນໄມ້ທີ່ຜ່ານມາ. ແຕ່ເມື່ອທ່ານໄດ້ຮັບ node ນີ້, ທ່ານຈະໄດ້ຮັບ M successors ໃນການດໍາເນີນງານ M ດ້ວຍການອ້າງອີງເຖິງຜູ້ສືບທອດຂອງພວກເຂົາ. ການຄົ້ນຫານີ້ມີມູນຄ່າ M+log(N) ເທົ່ານັ້ນ ການດໍາເນີນງານທຽບກັບການດໍາເນີນງານ N ໃນຕົ້ນໄມ້ທີ່ຜ່ານມາ. ຍິ່ງໄປກວ່ານັ້ນ, ທ່ານບໍ່ຈໍາເປັນຕ້ອງອ່ານຕົ້ນໄມ້ເຕັມ (ພຽງແຕ່ M + log (N) nodes), ຊຶ່ງຫມາຍຄວາມວ່າການໃຊ້ແຜ່ນຫນ້ອຍລົງ. ຖ້າ M ແມ່ນຂະຫນາດນ້ອຍ (ຕົວຢ່າງ 200 ແຖວ) ແລະ N ແມ່ນຂະຫນາດໃຫຍ່ (1 ແຖວ), ຈະມີຄວາມແຕກຕ່າງທີ່ໃຫຍ່ຫຼວງ.

ແຕ່ມີບັນຫາໃຫມ່ຢູ່ທີ່ນີ້ (ອີກເທື່ອຫນຶ່ງ!). ຖ້າທ່ານເພີ່ມຫຼືລຶບແຖວໃນຖານຂໍ້ມູນ (ແລະດັ່ງນັ້ນຢູ່ໃນດັດຊະນີ B+Tree ທີ່ກ່ຽວຂ້ອງ):

• ທ່ານຕ້ອງຮັກສາລະບຽບລະຫວ່າງ nodes ພາຍໃນ B+Tree, ຖ້າບໍ່ດັ່ງນັ້ນທ່ານຈະບໍ່ສາມາດຊອກຫາ nodes ພາຍໃນຕົ້ນໄມ້ທີ່ບໍ່ໄດ້ຈັດຮຽງ.
• ທ່ານ​ຕ້ອງ​ຮັກ​ສາ​ຈໍາ​ນວນ​ຕໍາ​່​ສຸດ​ທີ່​ຂອງ​ລະ​ດັບ​ທີ່​ເປັນ​ໄປ​ໄດ້​ໃນ B+Tree, ຖ້າ​ບໍ່​ດັ່ງ​ນັ້ນ O(log(N)) ຄວາມ​ສັບ​ສົນ​ຈະ​ກາຍ​ເປັນ O(N).

ໃນຄໍາສັບຕ່າງໆອື່ນໆ, B + Tree ຕ້ອງເປັນຄໍາສັ່ງດ້ວຍຕົນເອງແລະມີຄວາມສົມດູນ. ໂຊກດີ, ນີ້ເປັນໄປໄດ້ດ້ວຍການລຶບອັດສະລິຍະ ແລະໃສ່ຄຳສັ່ງ. ແຕ່ນີ້ແມ່ນຄ່າໃຊ້ຈ່າຍ: ການໃສ່ແລະການລຶບໃນ B+ tree cost O(log(N)). ດ້ວຍເຫດນີ້ ບາງຄົນໃນພວກທ່ານຈຶ່ງໄດ້ຍິນແນວນັ້ນ ການນໍາໃຊ້ດັດສະນີຫຼາຍເກີນໄປບໍ່ແມ່ນຄວາມຄິດທີ່ດີ. ແທ້, ທ່ານກໍາລັງຊ້າລົງໄວແຊກ / ປັບປຸງ / ລົບແຖວໃນຕາຕະລາງເນື່ອງຈາກວ່າຖານຂໍ້ມູນຕ້ອງການປັບປຸງດັດສະນີຂອງຕາຕະລາງໂດຍໃຊ້ການປະຕິບັດ O(Log(N)) ລາຄາແພງສໍາລັບແຕ່ລະດັດສະນີ. ຍິ່ງໄປກວ່ານັ້ນ, ການເພີ່ມດັດສະນີຫມາຍຄວາມວ່າມີວຽກຫຼາຍສໍາລັບ ຜູ້ຈັດການທຸລະກໍາ (ຈະອະທິບາຍໃນຕອນທ້າຍຂອງບົດຄວາມ).

ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ, ທ່ານສາມາດເບິ່ງບົດຄວາມ Wikipedia ກ່ຽວກັບ B+ຕົ້ນໄມ້. ຖ້າທ່ານຕ້ອງການຕົວຢ່າງຂອງການປະຕິບັດ B + Tree ໃນຖານຂໍ້ມູນ, ເບິ່ງ ຫົວ​ຂໍ້​ນີ້ и ຫົວ​ຂໍ້​ນີ້ ຈາກຜູ້ພັດທະນາ MySQL ຊັ້ນນໍາ. ພວກເຂົາທັງສອງສຸມໃສ່ວິທີການ InnoDB (ເຄື່ອງຈັກ MySQL) ຈັດການກັບດັດສະນີ.

ຫມາຍເຫດ: ຜູ້ອ່ານບອກຂ້ອຍວ່າ, ເນື່ອງຈາກການເພີ່ມປະສິດທິພາບໃນລະດັບຕ່ໍາ, ຕົ້ນໄມ້ B + ຄວນມີຄວາມສົມດູນຢ່າງສົມບູນ.

Hasshable

ໂຄງສ້າງຂໍ້ມູນທີ່ສໍາຄັນທີ່ສຸດຂອງພວກເຮົາແມ່ນຕາຕະລາງ hash. ນີ້ແມ່ນເປັນປະໂຫຍດຫຼາຍເມື່ອທ່ານຕ້ອງການຊອກຫາຄ່າຢ່າງໄວວາ. ຍິ່ງໄປກວ່ານັ້ນ, ຄວາມເຂົ້າໃຈຕາຕະລາງ hash ຈະຊ່ວຍໃຫ້ພວກເຮົາເຂົ້າໃຈໃນພາຍຫລັງການເຂົ້າຮ່ວມຖານຂໍ້ມູນທົ່ວໄປທີ່ເອີ້ນວ່າ hash join ( hash ເຂົ້າຮ່ວມ). ໂຄງສ້າງຂໍ້ມູນນີ້ຍັງຖືກໃຊ້ໂດຍຖານຂໍ້ມູນເພື່ອເກັບບາງສິ່ງພາຍໃນ (e.g. ຕາຕະລາງລັອກ ຫຼື ສະນຸກເກີ buffer, ພວກເຮົາຈະເຫັນທັງສອງແນວຄວາມຄິດເຫຼົ່ານີ້ຕໍ່ມາ).

ຕາຕະລາງ hash ແມ່ນໂຄງສ້າງຂໍ້ມູນທີ່ໄວຊອກຫາອົງປະກອບໂດຍກຸນແຈຂອງມັນ. ເພື່ອສ້າງຕາຕະລາງ hash, ທ່ານຈໍາເປັນຕ້ອງກໍານົດ:

• ຂໍ້ຄຶດ ສໍາລັບອົງປະກອບຂອງທ່ານ
• ຟັງຊັນ hash ສໍາລັບກະແຈ. hashes ທີ່ສໍາຄັນທີ່ຄິດໄລ່ໃຫ້ສະຖານທີ່ຂອງອົງປະກອບ (ເອີ້ນວ່າ ພາກສ່ວນ ).
• ຟັງຊັນສໍາລັບການປຽບທຽບຄີ. ເມື່ອທ່ານໄດ້ພົບເຫັນສ່ວນທີ່ຖືກຕ້ອງ, ທ່ານຕ້ອງຊອກຫາອົງປະກອບທີ່ເຈົ້າກໍາລັງຊອກຫາພາຍໃນສ່ວນໂດຍໃຊ້ການປຽບທຽບນີ້.

ຕົວຢ່າງງ່າຍໆ

ຂໍໃຫ້ພິຈາລະນາຕົວຢ່າງທີ່ຊັດເຈນ:

ຕາຕະລາງ hash ນີ້ມີ 10 ພາກສ່ວນ. ເພາະວ່າຂ້ອຍຂີ້ຄ້ານ, ຂ້ອຍຖ່າຍຮູບພຽງແຕ່ 5 ສ່ວນ, ແຕ່ຂ້ອຍຮູ້ວ່າເຈົ້າສະຫລາດ, ສະນັ້ນຂ້ອຍຈະໃຫ້ເຈົ້າຖ່າຍຮູບອີກ 5 ສ່ວນຂອງເຈົ້າເອງ. ຂ້ອຍໃຊ້ hash function modulo 10 ຂອງກຸນແຈ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຂ້າພະເຈົ້າເກັບຮັກສາພຽງແຕ່ຕົວເລກສຸດທ້າຍຂອງກຸນແຈຂອງອົງປະກອບເພື່ອຊອກຫາສ່ວນຂອງມັນ:

• ຖ້າຕົວເລກສຸດທ້າຍແມ່ນ 0, ອົງປະກອບຕົກຢູ່ໃນສ່ວນ 0,
• ຖ້າຕົວເລກສຸດທ້າຍແມ່ນ 1, ອົງປະກອບຕົກຢູ່ໃນສ່ວນ 1,
• ຖ້າຕົວເລກສຸດທ້າຍແມ່ນ 2, ອົງປະກອບຕົກຢູ່ໃນພື້ນທີ່ 2,
• ...

ຟັງຊັນການປຽບທຽບທີ່ຂ້ອຍໃຊ້ແມ່ນພຽງແຕ່ຄວາມສະເຫມີພາບລະຫວ່າງສອງຈໍານວນເຕັມ.

ໃຫ້ເວົ້າວ່າທ່ານຕ້ອງການທີ່ຈະໄດ້ຮັບອົງປະກອບ 78:

• ຕາຕະລາງ hash ຄິດໄລ່ລະຫັດ hash ສໍາລັບ 78, ເຊິ່ງແມ່ນ 8.
• ຕາຕະລາງ hash ເບິ່ງຢູ່ໃນສ່ວນ 8, ແລະອົງປະກອບທໍາອິດທີ່ມັນພົບແມ່ນ 78.
• ນາງສົ່ງຄືນລາຍການ 78 ໃຫ້ທ່ານ
• ການຊອກຫາຄ່າໃຊ້ຈ່າຍພຽງແຕ່ 2 ການດໍາເນີນງານ (ຫນຶ່ງເພື່ອຄິດໄລ່ຄ່າ hash ແລະອີກອັນຫນຶ່ງເພື່ອຊອກຫາອົງປະກອບພາຍໃນສ່ວນ).

ດຽວນີ້, ໃຫ້ເວົ້າວ່າທ່ານຕ້ອງການເອົາອົງປະກອບ 59:

• ຕາຕະລາງ hash ຄິດໄລ່ລະຫັດ hash ສໍາລັບ 59, ເຊິ່ງແມ່ນ 9.
• ຕາຕະລາງ hash ຄົ້ນຫາຢູ່ໃນສ່ວນ 9, ອົງປະກອບທໍາອິດທີ່ພົບແມ່ນ 99. ນັບຕັ້ງແຕ່ 99!=59, ອົງປະກອບ 99 ບໍ່ແມ່ນອົງປະກອບທີ່ຖືກຕ້ອງ.
• ການນໍາໃຊ້ເຫດຜົນດຽວກັນ, ອົງປະກອບທີສອງ (9), ທີສາມ (79), ... , ສຸດທ້າຍ (29) ຖືກປະຕິບັດ.
• ບໍ່ພົບອົງປະກອບ.
• ການຄົ້ນຫາຄ່າໃຊ້ຈ່າຍ 7 ການດໍາເນີນງານ.

ຟັງຊັນ hash ດີ

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ຂຶ້ນກັບມູນຄ່າທີ່ທ່ານກໍາລັງຊອກຫາ, ຄ່າໃຊ້ຈ່າຍແມ່ນບໍ່ຄືກັນ!

ຖ້າຕອນນີ້ຂ້ອຍປ່ຽນ modulo ຟັງຊັນ hash 1 ຂອງກຸນແຈ (ນັ້ນແມ່ນ, ເອົາ 000 ຕົວເລກສຸດທ້າຍ), ການຊອກຫາທີສອງມີຄ່າໃຊ້ຈ່າຍພຽງແຕ່ 000 ການດໍາເນີນງານເນື່ອງຈາກບໍ່ມີອົງປະກອບໃນ segment 6. ສິ່ງທ້າທາຍທີ່ແທ້ຈິງແມ່ນການຊອກຫາຫນ້າທີ່ hash ທີ່ດີທີ່ຈະສ້າງຖັງທີ່ມີອົງປະກອບຈໍານວນຫນ້ອຍຫຼາຍ.

ໃນຕົວຢ່າງຂອງຂ້ອຍ, ຊອກຫາຫນ້າທີ່ hash ທີ່ດີແມ່ນງ່າຍ. ແຕ່ນີ້ແມ່ນຕົວຢ່າງທີ່ງ່າຍດາຍ, ການຊອກຫາຫນ້າທີ່ hash ທີ່ດີແມ່ນມີຄວາມຫຍຸ້ງຍາກຫຼາຍເມື່ອສໍາຄັນຄື:

• string (ຕົວຢ່າງ - ນາມສະກຸນ)
• 2 ແຖວ (ຕົວຢ່າງ - ນາມສະກຸນ ແລະນາມສະກຸນ)
• 2 ແຖວ ແລະ ວັນທີ (ຕົວຢ່າງ - ນາມສະກຸນ, ຊື່ ແລະ ວັນເດືອນປີເກີດ)
• ...

ດ້ວຍຟັງຊັນ hash ທີ່ດີ, ການຊອກຫາຕາຕະລາງ hash ມີຄ່າໃຊ້ຈ່າຍ O(1).

Array ທຽບກັບຕາຕະລາງ hash

ເປັນຫຍັງບໍ່ໃຊ້ array?

Hmm, ຄໍາຖາມທີ່ດີ.

• ຕາຕະລາງ hash ສາມາດເປັນ ໂຫຼດບາງສ່ວນເຂົ້າໄປໃນຫນ່ວຍຄວາມຈໍາ, ແລະພາກສ່ວນທີ່ຍັງເຫຼືອສາມາດຍັງຄົງຢູ່ໃນແຜ່ນ.
• ດ້ວຍ array ທ່ານຕ້ອງໃຊ້ພື້ນທີ່ຕິດຕໍ່ກັນໃນຫນ່ວຍຄວາມຈໍາ. ຖ້າທ່ານກໍາລັງໂຫລດຕາຕະລາງຂະຫນາດໃຫຍ່ ມັນເປັນການຍາກຫຼາຍທີ່ຈະຊອກຫາພື້ນທີ່ຢ່າງຕໍ່ເນື່ອງພຽງພໍ.
• ສໍາລັບຕາຕະລາງ hash, ທ່ານສາມາດເລືອກລະຫັດທີ່ທ່ານຕ້ອງການ (ຕົວຢ່າງ, ປະເທດແລະນາມສະກຸນຂອງບຸກຄົນ).

ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ, ທ່ານສາມາດອ່ານບົດຄວາມກ່ຽວກັບ JavaHashMap, ເຊິ່ງເປັນການປະຕິບັດທີ່ມີປະສິດທິພາບຂອງຕາຕະລາງ hash; ທ່ານບໍ່ຈໍາເປັນຕ້ອງເຂົ້າໃຈ Java ເພື່ອເຂົ້າໃຈແນວຄວາມຄິດທີ່ກວມເອົາໃນບົດຄວາມນີ້.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com