Skip to main content

อัลกอริทึมเบื้องต้น

ก่อนที่เราจะไปลงรายละเอียดและขั้นตอนการเขียนโปรแกรม สิ่งแรกที่นักพัฒนาซอฟต์แวร์ทุกคนจะต้องมีนั่นก็คือการคิดที่เป็นไปตามขั้นตอน แยกออกมาเป็นส่วนเหมือนจิ๊กซอว์ สามารถทำงานร่วมกันได้ตามที่กำหนดไว้ และยืดหยุ่นเพื่อรองรับการพัฒนาหรือปรับเปลี่ยนที่อาจเกิดขึ้นในอนาคต

เราจึงจะมาเริ่มต้นกันกับการฝึกวิธีคิดเพื่อให้เหมือนนักพัฒนาซอฟต์แวร์กันครับ กับหัวข้ออัลกอริทึม

ทำไมเราต้องสามารถแตกงานออกมาได้?

การแตกงานออกมาเป็นขั้นตอนเล็ก ๆ เป็นกระบวนการที่ช่วยให้เราเข้าใจและจัดการกับปัญหาที่ซับซ้อนให้กลายเป็นปัญหาย่อย ๆ ที่สามารถแก้ไขได้ง่ายขึ้น และนอกจากนี้ยังสามารถ

  1. เพิ่มประสิทธิภาพการทำงาน: การแตกงานออกมาเป็นขั้นตอนเล็ก ๆ ทำให้เราสามารถโฟกัสที่งานย่อยแต่ละขั้นตอนและสามารถพึ่งพาได้เนื่องจากการทำงานในแต่ละงานย่อย ๆ นั้นได้รับการทดสอบแล้วซ้ำแล้วซ้ำเล่า แถมยังสามารถนำไปใช้งานในส่วนอื่นได้อีกด้วย เหมือนเป็นอีกหนึ่งบริการไปเลย
  2. ลดความซับซ้อนและง่ายต่อการตรวจสอบและบำรุงรักษา: ปัญหาการทำงานของซอฟต์แวร์นั้นดูเหมือนจะใหญ่มาก แต่หากเรารู้ว่าต้นตอของปัญหานั้นอยู่ตรงไหนและเราสามารถทำมันได้เร็วก็จะเป็นประโยชน์ต่อการพัฒนามากยิ่งขึ้น ซึ่งการแตกงานออกมาเป็นส่วนย่อยนั้นจะทำให้ขั้นตอนนี้ง่ายยิ่งขึ้น
  3. สนับสนุนการทำงานร่วมกัน: การแบ่งงานออกมาเป็นขั้นตอนย่อย ๆ ช่วยให้ทีมงานสามารถทำงานร่วมกันได้ด้วยการรับผิดชอบงานย่อยที่แตกต่างกัน

อัลกอริทึมซอฟต์แวร์คืออะไร?

อัลกอริทึม (Algorithm) คือ ชุดคำสั่งหรือขั้นตอนที่ชัดเจนและมีลำดับที่แน่นอนในการทำงาน เพื่อแก้ไขปัญหาหรือบรรลุเป้าหมายบางอย่าง การเขียนอัลกอริทึมเป็นการวางแผนขั้นตอนการทำงานให้เป็นระเบียบและเข้าใจได้ง่าย ซึ่งจะเป็นพื้นฐานสำคัญในการพัฒนาโปรแกรมที่มีประสิทธิภาพ โดยลักษณะการทำงานของอัลกอริทึมนั้นสามารถถูกสร้างหรือระบุโดยผู้ให้คำสั่ง โดยในที่นี้เพื่อน ๆ ก็คือผู้ให้คำสั่งแก่ระบบเพื่อแก้ไขปัญหาที่เราต้องการนั่นเอง

อัลกอริทึมแรกของคุณ

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

ตื่นนอน ลุกไปแปรงฟัน ดู Netflix

แต่จริง ๆ แล้ว ในความเป็นจริงมันก็ยังมีขั้นตอนอื่นที่ต้องทำให้เสร็จอีกก่อนที่จะทำภารกิจในการดู Netflix ให้เสร็จ เราจึงต้องทำการแตกงานออกมาเป็นลำดับขั้นตอนที่ชัดเจนมากกว่านี้เพื่อให้ผู้อื่นสามารถเข้าใจได้ นั่นก็คือการแจกแจงงานหรือหน้าที่ (หรือที่เรียกว่า Task) ออกมาเป็นงานหรือหน้าที่ย่อย ๆ (Sub-task)

โดยเราจะได้ใช้ทักษะในการแบ่งงานในการเขียนโปรแกรมอยู่เรื่อย ๆ เมื่อเราเขียนขั้นตอนเข้าไปเพิ่มเติม จะได้ลำดับขั้นตอนดังนี้:

ตื่นนอน ลุกออกจากเตียง เดินไปห้องน้ำ หยิบแปรงสีฟัน หยิบยาสีฟัน บีบยาสีฟันไปที่แปรงสีฟัน แปรงฟัน เดินไปหน้าทีวี หยิบรีโมท เปิด Netflix นั่งที่โซฟา ดู Netflix

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

  • เพราะว่าหากเราไม่ได้ระบุมันมากเพียงพอ มันก็จะไม่รู้ว่าจะต้องทำอะไรและจะไปต่อไม่ถูก
  • หรือถ้าบอกมันมากเกินไปก็จะทำให้เราเองก็จะต้องเหนื่อยซ้ำเพื่ออธิบายหรือแก้ไขวิธีการในภายหลังอีก

ในการเรียนเขียนโปรแกรม เราจะเจอโจทย์ที่ต้องใช้ทักษะการแบ่งงานเป็นขั้นตอนย่อย ๆ อยู่เรื่อย ๆ

แปลงขั้นตอนให้กลายเป็นโค้ด

หากว่าเราแปลงขั้นตอนข้างต้น 12 ขั้นตอนมันออกมาเป็นโค้ดภาษา Python ก็จะได้ประมาณนี้ครับ:

wake_up()                                   # ตื่น
get_out_of_bed() # ลุกขึ้นออกจากเตียง
go_to('Toilet') # เดินไปยัง: ห้องน้ำ
get_item('Toothbrush') # หยิบสิ่งของ: แปรงสีฟัน
get_item('Toothpaste') # หยิบสิ่งของ: ยาสีฟัน
combine_item('Toothbrush', 'Toothpaste') # บีบยาสีฟันไปที่แปรงสีฟัน
brush_teeth() # แปรงฟัน
go_to_sofa() # เดินไปยัง: โซฟา
get_item('Remote TV') # หยิบ: รีโมททีวี
open_tv() # เปิดทีวี
open_netflix() # เปิดดู Netflix

จะเห็นได้ว่าลำดับการทำงานจะทำงานจากบนลงล่างเหมือนลำดับขั้นตอนที่เราเขียนไว้ แม้ว่าอาจจะยังไม่เข้าใจโค้ดทั้งหมด แต่ก็พอเข้าใจว่ามันแปลงออกมาเป็นขั้นเป็นตอนในภาษา Python ได้อย่างไร

ในแต่ละขั้นตอนยังต้องระบุรายละเอียดเพิ่มเติม เช่น get_item() หรือหยิบของ ก็ต้องมีการให้คำอธิบายว่าจะให้หยิบอะไร เช่น การหาของในพื้นที่ใกล้ตัวและหยิบขึ้นมาใช้เป็นต้น ซึ่งภายใน get_item() นั้นก็จะมีขั้นตอนลงลึก (Sub-task) ของตัวมันอีกแบบไม่สิ้นสุด

บางครั้งเราจึงมีการใช้งานโค้ดของผู้อื่นที่เขียนขั้นตอนอย่าง get_item() ซึ่งนั่นก็คืออีกหนึ่งหน้่าที่ที่เพื่อน ๆ ต้องพึ่งพาเพราะเราคงจะไม่เวลาเขียนทุกอย่างได้เองทุกอย่างหรอกนะ!

การจัดขั้นตอนให้เป็นกลุ่มและเปลี่ยนแปลงง่าย

แม้ว่าเราจะไม่สามารถทำให้ขั้นตอนที่เราต้องทำนั้นลดลงได้ แต่เราก็สามารถสรุปงานที่เราจะต้องทำอย่างคร่าว ๆ ได้ ซึ่งเราก็ได้ทำไปเรียบร้อยแล้วในขั้นตอนข้างบน นั่นก็คือ

...นั่นเองครับ แต่เราก็รู้อยู่แล้วว่าการลุกไปแปรงฟันนั้นต้องทำอย่างไร มีขั้นตอนที่ตายตัว เราก็เลยสามารถกำหนดออกมาเป็นขั้นตอนได้เลยดังนี้

wake_up()
brush_teeth_procedure()
watch_netflix_procedure()

แล้วเราก็ระบุไปว่า brush_teeth_procedure() ต้องทำดังต่อไปนี้

get_out_of_bed()
go_to('Toilet')
get_item('Toothbrush')
get_item('Toothpaste')
combine_item('Toothbrush', 'Toothpaste')
brush_teeth()

และระบุว่า watch_netflix_procedure() ต้องทำดังต่อไปนี้

go_to_sofa()
get_item('Remote TV')
open_tv()
open_netflix()

การเขียนเพื่อใช้งานจริง

หลังจากเนื้อหานี้แล้ว เราก็จะไปยังการใช้งานภาษา Python ที่เราจะได้นำเอาความรู้ในจุดนี้ไปใช้งานให้เกิดประโยชน์ ซึ่งเราจะได้นำเอาการใช้อัลกอริทึมและการแบ่งงานมาใช้ประโยชน์กัน

แต่ครั้งนี้เราก็จะเขียนโปรแกรมที่จะใช้งานจริงแบบนี้

# ตื่นนอน
def wake_up():
print("Wake up")

# ลุกขึ้นจากเตียง
def get_out_of_bed():
print("Get out of bed")

# เดินไปยังห้องน้ำ
def go_to(location):
print(f"Go to: {location}")

# หยิบสิ่งของ
def get_item(item):
print(f"Get item: {item}")

# รวมสิ่งของ
def combine_item(item1, item2):
print(f"Combine {item1} with {item2}")

# แปรงฟัน
def brush_teeth():
print("Brush teeth")

# เดินไปยังโซฟา
def go_to_sofa():
print("Go to the sofa")

# เปิดทีวี
def open_tv():
print("Open TV")

# เปิดดู Netflix
def open_netflix():
print("Open Netflix")

# ขั้นตอนการแปรงฟัน
def brush_teeth_procedure():
get_out_of_bed()
go_to('Toilet')
get_item('Toothbrush')
get_item('Toothpaste')
combine_item('Toothbrush', 'Toothpaste')
brush_teeth()

# ขั้นตอนการดู Netflix
def watch_netflix_procedure():
go_to_sofa()
get_item('Remote TV')
open_tv()
open_netflix()

# ขั้นตอนการทำกิจวัตรประจำวัน
def daily_routine():
wake_up()
brush_teeth_procedure()
watch_netflix_procedure()

# เรียกใช้งาน
daily_routine()

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

ถ้ายังไม่ได้ เราก็ไม่ว่ากันเพราะเพื่อน ๆ อาจจะยังไม่ได้เห็นตัวอย่างการทำงานอย่างแท้จริง ไว้หลังจากที่เราเรียนรู้เรื่องของการใช้งานฟังก์ชันเสร็จเรียบร้อยแล้วค่อยกลับมาอ่านกันอีกครั้งก็ได้นะ

โจทย์ฝึกฝนการใช้อัลกอริทึม

ได้เวลาที่เพื่อน ๆ จะได้ฝึกฝนและพัฒนาทักษะการเขียนโปรแกรมของตัวเองกันแล้ว! ในหัวข้อนี้ เราจะมาทำความรู้จักกับโจทย์ที่หลากหลายเพื่อฝึกฝนการใช้อัลกอริทึม ซึ่งเป็นพื้นฐานสำคัญในการพัฒนาโปรแกรม และการแก้ไขปัญหาต่าง ๆ

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

โจทย์การใช้อัลกอริทึม 1

การออกกำลังกายที่ดีต้องเริ่มจากการใส่เสื้อผ้าจากบ้านให้เหมาะสมกับการออกกำลังกาย และเดินทางไปยังสวนที่ใกล้บ้านมากที่สุด หลังจากนั้นให้เราทำวอร์มอัพ, เดินเหยาะ เริ่มความเร็วที่ 1 และเพิ่มทีละหนึ่งไปเรื่อย ๆ จนถึง 5 และจากนั้นให้เราลดความเร็วทีละ 1 จนกลับมาเป็นความเร็วที่ 1 และทำการวอร์มอัพอีกครั้ง

เฉลยโจทย์การใช้อัลกอริทึม
  1. ใส่เสื้อผ้าออกกำลังกายจากบ้าน
  2. ออกจากบ้าน
  3. เดินทางไปยังสวนที่ใกล้บ้านที่สุด
  4. วอร์มอัพ
  5. เดินเหยาะ
  6. เริ่มความเร็วเป็น 1
  7. เพิ่มความเร็วเป็น 2
  8. เพิ่มความเร็วเป็น 3
  9. เพิ่มความเร็วเป็น 4
  10. เพิ่มความเร็วเป็น 5
  11. ลดความเร็วเหลือ 4
  12. ลดความเร็วเหลือ 3
  13. ลดความเร็วเหลือ 2
  14. ลดความเร็วเหลือ 1
  15. วอร์มอัพ

โจทย์การใช้อัลกอริทึม 2

ให้เพื่อน ๆ ลองทำการแบ่งงานออกมาเป็นขั้นตอน จากการเล่าขั้นตอนดังต่อไปนี้:

การทำอาหารเช้าอย่างไข่ดาวบนกระทะจนไข่สุกทั้งสองด้าน พร้อมเสิร์ฟกับขนมปังและนม

ตัวอย่างเฉลยของโจทย์
  1. เตรียมวัตถุดิบ (ไข่ ขนมปัง นม)
  2. ตั้งกระทะบนเตาไฟอ่อน
  3. ใส่น้ำมันเล็กน้อย
  4. ตีไข่ในชาม
  5. เทไข่ลงในกระทะ
  6. รอจนไข่เริ่มสุก
  7. กลับด้านไข่
  8. รอจนไข่สุกทั้งสองด้าน
  9. ปิดเตา
  10. ตักไข่ใส่จาน
  11. เสิร์ฟไข่กับขนมปังและนม

โจทย์การใช้อัลกอริทึม 3

ให้เพื่อน ๆ ลองทำการแบ่งงานออกมาเป็นขั้นตอน จากการเล่าขั้นตอนดังต่อไปนี้:

การทำความสะอาดห้องน้ำ

ตัวอย่างเฉลยของโจทย์
  1. เก็บของที่ไม่จำเป็นออกจากห้องน้ำ
  2. ใช้น้ำเปล่าล้างพื้นและผนังห้องน้ำ
  3. ใช้แปรงขัดพื้นและผนังให้สะอาด
  4. ใช้น้ำยาทำความสะอาดเช็ดถูพื้นและผนัง
  5. ล้างออกด้วยน้ำเปล่า
  6. ใช้ผ้าแห้งเช็ดให้แห้งสนิท

หวังว่าโจทย์เหล่านี้จะช่วยให้ผู้เรียนสามารถฝึกทักษะการแตกงานและการใช้อัลกอริทึมในชีวิตประจำวันได้อย่างดี