จะพิมพ์ Leaf Nodes ทั้งหมดของ Binary Tree จากซ้ายไปขวาใน JavaScript ได้อย่างไร

Ca Phimph Leaf Nodes Thanghmd Khxng Binary Tree Cak Say Pi Khwa Ni Javascript Di Xyangri



ต้นไม้ไบนารีประกอบด้วยหลายโหนดที่เชื่อมต่อกันผ่านจุดยอด แต่ละโหนดสามารถเชื่อมต่อกับโหนดย่อยได้มากที่สุดสองโหนด ซึ่งเรียกว่าโหนดย่อย หาก “ โหนด ” ไม่มีโหนดพาเรนต์ แต่มีโหนดย่อยบางโหนดที่มีโหนดหลาน ดังนั้นจึงเรียกว่า “ ราก ” โหนด โหนดคือ “ ภายใน ” ถ้ามีโหนดหลักและโหนดลูก “ ใบไม้ ” โหนดมีโหนดพาเรนต์ แต่ไม่มีโหนดลูกหมายถึงโหนดที่เป็นทางตัน

การแสดงแนวคิดที่กล่าวถึงด้วยภาพจะแสดงในรูปด้านล่าง:







คู่มือนี้จะอธิบายกระบวนการพิมพ์โหนดใบทั้งหมดของต้นไม้ไบนารีโดยครอบคลุมส่วนที่กล่าวถึงด้านล่าง:



จะระบุโหนดใบได้อย่างไร?

ใบไม้ ” โหนดคือโหนดที่ไม่มีโหนดลูกหรือเฉพาะเจาะจงซึ่งมี “ ความสูง ' ของ ' 0 '. หากโหนดมี “ ความสูง ' มากกว่า ' 0 ” จากนั้นโหนดนั้นอาจเป็นโหนดภายในหรือโหนดรูทได้ “ ใบไม้ ” โหนดมักจะย้อนรอยเพื่อระบุแหล่งที่มาดั้งเดิมจากที่ที่โหนดนี้ถูกสร้างขึ้น ส่วนใหญ่จะใช้ในการค้นหาหรืออัลกอริธึมการค้นหาข้อผิดพลาดเพื่อค้นหาสาเหตุของข้อผิดพลาดหรือปัญหา



จะพิมพ์ Leaf Nodes ทั้งหมดของ Binary Tree จากซ้ายไปขวาใน JavaScript ได้อย่างไร

มี 2 ​​แนวทาง” ซ้ำ ' และ ' วนซ้ำ ” เพื่อเลือกโหนดใบทั้งหมดที่มีอยู่ในไบนารีทรีที่ให้ไว้ในที่ต้องการ “ ซ้าย ' ถึง ' ขวา ' ทิศทาง. การนำแนวทางเหล่านี้ไปปฏิบัติจริงแสดงให้เห็นในส่วนที่ระบุไว้ด้านล่าง:





วิธีที่ 1: พิมพ์ Leaf Nodes ทั้งหมดของ Binary Tree จากซ้ายไปขวาซ้ำๆ

วิธีการเรียกซ้ำจะเลือกโหนดทั้งหมดใน อัลกอริธึมการค้นหาเชิงลึกก่อน ลักษณะที่ลัดเลาะไปตามโหนดด้านซ้ายทั้งหมดก่อน จากนั้นจึงไปยังโหนดกลางและโหนดด้านขวาในที่สุด การดำเนินการนี้จะดำเนินการซ้ำๆ สำหรับทุกโหนด และเมื่อไม่มีการเคลื่อนที่ผ่าน “ ใบไม้ ” โหนดได้รับการระบุ เพื่อให้เข้าใจแนวคิดนี้ได้ดีขึ้น โปรดไปที่ข้อมูลโค้ดด้านล่าง:

ระดับ โหนด
{
ตัวสร้าง ( )
{
นี้ . เนื้อหา = 0 ;
นี้ . ซ้าย = โมฆะ ;
นี้ . ขวา = โมฆะ ;
}
} ;

โดยที่ displayLeafNodes = ( rootNode ) =>
{
ถ้า ( rootNode == โมฆะ )
กลับ ;

ถ้า ( rootNode. ซ้าย == โมฆะ && rootNode. ขวา == โมฆะ )
{
เอกสาร. เขียน ( rootNode. เนื้อหา + ' ' ) ;
กลับ ;
}

ถ้า ( rootNode. ซ้าย != โมฆะ )
displayLeafNodes ( rootNode. ซ้าย ) ;
ถ้า ( rootNode. ขวา != โมฆะ )
displayLeafNodes ( rootNode. ขวา ) ;
}
คือ SampleNode = ( วาล ) =>
{
คือ tempNode = ใหม่ โหนด ( ) ;
tempNode. เนื้อหา = วาล ;
tempNode. ซ้าย = โมฆะ ;
tempNode. ขวา = โมฆะ ;
กลับ tempNode ;
}
คือ rootNode = พิสูจน์Node ( 3 ) ;
rootNode. ซ้าย = พิสูจน์Node ( 6 ) ;
rootNode. ขวา = พิสูจน์Node ( 9 ) ;
rootNode. ซ้าย . ซ้าย = พิสูจน์Node ( 12 ) ;
rootNode. ซ้าย . ขวา = พิสูจน์Node ( สิบห้า ) ;
rootNode. ซ้าย . ขวา . ขวา = พิสูจน์Node ( 24 ) ;
rootNode. ขวา . ซ้าย = พิสูจน์Node ( 18 ) ;
rootNode. ขวา . ขวา = พิสูจน์Node ( ยี่สิบเอ็ด ) ;

displayLeafNodes ( rootNode ) ;

คำอธิบายของบล็อกโค้ดข้างต้นระบุไว้ด้านล่าง:



  • ขั้นแรกให้สร้างคลาสชื่อ “ โหนด ” ซึ่งสร้างโหนดใหม่และตั้งค่าเป็น “ 0 '. ที่แนบมา ' ซ้าย ' และ ' ขวา ” โหนดด้านข้างถูกตั้งค่าเป็น “ โมฆะ ” โดยค่าเริ่มต้นโดยใช้ตัวสร้างคลาส
  • ต่อไป ให้นิยาม “ displayLeafNodes() ” ฟังก์ชันที่ยอมรับพารามิเตอร์ตัวเดียวของ “ rootNode '. ค่าพารามิเตอร์นี้ถือเป็นโหนดที่เลือกในปัจจุบันของแผนผังไบนารี
  • ภายในฟังก์ชั่น “ ถ้า ” คำสั่งที่ใช้ในการตรวจสอบว่า “ rootNode ” เป็นโมฆะหรือไม่ ในกรณีของ ' โมฆะ ” การดำเนินการเพิ่มเติมหยุดลงสำหรับโหนดนั้น ในอีกกรณีหนึ่ง rootNode “ ซ้าย ' และ ' ขวา ” โหนดด้านข้างถูกตรวจสอบสำหรับ “ โมฆะ '. หากทั้งสองค่าเป็นโมฆะ ค่าของ “ โหนด ” ได้รับการพิมพ์
  • หาก “ ซ้าย ' หรือ ' ขวา ” โหนดไม่ใช่ “null” จากนั้นส่งผ่านด้านนั้นของโหนดไปที่ “ displayLeafNodes() ” ฟังก์ชันสำหรับการดำเนินการแบบเรียกซ้ำ
  • กำหนดฟังก์ชันใหม่ชื่อว่า “ พิสูจน์โหนด() ” ที่ยอมรับพารามิเตอร์เดียวของ “ วาล '. ภายในฟังก์ชั่นสร้างอินสแตนซ์ใหม่ของ “ โหนด ” คลาสชื่อ “ tempNode '. กำหนดพารามิเตอร์ “ วาล ” เป็นมูลค่าทรัพย์สินคลาส” เนื้อหา ” และตั้งค่า “ ซ้าย ' และ ' ขวา ” โหนดด้านข้างถึง “ โมฆะ ' โดยค่าเริ่มต้น.
  • สุดท้ายสร้างวัตถุชื่อ “ rootNode ” สำหรับ “ พิสูจน์โหนด() ” และส่งค่าโหนดเป็นพารามิเตอร์ฟังก์ชันนี้ สร้างโหนดด้านซ้ายและด้านขวาโดยการเพิ่ม ' ซ้าย ' และ ' ขวา ” คำหลักที่มี “rootNode” และกำหนดค่าโดยใช้ฟังก์ชันเดียวกัน “ พิสูจน์โหนด() '.
  • ซ้าย ” หมายถึงตำแหน่งด้านซ้ายของโหนดรูทและ “ ซ้าย.ซ้าย ” ตำแหน่ง หมายถึง ซ้ายจากซ้าย ใช้วิธีเดียวกันในกรณีของ “ ขวา ' และ ' ขวา
  • หลังจากกำหนดแผนผังแล้ว ให้ส่งผ่าน 'rootNode' เป็นอาร์กิวเมนต์สำหรับ ' displayLeadNodes() ” เพื่อเลือกและพิมพ์โหนดใบทั้งหมดของแผนผังที่สร้างขึ้น

ผลลัพธ์ที่สร้างขึ้นหลังจากการคอมไพล์ยืนยันว่าโหนดปลายสุดของแผนผังที่ให้ไว้ได้รับการดึงและพิมพ์บนคอนโซล:

วิธีที่ 2: พิมพ์ Leaf Nodes ทั้งหมดของ Binary Tree โดยใช้วิธีวนซ้ำ

วนซ้ำ ” แนวทางเป็นแนวทางที่มีประสิทธิภาพสูงสุด โดยใช้แนวคิด “ ดัน ' และ ' โผล่ ” เพื่อเลือก “ ใบไม้ ” โหนด ประเด็นสำคัญหรือการทำงานของแนวทางนี้มีดังต่อไปนี้:

ระดับ โหนด
{
ตัวสร้าง ( ค่า )
{
นี้ . ข้อมูล = ค่า ;
นี้ . ซ้าย = โมฆะ ;
นี้ . ขวา = โมฆะ ;
}
} ;

โดยที่ displayLeafNodes = ( rootNode ) =>
{
ถ้า ( ! rootNode )
กลับ ;
ให้รายการ = [ ] ;
รายการ. ดัน ( rootNode ) ;

ในขณะที่ ( รายการ. ความยาว > 0 ) {
rootNode = รายการ [ รายการ. ความยาว - - 1 ] ;
รายการ. โผล่ ( ) ;
ถ้า ( ! rootNode. ซ้าย && ! rootNode. ขวา )
เอกสาร. เขียน ( rootNode. ข้อมูล + ' ' ) ;
ถ้า ( rootNode. ขวา )
รายการ. ดัน ( rootNode. ขวา ) ;
ถ้า ( rootNode. ซ้าย )
รายการ. ดัน ( rootNode. ซ้าย ) ;
}
}

คือ rootNode = ใหม่ โหนด ( 3 ) ;
rootNode. ซ้าย = ใหม่ โหนด ( 6 ) ;
rootNode. ขวา = ใหม่ โหนด ( 9 ) ;
rootNode. ซ้าย . ซ้าย = ใหม่ โหนด ( 12 ) ;
rootNode. ซ้าย . ขวา = ใหม่ โหนด ( สิบห้า ) ;
rootNode. ซ้าย . ขวา . ขวา = ใหม่ โหนด ( 24 ) ;
rootNode. ขวา . ซ้าย = ใหม่ โหนด ( 18 ) ;
rootNode. ขวา . ขวา = ใหม่ โหนด ( ยี่สิบเอ็ด ) ;

displayLeafNodes ( rootNode ) ;

คำอธิบายของโค้ดข้างต้นเขียนไว้ด้านล่าง:

  • ขั้นแรก สร้าง ' โหนด ” คลาสที่ได้รับพารามิเตอร์ตัวเดียว “ ค่า ” ซึ่งถูกกำหนดเป็นค่าของโหนดที่สร้างขึ้นใหม่และตั้งค่าด้านซ้ายและด้านขวาเป็นโมฆะ เช่นเดียวกับที่ทำในตัวอย่างข้างต้น
  • ต่อไปให้สร้างฟังก์ชัน “ displayLeafNodes() ” ที่ยอมรับพารามิเตอร์ตัวเดียวของ “ rootNode '. “rootNode” นี้ถือเป็นแผนผังไบนารี และความว่างเปล่าของมันจะถูกตรวจสอบก่อน
  • หากโหนดไม่ว่างเปล่า รายการว่างชื่อ “ รายการ ” ถูกสร้างขึ้นและ “ rootNode ” พารามิเตอร์ถูกแทรกลงไปโดยใช้คำสั่ง “ ดัน() ' วิธี.
  • จากนั้น “ ในขณะที่() ” ถูกใช้ซึ่งดำเนินการจนถึงความยาวของ “ รายการ '. ภายในวงคือธาตุที่อยู่ด้านล่างของต้นไม้หรือ “ รายการ ” ถูกลบออกโดยใช้ “ โผล่() ' วิธี.
  • บัดนี้การดำรงอยู่ของ “ ซ้าย ' และ ' ขวา ” ด้านข้างของ “rootNode” ได้รับการตรวจสอบ และหากไม่มีทั้งสองด้าน แสดงว่าไม่มีโหนดลูก จากนั้นโหนดนี้จะแสดงบนหน้าจอและระบุว่าเป็นโหนดปลายสุด
  • หากมีโหนดทางด้านซ้ายหรือขวาแสดงว่าโหนดนั้นมีลูก แล้วนั้น” ซ้าย ' และ ' ขวา ” โหนดถูกผลักเข้าไปใน “ รายการ ” เพื่อดำเนินการค้นหาโหนดใบต่อไป
  • ในตอนท้าย ให้สร้างแผนผังไบนารีแบบกำหนดเองโดยส่งค่าโหนดเป็นพารามิเตอร์สำหรับ ' โหนด ” ตัวสร้างคลาส หลังจากสร้างแล้ว ให้ส่งแผนผัง “rootNode” เป็นอาร์กิวเมนต์สำหรับ “ displayLeafNodes() ' การทำงาน.

ผลลัพธ์ที่สร้างขึ้นหลังจากการคอมไพล์แสดงให้เห็นว่าโหนดใบของแผนผังที่ให้มานั้นถูกพิมพ์:

เคล็ดลับโบนัส: การพิมพ์โหนดใบของต้นไม้ไบนารีจากทิศทางขวาไปซ้าย

เพื่อดึงโหนดลีฟทั้งหมดที่ไม่มีโหนดย่อยใน “ ขวา ' ถึง ' ซ้าย ” ทิศทาง วิธีเรียกซ้ำเป็นวิธีที่แนะนำมากที่สุดเนื่องจากความสะดวก ตัวอย่างเช่น ต้นไม้เดียวกันที่กล่าวถึงในส่วนข้างต้นจะถูกนำมาใช้เพื่อดึงโหนดใบ แต่ใน ' ขวา ” ถึง “ ซ้าย ” ทิศทาง ดังแสดงด้านล่าง:

ระดับ โหนด
{
ตัวสร้าง ( ค่า )
{
นี้ . ข้อมูล = ค่า ;
นี้ . ซ้าย = โมฆะ ;
นี้ . ขวา = โมฆะ ;
}
} ;


ฟังก์ชั่น DisplayLeafNodes ( ราก )
{
ถ้า ( ราก == โมฆะ )
{
กลับ ;
}

ถ้า ( ราก. ซ้าย == โมฆะ && ราก. ขวา == โมฆะ )
{
เอกสาร. เขียน ( ราก. ข้อมูล + ' ' ) ;
กลับ ;
}
ถ้า ( ราก. ขวา != โมฆะ )
{
displayLeafNodes ( ราก. ขวา ) ;
}
ถ้า ( ราก. ซ้าย != โมฆะ )
{
displayLeafNodes ( ราก. ซ้าย ) ;
}
}


คือ rootNode = ใหม่ โหนด ( 3 ) ;
rootNode. ซ้าย = ใหม่ โหนด ( 6 ) ;
rootNode. ขวา = ใหม่ โหนด ( 9 ) ;
rootNode. ซ้าย . ซ้าย = ใหม่ โหนด ( 12 ) ;
rootNode. ซ้าย . ขวา = ใหม่ โหนด ( สิบห้า ) ;
rootNode. ซ้าย . ขวา . ขวา = ใหม่ โหนด ( 24 ) ;
rootNode. ขวา . ซ้าย = ใหม่ โหนด ( 18 ) ;
rootNode. ขวา . ขวา = ใหม่ โหนด ( ยี่สิบเอ็ด ) ;

displayLeafNodes ( rootNode ) ;

รหัสที่ระบุไว้ข้างต้นทำงานดังนี้:

  • อันดับแรกชั้นเรียน” โหนด ” ถูกสร้างขึ้นโดยใช้ตัวสร้างเริ่มต้นในการเพิ่มโหนดใหม่ในแผนผังเพียงแค่ลิงก์ที่ทำในตัวอย่างข้างต้น
  • ต่อไป “ displayLeadNodes() ” ฟังก์ชั่นถูกสร้างขึ้นที่ยอมรับพารามิเตอร์เดียวของ “ rootNode '. พารามิเตอร์นี้ได้รับการตรวจสอบสำหรับ “ โมฆะ ” เงื่อนไขผ่านทาง “ ถ้า ' คำแถลง.
  • หากโหนดที่ระบุไม่เป็นความจริง แสดงว่า ' ซ้าย ' และ ' ขวา ” โหนดด้านข้างถูกตรวจสอบสำหรับ “ โมฆะ ' เงื่อนไข. หากทั้งสองค่าเป็นโมฆะ โหนดจะถูกระบุเป็น “ ใบไม้ ” โหนดและพิมพ์บนหน้าเว็บ
  • หลังจากนั้นให้ผ่าน “ ขวา ' และ ' ซ้าย ” โหนดของ “ rootNode ” ถึง “ displayLeafNodes() ' การทำงาน.
  • จัดสรรตำแหน่งของแต่ละโหนดโดยสร้างอินสแตนซ์โดยใช้คำสั่ง “ ใหม่ ” คำหลัก และ “ โหนด() ” ตัวสร้างและระบุตำแหน่งเป็นพารามิเตอร์ตัวสร้าง
  • ซ้าย ” หมายถึงตำแหน่งด้านซ้ายของโหนดรูทและ “ ซ้าย.ซ้าย ” ตำแหน่ง หมายถึง ซ้ายหรือซ้าย แนวทางเดียวกันนี้ใช้ในกรณีของ “ ขวา ' และ ' ขวา '.
  • สุดท้ายก็ผ่าน “ rootNode ” เป็นข้อโต้แย้งสำหรับ “ displayLeafNode() ' การทำงาน.

ผลลัพธ์ที่สร้างขึ้นแสดงให้เห็นว่าโหนดปลายสุดถูกพิมพ์ในทิศทางจากขวาไปซ้าย

นั่นคือทั้งหมดที่เกี่ยวกับการพิมพ์โหนดใบทั้งหมดของต้นไม้ไบนารี่ในทิศทางที่ต้องการ

บทสรุป

หากต้องการพิมพ์โหนดใบทั้งหมดของต้นไม้ไบนารี ให้สร้างคลาสแบบสุ่มที่สร้างและกำหนดค่าให้กับโหนดต้นไม้ ถัดไป สร้างฟังก์ชันสุ่มที่ยอมรับโหนดเดียวของแผนผังในลำดับชั้นจากบนลงล่าง ฟังก์ชั่นนี้มีหลาย “ ถ้า ” เงื่อนไขที่จะตรวจสอบว่า “ โหนด ” ไม่ว่างเปล่าและไม่มีโหนดใน “ ซ้าย ' และ ' ขวา ” ทิศทางนั้นโหนดนั้นจะถือเป็น “ ใบไม้ ” และจะแสดงบนคอนโซล คู่มือนี้ได้อธิบายขั้นตอนการพิมพ์โหนดใบทั้งหมดของต้นไม้ไบนารีจากซ้ายไปขวาหรือจากขวาไปซ้าย