ฉันได้สัมผัสกับพื้นฐานอัลกอริทึมต่าง ๆ ตั้งแต่ฉันเรียนรู้โครงสร้างข้อมูล แต่ฉันไม่เคยฝึกฝนมาก่อนตั้งแต่ฉันสอบเสร็จ เมื่อฉันกำลังพัฒนาฉันก็ตรวจสอบเมื่อฉันใช้มัน ตอนนี้ฉันกำลังเรียนรู้ JavaScript ฉันจะใช้เวลานี้ในการจัดระเบียบอัลกอริทึมพื้นฐานต่างๆและเขียนรหัสในไวยากรณ์ JS และ PHP ตามลำดับ
1. การเรียงลำดับฟอง
หลักการ: เปรียบเทียบตัวเลขที่อยู่ติดกันเป็นคู่และแลกเปลี่ยนตามลำดับจากขนาดเล็กถึงใหญ่หรือใหญ่ถึงขนาดเล็ก หลังจากการเดินทางจำนวนที่ใหญ่ที่สุดหรือเล็กที่สุดจะถูกแลกเปลี่ยนเป็นตัวเลขสุดท้ายจากนั้นเปรียบเทียบและแลกเปลี่ยนพวกเขาตั้งแต่ต้นจนกระทั่งสองถึงตัวเลขสุดท้ายสิ้นสุดลง
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (N2) กรณีที่ดีที่สุด: O (n) กรณีที่เลวร้ายที่สุด: O (N2)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: เสถียร
// JavaScript Syntax var Array = [23,0,32,45,56,75,43,0,34]; สำหรับ (var i = 0; i <array.length; i ++) {var issort = true; สำหรับ (var j = 0; j <array.length - 1 - i; j ++) {if (array [j]> array [j+1]) {issort = false; var temp = array [j]; อาร์เรย์ [j] = อาร์เรย์ [j + 1]; อาร์เรย์ [j + 1] = อุณหภูมิ; }} ถ้า (ออก) {break; }} console.log (อาร์เรย์); <? php $ array = [23,0,32,45,56,75,43,0,34]; สำหรับ ($ i = 0; $ i <count ($ array); $ i ++) {$ issort = true; สำหรับ ($ j = 0; $ j <count ($ array) - 1; $ j ++) {ถ้า ($ array [$ j]> $ array [$ j+1]) {$ issort = false; $ temp = $ array [$ j]; $ array [$ j] = $ array [$ j + 1]; $ array [$ j + 1] = $ temp; }} if ($ issort) {break; }} var_dump ($ array);?>2. การเรียงลำดับการเลือกอย่างง่าย
หลักการ: โดยการเปรียบเทียบคำหลักของ NI ให้เลือกบันทึกด้วยคำหลักที่เล็กที่สุดจากบันทึก N-I+1 และแลกเปลี่ยนกับ i (1 <= i <= n) th Records ประสิทธิภาพของการเรียงลำดับการเลือกอย่างง่ายนั้นดีกว่าการเรียงลำดับฟองเล็กน้อย
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (N2) กรณีที่ดีที่สุด: O (n) กรณีที่เลวร้ายที่สุด: O (N2)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: ไม่เสถียร
// javascript var array = [23,0,32,45,56,75,43,0,34]; สำหรับ (var i = 0; i <array.length - 1; i ++) {var pos = i; สำหรับ (var j = i+1; j <array.length; j ++) {if (array [j] <array [pos]) {pos = j; }} var temp = array [i]; อาร์เรย์ [i] = อาร์เรย์ [pos]; อาร์เรย์ [pos] = อุณหภูมิ; } console.log (อาร์เรย์); <? php $ array = [23,0,32,45,56,75,43,0,34]; สำหรับ ($ i = 0; $ i <count ($ array); $ i ++) {$ pos = $ i; สำหรับ ($ j = $ i+1; $ j <count ($ array); $ j ++) {ถ้า ($ array [$ j] <$ array [$ pos]) {$ pos = $ j; }} $ temp = $ array [$ i]; $ array [$ i] = $ array [$ pos]; $ array [$ pos] = $ temp; } var_dump ($ array);?>3. แทรกการเรียงลำดับโดยตรง
หลักการ: แทรกบันทึกลงในตารางที่เรียงลำดับที่เรียงลำดับดังนั้นจึงได้รับตารางที่สั่งซื้อใหม่โดยเพิ่มขึ้น 1 บันทึก นั่นคือการปฏิบัติครั้งแรกบันทึกแรกของลำดับเป็นลำดับที่สั่งซื้อจากนั้นแทรกทีละหนึ่งจากบันทึกที่สองจนกว่าจะมีการสั่งลำดับทั้งหมด ประสิทธิภาพที่ดีกว่าวิธีฟองและการเรียงลำดับการเลือก
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (N2) กรณีที่ดีที่สุด: O (n) กรณีที่เลวร้ายที่สุด: O (N2)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: เสถียร
// javascript var array = [23,0,32,45,56,75,43,0,34]; สำหรับ (var j = 0; j <array.length; j ++) {var key = array [j]; var i = j - 1; ในขณะที่ (i> -1 && array [i]> key) {array [i + 1] = array [i]; i = i - 1; } array [i + 1] = key; } console.log (อาร์เรย์); <? php // แทรกโดยตรงเรียงลำดับ $ array = [23,0,32,45,56,75,43,0,34]; สำหรับ ($ i = 0; $ i <count ($ array); $ i ++) {$ key = $ array [$ i]; $ j = $ i - 1; ในขณะที่ ($ j> -1 && $ array [$ j]> $ key) {$ array [$ j +1] = $ array [$ j]; $ j = $ j - 1; } $ array [$ j + 1] = $ key; } var_dump ($ array);?>4. จัดเรียงอย่างรวดเร็ว
หลักการ: ผ่านการเรียงลำดับข้อมูลที่จะถูกแบ่งจะแบ่งออกเป็นสองส่วนที่เป็นอิสระและข้อมูลทั้งหมดในบางส่วนมีขนาดเล็กกว่าข้อมูลทั้งหมดในส่วนอื่น ๆ จากนั้นข้อมูลทั้งสองจะถูกจัดเรียงอย่างรวดเร็วตามวิธีนี้ กระบวนการจัดเรียงทั้งหมดสามารถดำเนินการซ้ำเพื่อให้ได้ข้อมูลทั้งหมดกลายเป็นลำดับที่สั่งซื้อ
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (NLOG2N) กรณีที่ดีที่สุด: O (NLOG2N) กรณีที่เลวร้ายที่สุด: O (N2)
ความซับซ้อนของอวกาศ: O (nlog2n)
เสถียรภาพ: ไม่เสถียร
// JavaScript Quick Sort Var Array = [23,0,32,45,56,75,43,0,34]; var QuickSort = function (arr) {if (arr.length <= 1) {return arr; } // ตรวจสอบจำนวนองค์ประกอบในอาร์เรย์หากน้อยกว่าหรือเท่ากับ 1 มันจะถูกส่งคืน var pivotindex = math.floor (arr.length/2); // var pivot = arr.splice (pivotindex, 1) [0]; // เลือก "เกณฑ์มาตรฐาน" (pivot) และแยกออกจากอาร์เรย์ดั้งเดิม var ซ้าย = []; สำหรับ (var i = 0; i <arr.length; i ++) // transweep อาร์เรย์ใส่องค์ประกอบที่เล็กกว่า "เกณฑ์มาตรฐาน" ลงในชุดย่อยทางด้านซ้ายและองค์ประกอบที่ใหญ่กว่าเกณฑ์มาตรฐานลงในชุดย่อยทางด้านขวา {ถ้า (arr [i] <pivot) {left.push (arr [i]); } else {right.push (arr [i]); }} ส่งคืน Quicksort (ซ้าย) .concat ([pivot], Quicksort (ขวา)); // ทำซ้ำกระบวนการนี้อย่างต่อเนื่องเพื่อรับอาร์เรย์ที่เรียงลำดับ - var newarray = QuickSort (อาร์เรย์); console.log (Newarray); <? php $ array = [23,0,32,45,56,75,43,0,34]; ฟังก์ชั่น quick_sort ($ arr) {// ก่อนกำหนดว่าคุณจำเป็นต้องดำเนินการต่อ $ length = count ($ arr); if ($ length <= 1) {return $ arr; } $ base_num = $ arr [0]; // เลือกไม้บรรทัดเพื่อเลือกองค์ประกอบแรก // เริ่มต้นสองอาร์เรย์ $ left_array = array (); // $ right_array น้อยกว่าไม้บรรทัด = array (); // สำหรับ ($ i = 1; $ i <$ length; $ i ++) $ arr [$ i]) {// ใส่ลงในอาร์เรย์ซ้าย $ left_array [] = $ arr [$ i]; } else {// ใส่ลงใน $ right_array [] = $ arr [$ i]; }} // จากนั้นวิธีการเรียงลำดับเดียวกันสำหรับอาร์เรย์ด้านซ้ายและขวาตามลำดับ // เรียกฟังก์ชันนี้ซ้ำ ๆ และบันทึกผลลัพธ์ $ left_array = Quick_sort ($ left_array); $ right_array = quick_sort ($ right_array); // ผสานไม้บรรทัดซ้ายเข้ากับ return array_merge ($ left_array, array ($ base_num), $ right_array); } $ newArray = quick_sort ($ array); var_dump ($ newarray);?>5. Hill จัดเรียง
หลักการ: ก่อนอื่นแบ่งลำดับการบันทึกทั้งหมดเพื่อจัดเรียงเป็นหลายลำดับย่อยสำหรับการแทรกโดยตรงและการเรียงลำดับ เมื่อบันทึกในลำดับทั้งหมด "โดยทั่วไปสั่ง" จากนั้นแทรกและเรียงลำดับบันทึกทั้งหมดตามลำดับ -
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (n√n) กรณีที่ดีที่สุด: O (NLOG2N) กรณีที่เลวร้ายที่สุด: O (N2)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: ไม่เสถียร
// JavaScript Hill Sort Var Array = [23,0,32,45,56,75,43,0,34]; var shellsort = function (arr) {var length = arr.length; var h = 1; ในขณะที่ (h <ความยาว/3) {h = 3*h+1; // ตั้งค่าช่วงเวลา} ในขณะที่ (h> = 1) {สำหรับ (var i = h; i <length; i ++) {สำหรับ (var j = i; j> = h && arr [j] <arr [jh]; j- = h) {var temp = arr arr [jh] = arr [j]; arr [j] = อุณหภูมิ; }} h = (h-1)/3; } return arr; } var newArray = shellsort (อาร์เรย์); console.log (Newarray); <? php // ฮิลล์เรียงลำดับ $ array = [23,0,32,45,56,75,43,0,34]; ฟังก์ชั่นเชลล์ ($ arr) {$ length = count ($ arr); $ h = 1; ในขณะที่ ($ h <$ length/3) {$ h = 3*$ h+1; // set interval} ในขณะที่ ($ h> = 1) {สำหรับ ($ i = $ h; $ i <$ length; $ i ++) {สำหรับ ($ j = $ i; $ j> = $ h && arr [$ ar arr $ arr [$ j- $ h] = $ arr [$ j]; $ arr [$ j] = $ temp; }} $ h = ($ h-1)/3; } return $ arr; } $ newArray = shellsort ($ array); var_dump ($ newarray)?>6. การสั่งซื้อ
หลักการ: สมมติว่าลำดับเริ่มต้นมีระเบียน n มันถือได้ว่าเป็นลำดับที่สั่งซื้อแต่ละลำดับมีความยาว 1 และจากนั้นรวมกันเป็นคู่เพื่อให้ได้ (จำนวนเต็มที่เล็กที่สุดไม่น้อยกว่า n/2) คำสั่งที่มีความยาว 2 หรือ 1 และรวมกัน
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (NLOG2N) กรณีที่ดีที่สุด: O (NLOG2N) กรณีที่เลวร้ายที่สุด: O (NLOG2N)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: เสถียร
// ฟังก์ชั่นการเรียงลำดับ JavaScript รวม ISARRAY1 (arr) {ถ้า (object.prototype.toString.call (arr) == '[อาร์เรย์วัตถุ]') {return true; } else {return false; }} การรวมฟังก์ชั่น (ซ้าย, ขวา) {var result = []; if (! isarray1 (ซ้าย)) {ซ้าย = [ซ้าย]; } if (! isarray1 (ขวา)) {right = [ขวา]; } ในขณะที่ (left.length> 0 && right.length> 0) {ถ้า (ซ้าย [0] <ขวา [0]) {result.push (ซ้าย. shift ()); } else {result.push (right.shift ()); }} return result.concat (ซ้าย) .concat (ขวา); } ฟังก์ชั่น mergesort (arr) {var len = arr.length; var lim, work = []; var i, j, k; if (len == 1) {return arr; } สำหรับ (i = 0; i <len; i ++) {work.push (arr [i]); } work.push ([]); สำหรับ (lim = len; lim> 1;) {// lim คือความยาวการจัดกลุ่มสำหรับ (j = 0, k = 0; k <lim; j ++, k = k+2) {work [j] = ผสาน (งาน [k], งาน [k+1]); } งาน [j] = []; lim = math.floor ((lim+1)/2); } return work [0]; } var array = [23,0,32,45,56,75,43,0,34]; console.log (Mergesort (Array)); <? php // ฟังก์ชั่นการเรียงลำดับการทำความเข้าใจ mergesort (& $ arr) {$ len = count ($ arr); // การค้นหาความยาวอาร์เรย์ msort ($ arr, 0, $ len-1); } // โปรแกรมที่ใช้จริงจริง ๆ แล้วฟังก์ชั่นการเรียงลำดับ MSORT (& $ arr, $ ซ้าย, $ ขวา) {ถ้า ($ ซ้าย <$ ขวา) {// ระบุว่ามีองค์ประกอบพิเศษ 1 องค์ประกอบในลำดับจากนั้นจำเป็นต้องแยกแยกกันผสาน // คำนวณตำแหน่งแยกความยาว /2 // การโทรแบบเรียกซ้ำเรียงลำดับด้านซ้ายอีกครั้ง: msort ($ arr, $ ซ้าย, $ center); // เรียกซ้ำเพื่อเรียงลำดับด้านขวาอีกครั้ง msort ($ arr, $ center+1, $ ขวา); // ผสานผลการเรียงลำดับ mergearray ($ arr, $ ซ้าย, $ center, $ ขวา); }} // รวมหมายเลขสองที่สั่งซื้อไว้ในฟังก์ชั่นอาร์เรย์ที่สั่งซื้อ mergearray (& $ arr, $ ซ้าย, $ center, $ ขวา) {// ตั้งสองตำแหน่งเริ่มต้นทำเครื่องหมาย $ a_i = $ ซ้าย; $ b_i = $ center+1; ในขณะที่ ($ a_i <= $ center && $ b_i <= $ ขวา) {// เมื่อไม่มีอาร์เรย์ A หรืออาร์เรย์ B ข้ามขอบเขตถ้า ($ arr [$ a_i] <$ arr [$ b_i]) {$ temp [] = $ arr [$ a_i ++]; } else {$ temp [] = $ arr [$ b_i ++]; }} // ตัดสินว่าองค์ประกอบทั้งหมดในอาร์เรย์ A ใช้งานได้หรือไม่ ถ้าไม่แทรกองค์ประกอบทั้งหมดใน Array C: ในขณะที่ ($ a_i <= $ center) {$ temp [] = $ arr [$ a_i ++]; } // ตัดสินว่าองค์ประกอบทั้งหมดในอาร์เรย์ B ใช้งานได้หรือไม่ ถ้าไม่แทรกองค์ประกอบทั้งหมดในอาร์เรย์ c: ในขณะที่ ($ b_i <= $ ขวา) {$ temp [] = $ arr [$ b_i ++]; } // เขียนส่วนเรียงลำดับใน $ arrc เป็น $ arr: สำหรับ ($ i = 0, $ len = count ($ temp); $ i <$ len; $ i ++) {$ arr [$ left+$ i] = $ temp [$ i]; }} $ arr = array (23,0,32,45,56,75,43,0,34); Mergesort ($ arr); var_dump ($ arr);?>7. การเรียงลำดับกอง
หลักการ: การเรียงลำดับฮีปเป็นวิธีการเรียงลำดับโดยใช้กอง แนวคิดพื้นฐานคือ: เพื่อสร้างลำดับที่จะจัดเรียงเป็นกองบนขนาดใหญ่ ในเวลานี้ค่าสูงสุดของลำดับทั้งหมดคือโหนดรูทของด้านบนของกอง ลบออก (ในความเป็นจริงมันคือการแลกเปลี่ยนกับองค์ประกอบสิ้นสุดของอาเรย์ฮีปและองค์ประกอบสิ้นสุดคือค่าสูงสุด) จากนั้นสร้างลำดับ N-1 ที่เหลือลงในกองเพื่อให้ได้ค่า submaximum ขององค์ประกอบ N ซึ่งจะส่งผลให้เกิดการดำเนินการซ้ำ ๆ และสามารถรับลำดับที่สั่งซื้อได้
ความซับซ้อนของเวลา: กรณีเฉลี่ย: O (NLOG2N) กรณีที่ดีที่สุด: O (NLOG2N) กรณีที่เลวร้ายที่สุด: O (NLOG2N)
ความซับซ้อนของพื้นที่: O (1)
เสถียรภาพ: ไม่เสถียร
// JavaScript Heap Sort Var Array = [23,0,32,45,56,75,43,0,34]; ฟังก์ชั่น heapsort (อาร์เรย์) {สำหรับ (var i = math.floor (array.length / 2); i> = 0; i--) {heapadjust (อาร์เรย์, i, array.length-1); // สร้างอาร์เรย์อาร์เรย์ลงในฮีปด้านบนขนาดใหญ่} สำหรับ (i = array.length-1; i> = 0; i--) {/*เปลี่ยนโหนดรูท*/var temp = array [i]; อาร์เรย์ [i] = อาร์เรย์ [0]; อาร์เรย์ [0] = อุณหภูมิ; /*อาร์เรย์ที่เหลือยังคงถูกสร้างขึ้นในกองบนขนาดใหญ่*/ heapadjust (อาร์เรย์, 0, i - 1); } return array; } ฟังก์ชั่น heapadjust (อาร์เรย์, เริ่ม, สูงสุด) {var temp = array [start]; // temp เป็นค่าของโหนดรูทสำหรับ (var j = 2 * เริ่ม; j <max; j * = 2) {ถ้า (j <max && array [j] <array [j+1]) } if (temp> = array [j]) break; อาร์เรย์ [เริ่มต้น] = อาร์เรย์ [j]; start = j; } อาร์เรย์ [เริ่มต้น] = อุณหภูมิ; } var newArray = heapsort (อาร์เรย์); console.log (Newarray); <? php // ฟังก์ชั่นการเรียงลำดับ heapsort (& $ arr) {#initheap ($ arr, 0, count ($ arr) - 1); #START สลับโหนดศีรษะและหางและลดโหนดปลายหนึ่งโหนดในแต่ละครั้งและปรับกองจนกว่าจะมีองค์ประกอบที่เหลือสำหรับ ($ end = count ($ arr)-1; $ end> 0; $ end--) {$ temp = $ arr [0]; $ arr [0] = $ arr [$ end]; $ arr [$ end] = $ temp; ajustnodes ($ arr, 0, $ end - 1); }} #Initialize กองสูงสุดเริ่มจากโหนดที่ไม่ใช่ใบล่าสุดและโหนดที่ไม่ใช่ใบสุดท้ายจะถูกกำหนดหมายเลขเป็นความยาวอาร์เรย์/2 รอบฟังก์ชั่น initheap (& $ arr) {$ len = count ($ arr); สำหรับ ($ start = floor ($ len / 2) - 1; $ start> = 0; $ start--) {ajustnodes ($ arr, $ start, $ len - 1); }}#adjustNodes#@param $ arr array ที่จะปรับ#@param $ เริ่มพิกัดของโหนดพาเรนต์ที่จะปรับ#@param $ สิ้นสุดพิกัดของโหนดปลาย $ len = $ end + 1; #ความยาวของชิ้นส่วนที่จะปรับ $ leftchildinx = ($ start + 1) * 2 - 1; #left เด็กประสานงาน $ rightChildInx = ($ start + 1) * 2; #right child พิกัด #ถ้าชิ้นส่วนที่จะปรับมีลูกซ้ายถ้า ($ leftchildinx + 1 <= $ len) {#get พิกัดโหนดขั้นต่ำถ้า ($ arr [$ maxinx] <$ arr [$ leftchildinx]) {$ maxinx = $ leftchildinx; } #หากชิ้นส่วนที่จะปรับมีโหนดลูกที่ถูกต้องถ้า ($ rightChildInx + 1 <= $ len) {ถ้า ($ arr [$ maxinx] <$ arr [$ rightChildInx]) {$ maxinx = $ rightChildInx; }}} #swap โหนดพาเรนต์และโหนดสูงสุดถ้า ($ start! = $ maxinx) {$ temp = $ arr [$ start]; $ arr [$ start] = $ arr [$ maxinx]; $ arr [$ maxinx] = $ temp; #หากโหนดลูกหลังจากการแลกเปลี่ยนมีโหนดลูกดำเนินการต่อเพื่อปรับถ้า (($ maxinx + 1) * 2 <= $ len) {ajustnodes ($ arr, $ maxinx, $ end); }}} $ arr = array (23,0,32,45,56,75,43,0,34); heapsort ($ arr); var_dump ($ arr);?>8. การเรียงลำดับคาร์ดินัล
หลักการ: ตัดจำนวนเต็มเป็นตัวเลขที่แตกต่างกันโดยตัวเลขจากนั้นเปรียบเทียบแยกต่างหากโดยแต่ละหลัก เนื่องจากจำนวนเต็มสามารถแสดงสตริง (เช่นชื่อหรือวันที่) และหมายเลขจุดลอยตัวในรูปแบบเฉพาะการเรียงลำดับ radix ไม่เพียงใช้สำหรับจำนวนเต็มเท่านั้น
ความซับซ้อนของเวลา: กรณีเฉลี่ย: o (d (r+n)) กรณีที่ดีที่สุด: o (d (n+rd)) กรณีที่เลวร้ายที่สุด: o (d (r+n)) r: cardinality ของคำหลัก d: ความยาว n: จำนวนคำหลัก
ความซับซ้อนของพื้นที่: O (RD+N)
เสถียรภาพ: เสถียร
<? php #blassorting ที่นี่มีเพียงจำนวนเต็มบวกเท่านั้นที่ถูกจัดเรียง สำหรับจำนวนลบและจำนวนจุดลอยตัวจำเป็นต้องมีส่วนประกอบ คุณสนใจที่จะศึกษา #counting sort #@param $ arr array ที่จะเรียงลำดับ #@param $ digit_num เรียงลำดับตามจำนวนฟังก์ชั่นตัวเลขการนับ _sort (& $ arr, $ digit_num = false) {ถ้า ($ digit_num! == false) { #ถ้าพารามิเตอร์ $ digit_num นับ ($ arr); }} else {$ arr_temp = $ arr; } $ max = สูงสุด ($ arr); $ time_arr = array (); #Storage อาร์เรย์ขององค์ประกอบที่เกิดขึ้น#เริ่มต้นอาร์เรย์เหตุการณ์สำหรับ ($ i = 0; $ i <= $ max; $ i ++) {$ time_arr [$ i] = 0; } #STATIZE การเกิดขึ้นของแต่ละองค์ประกอบสำหรับ ($ i = 0; $ i <count ($ arr_temp); $ i ++) {$ time_arr [$ arr_temp); $ i ++) {$ time_arr [$ arr_temp [$ i]] ++; } #Statify การเกิดขึ้นของแต่ละองค์ประกอบที่เล็กกว่าหรือเท่ากับสำหรับ ($ i = 0; $ i <count ($ time_arr) - 1; $ i ++) {$ time_arr [$ i +1] += $ time_arr [$ i]; } #sort อาร์เรย์โดยใช้จำนวนเหตุการณ์สำหรับ ($ i = count ($ arr) - 1; $ i> = 0; $ i--) {$ sorted_arr [$ time_arr [$ arr_temp [$ i]] - 1] = $ arr [$ i]; $ time_arr [$ arr_temp [$ i]]-; } $ arr = $ sorted_arr; ksort ($ arr); #IGNORE การสูญเสียประสิทธิภาพของการเรียงลำดับคีย์ในครั้งนี้} #คำนวณจำนวนบิตของฟังก์ชันตัวเลขที่แน่นอน get_digit ($ number) {$ i = 1; ในขณะที่ ($ number> = pow (10, $ i)) {$ i ++; } return $ i; } #get หมายเลขหลัก i -th ของตัวเลขจากฟังก์ชันตัวเลขหลักเดียว get_specific_digit ($ num, $ i) {ถ้า ($ num <pow (10, $ i - 1)) {return 0; } return floor ($ num % pow (10, $ i) / pow (10, $ i - 1)); } #black การเรียงลำดับนับการเรียงลำดับเป็นฟังก์ชันกระบวนการย่อย radix_sort (& $ arr) {#first ค้นหาตัวเลขที่ใหญ่ที่สุดในอาร์เรย์ $ max = max ($ arr); $ max_digit = get_digit ($ max); สำหรับ ($ i = 1; $ i <= $ max_digit; $ i ++) {counting_sort ($ arr, $ i); }} $ arr = array (23,0,32,45,56,75,43,0,34); radix_sort ($ arr); var_dump ($ arr);?>ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น