ลูกแรดเตรียมพร้อมล่าเหยื่อ

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

DTS 10-09/09/52

Sorting
การเรียงลำดับ(sorting)เป็นการจัดให้เป็นระเบียบมีแบบแผนช่วยให้การค้นหาสิ่งของหรือข้อมูลสามารถทำได้รวดเร็วมีประสิทธิภาพ
วิธีการเรียงลำดับสามารถแบ่งเป็น 2 ประเภท คือ
1)การเรียงลำดับแบบภายใน(internal sorting)เป็นการเรียงลำดับที่ข้อมูลทั้งหมดต้องอยู่ในหน่วยความจำหลัก เวลาที่ใช้ในการเรียงลำดับจะคำนึงถึงเวลาที่ใช้ในการเปรียบเทียบและเลื่อนข้อมูลภายในความจำหลัก
2)การเรียงลำดับแบบภายนอก(external sorting)เป็นการเรียงลำดับข้อมูลที่เก็บอยู่ในหน่วยความจำสำรองซึ่งเป็นการเรียงลำดับข้อมูลในแฟ้มข้อมูล(file)เวลาที่ใช้ในการเรียงลำดับต้องคำนึงถึงเวลาที่เสียไประหว่างการถ่ายเทข้อมูลในหน่วยความจำสำรองนอกเหนือจากเวลาที่ใช้ในการเรียงลำดับข้อมูลแบบภายใน
ประเภทของการเรียงลำดับ
-การเรียงลำดับแบบเลือก (selection sort)เป็นการเลือกข้อมูลที่มีค่ามากหรือน้อยที่สุดไปเก็บไว้ในตำแหน่งที่ 1 แล้วก็ทำแบบเดิมไปเรื่อยๆจนกระทั่งครบทุกข้อมูลก็จะได้ลำดับจากน้อยไปมากหรือมากไปน้อยตามที่ต้องการ
-การเรียงลำดับแบบฟอง (Bubble Sort)เป็นการเรียงลำดับโดยการเลือกคู่ข้อมูลจากหน้าหรือหลังก็ได้แล้วก็เลือกว่าจะเรียงจากน้อยไปมากหรือมากไปน้อย โดยการเปรียบเทียบข้อมูลที่เลือกทั้งสองตัวแล้วสลับตำแหน่งกันเพื่อจะได้นำไปเปรียบเที่ยบในตำแหน่งต่อไปจนครบ
-การเรียงลำดับแบบเร็ว (quick sort)เป็นวิธีการเรียงลำดับที่ใช้เวลาน้อยเหมาะสำหรับข้อมูลที่มีจำนวนมากที่ต้องการความรวดเร็วในการทำงาน วิธีจะเลือกข้อมูลจากกลุ่มข้อมูลขึ้นมา 1 ค่าเป็นค่าหลัก แล้วหาตำแหน่งที่ถูกต้องให้กับค่าหลักนี้ เมื่อได้ตำแหน่งที่ถูกต้องแล้วใช้ค่านี้เป็นหลักในการแบ่งข้อมูลออกเป็นสองส่วนถ้าเป็นการเรียงลำดับจากน้อยไปมาก ส่วนแรกอยู่ในตอนหน้าข้อมูล ทั้งหมดจะมีค่าน้อยกว่าค่าหลักที่เป็นตัวแบ่งส่วน
-การเรียงลำดับแบบแทรก (insertion sort)เป็นการเรียงลำดับข้อมูลแบบเลือกคู่ข้อมูลจากหน้าหรือหลังก็ได้แล้วนำข้อมูลถัดไปมาเปรียบเทียบกันระหว่างข้อมูลทั้งสองว่าจะวางในตำแหน่งใดทำจนครบทุกข้อมูล
-การเรียงลำดับแบบฐาน (radix sort)เป็นการเรียงลำดับโดยพิจารณาจากฐานตัวเลขโดยเริ่มจาก 0 ถึง9 โดยรอบแรกให้พิจารณาในหลักหน่วยและเรียงลำดับหลักไปจนครบตามจำนวนข้อมูลก็จะได้เลขที่เรียงลำดับโดยอัตโนมัติ

การเปรียบเทียบ"stdio" กับ "iostream.h"

การตรวจสอบสถานภาพของพนักงาน ถ้าอายุการทำงานของพนักงานมากกว่า 20 ปีให้แสดงคำว่า Senior แต่ถ้าไม่ใช่ตามเงื่อนไขแสดง Junior

#include
main()
{
int year;
int work=20;
print f("How many year to work");
scan f("%d", &year);
if(year<=work) printf("Junior"); else printf("senior");
}


#include "iostream.h"
main()
{
int year; int work=20; cout<<"How many year to work?" cin>>year;
if(year<=work)
cout<<"Junior";
else cout<<"senior";
}

DTS 09-02/09/52

สรุปเรื่อง Tree (ต่อ)

เอ็กซ์เพรสชันทรี (Expression Tree)เป็นการนำเอาโครงสร้างทรีไปใช้เก็บ

นิพจน์ ทางคณิตศาสตร์โดยเป็นไบนารีทรี ซึ่งแต่ละโหนดเก็บตัวดำเนินการ

(Operator) และตัวถูกดำเนินการ(Operand) ของนิพจน์คณิตศาสตร์

นั้น ๆ ไว้ โดยมีความสำคัญตามลำดับดังนี้
- ฟังก์ชัน - วงเล็บ
- ยกกำลัง - เครื่องหมายหน้าเลขจำนวน (unary)
- คูณ หรือ หาร - บวก หรือ ลบ
- ถ้ามีเครื่องหมายที่ระดับเดียวกันห้ทำจากซ้ายไปขวา
ไบนารีเซิร์ชทรี (Binary Search Tree)
เป็นไบนารีทรีที่มีคุณสมบัติที่ว่าทุก ๆ โหนดในทรี ค่าของโหนดรากมีค่ามาก

กว่าค่าของทุก โหนดในทรีย่อยทางซ้าย และมีค่าน้อยกว่าหรือเท่ากับค่าของทุก

โหนดในทรีย่อยทางขวา และในแต่ละทรีย่อยก็มี คุณสมบัติเช่นเดียวกันมี

ปฏิบัติการดังต่อไปนี้
(1) การเพิ่มโหนดในไบนารีเซิร์ชทรี การเพิ่มโหนดใหม่เข้าไปในไบนารีเซิร์ชทรี

ถ้าทรีว่างโหนดที่เพิ่มเข้าไปก็จะเป็นโหนดรากของทรี ถ้าทรีไม่ว่างต้องทำการ

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

ถ้ามีค่ามากกว่าหรือเท่ากันจะนำโหนดใหม่ไปเพิ่มในทรีย่อยทางขวาและถ้ามีค่า

น้อยกว่านำโหนดใหม่ไปเพิ่มในทรีย่อยทางซ้าย
(2) การดึงโหนดในไบนารีเซิร์ชทรี หลังจากดึงโหนดที่ต้องการออกจากทรีแล้ว
ทรีนั้นต้องคงสภาพไบนารีเซิร์ชทรีเหมือนเดิมก่อนที่จะทำการดึงโหนดใด ๆ ออก

จาก ไบนารีเซิร์ชทรี ต้องค้นหาก่อนว่าโหนดที่ต้องการดึงออกอยู่ที่ตำแหน่งไหน

ภายในทรี และต้องทราบที่อยู่ของโหนดแม่โหนดนั้นด้วยแล้วจึงทำการดึงโหนด

ออกจากทรีได้ ขั้นตอนวิธีดึงโหนดออกอาจแยกพิจารณาได้ 3 กรณีดังต่อไปนี้
ก. กรณีโหนดที่จะดึงออกเป็นโหนดใบการดึงโหนดใบออกในกรณีนี้ ทำได้

ง่ายที่สุดโดยการดึงโหนดนั้นออกได้ทันที เนื่องจากไม่กระทบกับโหนดอื่นมาก

นัก วิธีการก็คือให้ค่าในลิงค์ฟิลด์ของโหนดแม่ซึ่งเก็บที่อยู่ ของโหนดที่ต้องการ

ดึงออกให้มีค่าเป็น Null
ข. กรณีโหนดที่ดึงออกมีเฉพาะทรีย่อยทางซ้ายหรือทรีย่อยทางขวาเพียง
ด้านใดด้านหนึ่ง วิธีการดึงโหนดนี้ออกสามารถใช้วิธีการเดียวกับการดึงโหนด
ออกจากลิงค์ลิสต์ โดยให้โหนดแม่ของโหนดที่จะดึงออกชี้ไปยังโหนดลูกของ
โหนดนั้นแทน
ค. กรณีโหนดที่ดึงออกมีทั้งทรีย่อยทางซ้าย และทรีย่อยทางขวาต้องเลือกโหนด

มาแทนโหนดที่ถูก ดึงออก โดยอาจจะเลือกมาจากทรีย่อยทางซ้ายหรือ ทรีย่อย

ทางขวาก็ได้

สรุป เรื่อง Graph

กราฟ (Graph) เป็นโครงสร้างข้อมูลแบบไม่ใช่เชิงเส้น อีกชนิดหนึ่ง กราฟเป็น

โครงสร้างข้อมูลที่มีการนำไปใช้ในงานที่เกี่ยวข้องกับการแก้ปัญหาที่ค่อนข้างซับ

ซ้อนเช่น การวางข่าย งานคอมพิวเตอร์ การวิเคราะห์เส้นทางวิกฤติ และปัญหา

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

ใช่เชิงเส้นที่ประกอบ ด้วยกลุ่มของสิ่งสองสิ่งคือ
(1) โหนด (Nodes) หรือ เวอร์เทกซ์(Vertexes)
(2) เส้นเชื่อมระหว่างโหนด เรียก เอ็จ (Edges)
กราฟที่มีเอ็จเชื่อมระหว่างโหนดสองโหนดถ้าเอ็จไม่มีลำดับ ความสัมพันธ์จะ

เรียกกราฟนั้นว่ากราฟแบบไม่มีทิศทาง (Undirected Graphs)และ

ถ้ากราฟนั้นมีเอ็จที่มีลำดับ ความสัมพันธ์หรือมีทิศทางกำกับด้วยเรียกกราฟนั้นว่า

กราฟแบบมีทิศทาง(Directed Graphs)บางครั้งเรียกว่า ไดกราฟ

(Digraph) โดยทั่ว ๆ ไปการเขียนกราฟเพื่อแสดงให้ เห็นความสัมพันธ์

ของสิ่งที่เราสนใจแทนโหนดด้วย จุด (pointes) หรือวงกลม (circles)

ที่มีชื่อหรือข้อมูลกำกับเพื่อบอกความแตกต่างของแต่ละโหนดและเอ็จแทนด้วย

เส้น หรือเส้นโค้งเชื่อมต่อระหว่างโหนดสองโหนด ถ้าเป็นกราฟแบบมีทิศทาง

เส้นหรือเส้นโค้งต้อง มีหัวลูกศรกำกับทิศทางของความสัมพันธ์ด้วย โหนดสอง

โหนดในกราฟแบบไม่มีทิศทางถือว่า เป็นโหนดที่ใกล้กัน (Adjacent)

ถ้ามีเอ็จเชื่อมจาก โหนดที่หนึ่งไปโหนดที่สอง

กราฟ (ก) แสดงกราฟที่มีลักษณะ ต่อเนื่อง (Connected)

เป็นกราฟที่มีเส้นทางเชื่อมจากโหนด ใด ๆ ไปยังโหนดอื่นเสมอ
กราฟ (ข) แสดงกราฟที่มีลักษณะเป็น วีถี (Path) มีเส้นทาง

เชื่อมไปยังโหนดต่าง ๆ อย่างเป็น ลำดับ โดยแต่ละโหนดจะเป็น
โหนดที่ใกล้กันกับโหนดที่อยู่ถัดไป
กราฟ (ค) แสดงกราฟที่เป็นวัฎจักร (Cycle) ซึ่งต้องมีอย่าง

น้อย 3 โหนด ที่โหนดสุดท้ายต้อง เชื่อมกับโหนดแรก
กราฟ (ง) แสดงกราฟที่มีลักษณะ ไม่ต่อเนื่อง

(Disconnected) เนื่องจากไม่มีเส้นทางเชื่อมจาก
โหนด 3 ไปยังโหนดอื่นเลย
กราฟ (จ) แสดงกราฟที่เป็นทรี โดยทรีเป็น กราฟที่ต่อเนื่อง

ไม่มีทิศทาง และไม่เป็นวัฏจักร
การแทนกราฟในหน่วยความจำ
ในการปฏิบัติการกับโครงสร้างกราฟ สิ่งที่ต้องการจัดเก็บ จากกราฟโดย

ทั่วไปก็คือ เอ็จ ซึ่งเป็นเส้นเชื่อมระหว่างโหนดสองโหนด มีวิธีการจัดเก็บ

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

ขึ้นเนื่องจากต้องเก็บโหนด และพอยน์เตอร์ในแถวลำดับ 2 มิติ และต้องจัดเก็บ
โหนดที่สัมพันธ์ด้วยในแถวลำดับ 1 มิติ อย่างไรก็ตามทั้งสองวิธีไม่เหมาะกับ

กราฟที่มีการ เปลี่ยนแปลง ตลอดเวลา ควรใช้ในกราฟที่ไม่มีการ เปลี่ยนแปลง

ตลอดการใช้งาน เพราะถ้ามีการเปลี่ยนแปลงส่วนใดส่วนหนึ่งของกราฟจะกระ

ทบกับส่วนอื่น ๆ ที่อยู่ในระดับที่ต่ำกว่าด้วยเสมอ
การท่องไปในกราฟ (graph traversal)

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

โหนดจะถูกเยือนเพียงครั้งเดียว สำหรับ การท่องไปในทรีเพื่อเยือนแต่ละโหนด

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

ที่ได้เยือนเสร็จเรียบร้อยแล้ว เพื่อไม่ให้เข้าไปเยือนอีก สำหรับเทคนิคการท่องไป
ในกราฟมี 2 แบบดังนี้
1. การท่องแบบกว้าง (Breadth First Traversal) วิธีนี้ทำโดย

เลือกโหนดที่เป็นจุดเริ่มต้น ต่อมาให้เยือนโหนด อื่นที่ใกล้กันกับโหนดเริ่มต้นที

ละระดับจนกระทั่งเยือนหมดทุก โหนดในกราฟ
2. การท่องแบบลึก (Depth First Traversal) การทำงานคล้าย

กับการท่องทีละระดับของทรี โดย กำหนดเริ่มต้นที่โหนดแรกและเยือนโหนด

ถัดไปตาม แนววิถีนั้นจนกระทั่งนำไปสู่ปลายวิถีนั้น จากนั้น ย้อนกลับ

(backtrack) ตามแนววิถีเดิมนั้น จนกระทั่ง สามารถดำเนินการต่อ

เนื่องเข้าสู่แนววิถีอื่น ๆ เพื่อเยือน โหนดอื่น ๆ ต่อไปจนครบทุกโหนด

DTS 08-26/08/52

สรุปเรื่อง Tree

ทรี (Tree) เป็นโครงสร้างข้อมูลที่ความสัมพันธ์ระหว่าง โหนดจะมีความสัมพันธ์

ลดหลั่นกันเป็นลำดับชั้นได้มีการนำรูปแบบทรีไปประยุกต์ใช้ในงานต่าง ๆ อย่าง

แพร่หลาย ส่วนมากจะใช้สำหรับแสดงความสัมพันธ์ระหว่างข้อมูล แต่ละโหนดจะ

มีความสัมพันธ์กับโหนดในระดับที่ต่ำลงมา หนึ่งระดับได้หลาย ๆ โหนดเรียกโหนด

ดังกล่าวว่า โหนดแม่ (Parent or Mother Node) โหนดที่อยู่ต่ำกว่าโหนดแม่อยู่

หนึ่งระดับเรียกว่า โหนดลูก (Child or Son Node) โหนดที่อยู่ในระดับสูงสุดและ

ไม่มีโหนดแม่เรียกว่า โหนดราก (Root Node) โหนดที่มีโหนดแม่เป็นโหนดเดียว

กัน เรียกว่า โหนดพี่น้อง (Siblings) โหนดที่ไม่มีโหนดลูก เรียกว่า โหนดใบ

(Leave Node) เส้นเชื่อมแสดงความสัมพันธ์ระหว่างโหนดสองโหนดเรียกว่า

กิ่ง (Branch)

นิยามของทรี
1. นิยามทรีด้วยนิยามของกราฟ ทรี คือ กราฟที่ต่อเนื่องโดยไม่มีวงจรปิด

(loop) ในโครงสร้างโหนดสองโหนดใด ๆ ในทรีต้องมีทางติดต่อกันทาง

เดียวเท่านั้น และทรีที่มี N โหนด ต้องมีกิ่ง ทั้งหมด N-1 เส้น
2. นิยามทรีด้วยรูปแบบรีเคอร์ซีฟทรีประกอบด้วยสมาชิกที่เรียกว่า โหนด

โดยที่ ถ้าว่าง ไม่มีโหนดใด ๆ เรียกว่านัลทรี (Null Tree) และถ้ามีโหนดหนึ่ง

เป็นโหนดราก ส่วนที่เหลือจะแบ่งเป็น ทรีย่อย (Sub Tree)
นิยามที่เกี่ยวข้องกับทรี
1. ฟอร์เรสต์ (Forest)หมายถึง กลุ่มของทรีที่เกิดจากการเอาโหนดรากของทรี

ออกหรือ เซตของทรีที่แยกจากกัน(Disjoint Trees)
2. ทรีที่มีแบบแผน (Ordered Tree)หมายถึง ทรีที่โหนดต่าง ๆ ในทรีนั้นมี

ความสัมพันธ์ที่แน่นอน เช่น ไปทางขวาไปทางซ้าย เป็นต้น
3. ทรีคล้าย (Similar Tree) คือ ทรีที่มีโครงสร้างเหมือนกัน หรือทรีที่มีรูปร่าง

ของทรีเหมือนกัน โดยไม่คำนึงถึงข้อมูลที่อยู่ในแต่ละโหนด
4. ทรีเหมือน (Equivalent Tree) คือ ทรีที่เหมือนกันโดยสมบูรณ์ โดยต้อง

เป็นทรีที่คล้ายกันและแต่ละโหนดในตำแหน่งเดียวกันมีข้อมูลเหมือนกัน
5. กำลัง (Degree) หมายถึง จำนวนทรีย่อยของโหนด นั้น ๆ
6. ระดับของโหนด (Level of Node) คือ ระยะทางในแนวดิ่งของโหนดนั้น ๆ

ที่อยู่ห่างจากโหนดราก เมื่อกำหนดให้ โหนดรากของทรีนั้นอยู่ระดับ 1 และ

กิ่งแต่ละกิ่งมีความเท่ากันหมด คือ ยาวเท่ากับ 1หน่วย ซึ่งระดับของโหนดจะ

เท่ากับจำนวนกิ่งที่น้อยที่สุดจากโหนดรากไปยังโหนดใด ๆ บวกด้วย 1

และจำนวนเส้นทางตามแนวดิ่งของโหนดใด ๆ ซึ่งห่างจากโหนดราก

เรียกว่า ความสูง (Height) หรือความลึก (Depth)
การแทนที่ทรีในหน่วยความจำหลัก
การแทนที่โครงสร้างข้อมูลแบบทรีในความจำหลักจะมีพอยเตอร์เชื่อมโยง

จากโหนดแม่ไปยังโหนดลูก แต่ละโหนดต้องมีลิงค์ฟิลด์เพื่อเก็บที่อยู่ของ

โหนดลูกต่าง ๆ นั่นคือจำนวน ลิงค์ฟิลด์ของแต่ละโหนดขึ้นอยู่กับจำนวน

ของโหนดลูก โดยอาจใช้วิธีการต่อไปนี้
1. โหนดแต่ละโหนดเก็บพอยเตอร์ชี้ไปยังโหนดลูกทุกโหนด การแทนที่ทรี

ด้วยวิธีนี้ จะให้จำนวนฟิลด์ในแต่ละโหนดเท่ากันโดยกำหนดให้มีขนาดเท่า

กับจำนวนโหนดลูกของโหนดที่มีลูกมากที่สุด โหนดใดไม่มีโหลดลูกก็

ให้ค่าพอยเตอร์ในลิงค์ฟิลด์นั้นมีค่าเป็น Null
2. แทนทรีด้วยไบนารีทรี เป็นวิธีแก้ปัญหาเพื่อลดการ สิ้นเปลืองเนื้อที่ใน

หน่วยความจำก็คือ กำหนดลิงค์ฟิลด์ให้มีจำนวนน้อยที่สุดเท่าที่จำเป็นเท่า

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

โหนดลูกหรือไม่มีโหนดพี่น้องให้ค่าพอยน์เตอร์ในลิงค์ฟิลด์มีค่าเป็น Null
การแปลงทรีทั่วไปให้เป็นไบนารีทรี ขั้นตอนการแปลงทรีทั่วๆ ไปให้เป็น

ไบนารีทรี มีลำดับ ขั้นตอนการแปลง ดังต่อไปนี้
1. ให้โหนดแม่ชี้ไปยังโหนดลูกคนโต แล้วลบความสัมพันธ์ ระหว่างโหนด

แม่และโหนดลูกอื่น ๆ
2. ให้เชื่อมความสัมพันธ์ระหว่างโหนดพี่น้อง
3. จับให้ทรีย่อยทางขวาเอียงลงมา 45 องศา
การท่องไปในไบนารีทรี
ปฏิบัติการที่สำคัญในไบนารีทรี คือ การท่องไปในไบนารีทรี (Traversing

Binary Tree)เพื่อเข้าไปเยือนทุก ๆโหนดในทรี ซึ่งวิธีการท่องเข้าไปต้อง

เป็นไปอย่างมีระบบแบบแผน สามารถเยือนโหนดทุก ๆ โหนด ๆ ละหนึ่ง

ครั้งวิธีการท่องไปนั้นมีด้วยกันหลายแบบแล้ว แต่ว่าต้องการลำดับขั้น

ตอนการเยือนอย่างไร โหนดที่ถูกเยือนอาจเป็นโหนดแม่ (แทนด้วย N)

ทรีย่อยทางซ้าย (แทนด้วย L) หรือทรีย่อยทางขวา (แทนด้วย R) มีวิธี

การท่องเข้าไปในทรี 6 วิธี คือ NLR LNR LRN NRL RNL และ RLN

แต่วิธีการท่องเข้าไปไบนารีทรีที่นิยมใช้กันมากเป็นการท่องจากซ้ายไป

ขวา 3 แบบแรกเท่านั้นคือ NLR LNRและ LRN ซึ่งลักษณะการนิยาม

เป็นนิยามแบบ รีเคอร์ซีฟ(Recursive)

DTS 07- 05/08/52

สรุป เรื่อง Queue
คิว (Queue) เป็นโครงสร้างข้อมูลแบบเชิงเส้นหรือลิเนียร์ลิสต์
ซึ่งการเพิ่มข้อมูลจะกระทำที่ปลายข้างหนึ่งซึ่งเรียกว่าส่วนท้าย
หรือเรียร์ (rear) และการนำข้อมูลออกจะกระทำที่ปลายอีกข้าง
หนึ่งซึ่งเรียกว่า ส่วนหน้า หรือฟรอนต์(front)
ลักษณะการทำงานของคิวเป็นลักษณะของการเข้าก่อนออกก่อน
หรือที่เรียกว่า FIFO (First In First Out)
การนำสมาชิกออกจากคิว เรียกว่าDequeue ซึ่งมีรูปแบบคือ
dequeue (queue, element) หมายถึง การนำออกจากส่วนหน้า
ของคิวและให้ ข้อมูลนั้นกับ element
การนำข้อมูลที่อยู่ตอนท้ายของคิวมาแสดงจะ เรียกว่าQueue Rear
แต่จะไม่ทำการเพิ่มข้อมูลเข้าไปในคิว
การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์ จะประกอบไปด้วย 2 ส่วน คือ
1. Head Node จะประกอบไปด้วย 3 ส่วนคือพอยเตอร์จำนวน 2 ตัว คือ
Front และ rearกับจำนวนสมาชิกในคิว
2. Data Node จะประกอบไปด้วย ข้อมูล (Data) และพอยเตอร์ที่ชี้ไปยัง
ข้อมูลตัวถัดไป
การดำเนินการเกี่ยวกับคิว ได้แก่
1. Create Queue จัดสรรหน่วยความจำให้แก่ Head Node และ
ให้ค่า pointer ทั้ง 2 ตัวมีค่าเป็น null และจำนวนสมาชิกเป็น 0
2. Enqueue การเพิ่มข้อมูลเข้าไปในคิว
3. Dequeue การนำข้อมูลออกจากคิว
4. Queue Front เป็นการนำข้อมูลที่อยู่ส่วนต้นของคิวมาแสดง
5. Queue Rear เป็นการนำข้อมูลที่อยู่ส่วนท้ายของคิวมาแสดง
6. Empty Queue เป็นการตรวจสอบว่าคิวว่างหรือไม่
7. Full Queue เป็นการตรวจสอบว่าคิวเต็มหรือไม่
8. Queue Coun เป็นการนับจำนวนสมาชิกที่อยู่ในคิว
9. Destroy Queue เป็นการลบข้อมูลทั้งหมดที่อยู่ในคิว
การนำข้อมูลเข้าสู่คิว จะไม่สามารถนำเข้า ในขณะที่คิวเต็ม
หรือไม่มีที่ว่าง ถ้าพยายามนำเข้าจะทำให้เกิดความผิดพลาดที่
เรียกว่า overflow
การนำข้อมูลออกจากคิว จะไม่สามารถนำอะไรออกจากคิวที
ว่างเปล่าได้ ถ้าพยายามจะทำให้เกิดความผิดพลาดที่เรียกว่า
underflow
การประยุกต์ใช้คิว
คิวถูกประยุกต์ใช้มากในการจำลองระบบงานธุรกิจ เช่น การให้บริการ
ลูกค้า ต้องวิเคราะห์จำนวนลูกค้าในคิวที่เหมาะสมว่าควรเป็นจำนวนเท่าใด
เพื่อให้ลูกค้าเสียเวลาน้อยที่สุด ในด้านคอมพิวเตอร์ ได้นำคิวเข้ามาใช้ คือ
ในระบบปฏิบัติการ (Operation System) ในเรื่องของคิวของงานที่เข้ามา
ทำงาน (ขอใช้ทรัพยากรระบบของ CPU) จะจัดให้งานที่เข้ามาได้ทำงาน
ตามลำดับความสำคัญ

DTS 06-29/07/52

การแทนที่ข้อมูลของสแตก สามารถทำได้ 2 วิธี คือ
1. การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์
2. การแทนที่ข้อมูลของสแตกแบบอะเรย์
การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์ จะประกอบไปด้วย2 ส่วน คือ
1.Head Node จะประกอบไปด้วย 2 ส่วนคือ top pointer และจำนวนสมาชิกในสแตก
2. Data Node จะประกอบไปด้วยข้อมูล (Data) และพอยเตอร์ ที่ชี้ไปยังข้อมูลตัวถัดไป
การดำเนินการเกี่ยวกับสแตก ได้แก่
1. Create Stack จัดสรรหน่วยความจำให้แก่ Head Node และส่งค่าตำแหน่งที่ชี้ไปยัง Head ของสแตกกลับมา
2. Push Stack การเพิ่มข้อมูลลงไปในสแตก
3. Pop Stack การนำข้อมูลบนสุดออกจากสแตก
4. Stack Top เป็นการคัดลอกข้อมูลที่อยู่บนสุดของสแตก โดยไม่มีการลบข้อมูลออกจากสแตก
5. Empty Stack เป็นการตรวจสอบการว่างของสแตก เพื่อไม่ให้เกิดความผิดพลาดในการนำข้อมูลออกจากสแตกที่เรียกว่า Stack Underflow
6. Full Stack เป็นการตรวจสอบว่าสแตกเต็มหรือไม่ เพื่อไม่ให้เกิดความผิดพลาดในการนำข้อมูลเข้าสแตกที่เรียกว่า Stack Overflow
7. Stack Count เป็นการนับจำนวนสมาชิกในสแตก
8. Destroy Stack เป็นการลบข้อมูลทั้งหมดที่อยู่ในสแตก
การแทนที่ข้อมูลของสแตกแบบอะเรย์
การดำเนินการเกี่ยวกับสแตก ได้แก่
1. Create Stack 5. Empty Stack
2. Push Stack 6. Full Stack
3. Pop Stack 7. Stack Count
4. Stack Top 8. Destroy Stack
การประยุกต์ใช้สแตก จะใช้ในงานด้านปฏิบัติการของเครื่องคอมพิวเตอร์ที่ขั้นตอนการทำงานต้องการเก็บข่าวสารอันดับแรกสุดไว้ใช้หลังสุด เช่น การทำงานของโปรแกรมแปลภาษานำไปใช้ในเรื่องของการโปรแกรมที่เรียกใช้โปรแกรมย่อย การคำนวณนิพจน์ทางคณิตศาสตร์ และรีเคอร์ชั่น (Recursion)เป็นต้น
การคำนวณนิพจน์ทางคณิตศาสตร์ ในการเขียนนิพจน์ทางคณิตศาสตร์เพื่อการคำนวณ จะต้อง
คำนึงถึงลำดับความสำคัญของเครื่องหมายสำหรับการคำนวณด้วยโดยทั่วไปนิพจน์ทางคณิตศาสตร์สามารถเขียนได้ 3 รูปแบบ คือ
1. นิพจน์ Infix นิพจน์รูปแบบนี้ operatorจะอยู่ตรงกลางระหว่างตัวถูกดำเนินการ 2 ตัว
2. นิพจน์ Postfix นิพจน์รูปแบบนี้ จะต้องเขียนตัวถูกดำเนินการตัวที่ 1 และ 2 ก่อน แล้วตามด้วย operator
3. นิพจน์ Prefix นิพจน์รูปแบบนี้ จะต้องเขียน operatorก่อนแล้วตามด้วยตัวถูกดำเนินการตัวที่ 1 และ 2
ตัวอย่างนิพจน์คณิตศาสตร์ในรูปแบบต่าง ๆ
นิพจน์ Infix นิพจน์ Postfix นิพจน์ Prefix
A+B-C AB+C- - +ABC
A+B*C-D/E ABC*+DE/- - +A*BC/DE
A*B+C-D/E AB*C+DE/- - +*ABC/DE
ขั้นตอนการแปลงจากนิพจน์ Infix เป็นนิพจน์Postfix
1. อ่านอักขระในนิพจน์ Infix เข้ามาทีละตัว
2. ถ้าเป็นตัวถูกดำเนินการจะถูกย้ายไปเป็นตัวอักษรในนิพจน์ Postfix
3. ถ้าเป็นตัวดำเนินการ จะนำค่าลำดับความสำคัญของตัว ดำเนินการที่อ่านเข้ามาเทียบกับค่าลำดับความสำคัญของตัวดำเนินการที่อยู่บนสุดของสแตก
- ถ้ามีความสำคัญมากกว่า จะถูก push ลงในสแตก
- ถ้ามีความสำคัญน้อยกว่าหรือเท่ากัน จะต้อง pop ตัวดำเนินการที่อยู่ในสแตกขณะนั้นไปเรียงต่อกับตัวอักษรในนิพจน์ Postfix
4. ตัวดำเนินการที่เป็นวงเล็บปิด “)” จะไม่ push ลงในสแตก แต่มีผลให้ตัวดำเนินการอื่น ๆ ถูก pop ออกจากสแตกนำไป เรียงต่อกันในนิพจน์ Postfix จนกว่าจะเจอ “(” จะ popวงเล็บเปิดออกจากสแตกแต่ไม่นำไปเรียงต่อ
5. เมื่อทำการอ่านตัวอักษรในนิพจน์ Infixหมดแล้ว ให้ทำการ Pop ตัวดำเนินการทุกตัวในสแตกนำมาเรียงต่อในนิพจน์ Postfix
ในการคำนวณค่า Postfix ที่แปลงมาแล้ว ตัวแปลภาษาจะทำการคำนวณโดยใช้โครงสร้างสแตกช่วยอีกเช่นกันขั้นตอนในการคำนวณ
1. อ่านตัวอักษรในนิพจน์ Postfix จากซานไปขวาทีละตัวอักษร
2. ถ้าเป็นตัวถูกดำเนินการ ให้ทำการ push ตัวถูกดำเนินการนั้นลงในสแตก แล้วกลับไปอ่านอักษรตัวใหม่เข้ามา
3. ถ้าเป็นตัวดำเนินการ ให้ทำการ pop ค่าจากสแตก 2 ค่าโดย ตัวแรกเป็นตัวถูกดำเนินการตัวที่ 2 และตัวที่ 1ตามลำดับ
4. ทำการคำนวณ ตัวถูกดำเนินการตัวที่ 1ด้วยตัวถูก ดำเนินการตัวที่ 2 โดยใช้ตัว
ดำเนินการในข้อ 3
5. ทำการ push ผลลัพธ์ที่ได้จากการคำนวณในข้อ 4 ลงสแตก
6. ถ้าตัวอักษรในนิพจน์ Postfix ยังอ่านไม่หมดให้กลับไปทำข้อ 1 ใหม่

DTS 05-22/07/52

สรุปเรื่อง Stack

สแตก (Stack) เป็นโครงสร้างข้อมูลที่ ข้อมูลแบบลิเนียร์ลิสต์ ที่มีคุณสมบัติที่ว่า การ
เพิ่มหรือลบข้อมูลในสแตก จะกระทำที่ ปลาย ข้างเดียวกัน ซึ่งเรียกว่า Top ลักษณะที่

สำคัญของสแตก คือ ข้อมูลที่ใส่หลังสุดจะถูกนำออกมา จากส แตกเป็นลำดับแรกสุด

เรียกคุณสมบัตินี้ว่า LIFO (Last In First Out)

การทำงานของสแตกจะประกอบด้วย กระบวนการ 3 กระบวนการที่สำคัญ คือ

1.Push คือ การนำข้อมูลใส่ลงไปในสแตก เช่น สแตก s ต้องการใส่ข้อมูล i ใ

นสแตก จะได้ push (s,i) คือ ใส่ข้อมูล i ลงไปที่ทอปของสแตก s

2. Pop คือ การนำข้อมูลออกจากส่วนบนสุด ของสแตก เช่น ต้องการนำข้อมูล

ออกจากสแตก s ไปไว้ที่ตัวแปร i จะได้ i = pop (s)
3. Stack Top เป็นการคัดลอกข้อมูลที่อยู่บนสุดของสแตก แต่ไม่ได้นำเอา

ข้อมูลนั้นออกจากสแตก
การแทนที่ข้อมูลของสแตก สามารถทำได้ 2 วิธี คือ
1. การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์

2. การแทนที่ข้อมูลของสแตกแบบอะเรย

ตัวอย่าง สแตกในชีวิตประจำวัน

การม้วนทับกันของเส้นด้าย ถ้าเราจะใช้เส้นได้เข็บอะไร

เราก็ต้องดึงเส้นด้ายจากด้านนอกก่อนไม่สามารถดึงด้ายจากเส้นที่อยู่ในสุดได้ก่อน

การใช้เทปใส เราจะดึงส่วนที่อยู่รอบนอกสุดมากใช้ก่อน ไม่สามารถดึงส่วนที่อยู่ในสุดมาใช้ก่อน

DTS 04-15/07/52

เรื่อง Linked List
ลิงค์ลิสต์ (Linked List) เป็นวิธีการเก็บข้อมูลอย่างต่อเนื่องของอิลิเมนต์ต่าง ๆ โดยมีพอยเตอร์เป็นตัวเชื่อมต่อแต่ละอิลิเมนท์ เรียกว่าโนด (Node) ซึ่งในแต่ละโนดจะประกอบไปด้วย 2 ส่วน คือ Data จะเก็บข้อมูลของอิลิเมนท์ และส่วนที่สอง คือ Link Field จะทำหน้าที่เก็บ ตำแหน่งของโนดต่อไปในลิสต์ ส่วนของ data ป็นรายการเดี่ยว หรือเป็นเรคคอร์ดก็ได้ ส่วนของ link จะเป็นส่วนที่เก็บตำแหน่ง ของโหนดถัดไป ในโหนดสุดท้ายจะเก็บค่า Null ซึ่งไม่ได้ชี้ไปยังตำแหน่งใด ๆ เป็นตัวบอกการสิ้นสุดของลิสต์

โครงสร้างข้อมูลแบบลิงค์ลิสต์
โครงสร้างข้อมูลแบบลิงค์ลิสต์จะแบ่งเป็น 2 ส่วน คือ
1. Head Structure
2. Data Node Structure
กระบวนงานและฟังก์ชั่นที่ใช้ดำเนินงานพื้นฐาน
1. กระบวนงาน Create Listหน้าที่ สร้างลิสต์ว่าง ผลลัพธ์ ลิสต์ว่าง
2. กระบวนงาน Insert Node หน้าที่เพิ่มข้อมูลลงไปในลิสต์บริเวณตำแหน่งที่ต้องการข้อมูลนำเข้า ลิสต์ ข้อมูล และตำแหน่ง ผลลัพธ์ ลิสต์ที่มีการเปลี่ยนแปลง
3. กระบวนงาน Delete Node หน้าที่ ลบสมาชิกในลิสต์บริเวณตำแหน่งที่ต้องการข้อมูลนำเข้า ข้อมูลและตำแหน่งผลลัพธ์ลิสต์ที่มีการเปลี่ยนแปลง
4. กระบวนงาน Search list หน้าที่ ค้นหาข้อมูลในลิสต์ที่ต้องการข้อมูลนำเข้าลิสต์ ผลลัพธ์ ค่าจริงถ้าพบข้อมูล ค่าเท็จถ้าไม่ พบข้อมูล
5. กระบวนงาน Traverse หน้าที่ ท่องไปในลิสต์เพื่อเข้าถึงและประมวลผลข้อมูล นำเข้าลิสต ผลลัพธ์ ขึ้นกับการประมวลผล เช่นเปลี่ยนแปลงค่าใน node , รวมฟิลด์ในลิสต์ , คำนวณค่าเฉลี่ยของฟิลด์ เป็นต้น
6. กระบวนงาน Retrieve Nodeหน้าที่ หาตำแหน่งข้อมูลจากลิสต์ข้อมูลนำเข้าลิสต์ผลลัพธ์ ตำแหน่งข้อมูลที่อยู่ในลิสต์
7. ฟังก์ชั่น EmptyListหน้าที่ ทดสอบว่าลิสต์ว่างข้อมูลนำเข้า ลิสต์ผลลัพธ์ เป็นจริง ถ้าลิสต์ว่าเป็นเท็จ ถ้าลิสต์ไม่ว่าง
8. ฟังก์ชั่น FullListหน้าที่ ทดสอบว่าลิสต์เต็มหรือไม่ข้อมูล นำเข้าลิสต์ผลลัพธ์ เป็นจริง ถ้าหน่วยความจำเต็ม เป็นเท็จ ถ้าสามารถมีโหนดอื่น
9. ฟังก์ชั่น list countหน้าที่ นับจำนวนข้อมูลที่อยู่ในลิสต์ข้อมูลนำเข้าลิสต์ผลลัพธ์ จำนวนข้อมูลที่อยู่ในลิสต์
10. กระบวนงาน destroy list หน้าที่ ทำลายลิสต์ข้อมูลนำเข้า ลิสต์ผลลัพธ์ ไม่มีลิสต์

DTS 03-01/07/52

โครงสร้างข้อมูลแบบเซ็ต เป็นโครงสร้างข้อมูลที่ข้อมูลแต่ละตัวไม่มีความสัมพันธ์กัน ในภาษาซีจะไม่มีประเภทข้อมูลแบบเซ็ตนี้เหมือนกับในภาษาปาสคาล แต่สามารถใช้หลักการของการดำเนินงานแบบเซ็ตมาใช้ได้
โครงสร้างข้อมูลแบบสตริง สตริงหรือสตริงของอักขระ เป็นข้อมูลที่ประกอบไปด้วย ตัวอักษร ตัวเลขหรือเครื่องหมายเรียงติดต่อกันไป รวมทั้งช่องว่าง การประยุกต์ใช้คอมพิวเตอร์ที่เกี่ยวกับข้อมูลที่เป็นสตริงมีการนำไปใช้สร้างโปรแกรมประเภทบรรณาธิการข้อความหรือโปรแกรมประเภทประมวลผลคำ
การกำหนดค่าคงตัวสตริง สามารถกำหนดได้ทั้งนอกและในฟังก์ชัน เมื่อกำหนดไว้นอกฟังก์ชัน ชื่อค่าคงตัวจะเป็นพอยเตอร์ชี้ไปยังหน่วยความจำที่เก็บสตริงนั้น
การกำหนดตัวแปรสตริง ในการกำหนดตัวแปรของสตริง อาศัยหลักการของอะเรย์ เพราะสตริงก็คืออะเรย์ของอักขระที่ปิดท้ายด้วย null character (/0) และมีฟังก์ชันพิเศษสำหรับทำงานกับสตริงโดยเฉพาะ
อะเรย์ของสตริง ถ้าหากมีสตริงจำนวนมากก็ควรจะทำให้เป็นอะเรย์ของสตริง เพื่อจะเขียนโปรแกรมได้สะดวก การสร้างอะเรย์ของสตริง สามารถสร้างได้ทั้งแบบที่ให้ค่าเริ่มต้นและแบบที่กำหนดเป็นตัวแปร
อะเรย์ของสตริงที่ยาวเท่ากัน อะเรย์ในลักษณะนี้จะถือว่าเป็นะเรย์ที่แท้จริง และสามรถกำหนดได้ทั้งเมื่อมีการให้ค่าเริ่มต้น และเมื่อกำหนดเป็นตัวแปร โดยดำเนินการตามแบการกำหนดอะเรย์ 2 มิติ การกำหนดตัวแปรในลักษณะนี้ จะแตกต่างจาการกำหนดตัวแปรแบบความยาวไม่เท่ากัน คือ ในแบบความยาวไม่เท่ากัน ท้ายของสตริงจะฟังก์ชันหะที่อยู่ในแฟ้มข้อมูล stdio.h เก็บอยู่ใน C Library อยู่แล้วสามารถนำมาใช้ได้ โดยการใช้คำสั่ง #include ในการเรียกใช้

การบ้านโครงสร้างข้อมูล

#include "stdio.h"
#include"string.h"
main()
{
struct address
{
char name[30];
int age;
char sex[20];
char address[40];
char road[20];
char district[30];
char province[30];
char code[20];
} address1;
strcpy(address1.name,"Supansa Chatthai");
address1.age=20;
strcpy(address1.sex,"female");
strcpy(address1.address,"24");
strcpy(address1.road,"-");
strcpy(address1.district,"Mueng");
strcpy(address1.province,"Patumtanee");
strcpy(address1.code,"12000");

printf("name:%s\n",address1.name);
printf("age:%d\n",address1.age);
printf("sex:%s\n",address1.sex);
printf("address:%s\n",address1.address);
printf("road:%s\n",address1.road);
printf("distric:%s\n",address1.district);
printf("province:%s\n",address1.province);
printf("code:%s\n",address1.code);
}

DTS 02-24/06/52

สรุปเนื้อหาที่เรียนเรื่อง Array and Record
การกำหนดอะเรย์จะต้องกำหนดชื่ออะเรย์ พร้อม subscript มีได้มากกว่า 1 ตัวจำนวน subscript จะเป็นตัวบอกมิติของอะเรย์นั้น การจัดเก็บอะเรย์ในหน่วยความจำหลักจะใช้เนื้อหาที่ขนาดเท่ากันเพิ้แก็บสมาชิกแต่ละตัว โดยเนื้อที่จะเรียงต่อเนื่องกัน จะพิจารณาตามประเภทของอะเรย์ในมิติต่าง ๆ ดังนี้
- อะเรย์ 1 มิติ
- อะเรย์หลายมิติ
การส่งอะเรย์ให้ฟังก์ชัน สามารถกำหนดอะเรย์เป็นพารามิเตอร์ส่งให้กับฟังก์ชันได้ 2 ลักษณะ
- การกำหนด array element เป็นพารามิเตอร์ส่งค่าให้กับฟังก์ชัน ทำได้โดยอ้างถึงชื่ออะเรย์พร้อมระบุ subscript เช่น swap (num[2],num[3]);
draw_house(color[i],x[i],y[i]);
- ส่งอะเรย์ทั้งชุดให้ฟังก์ชัน ทำได้โดยอ้างถึงชื่ออะเรย์โดยไม่มี subscript เช่น #define N 10
float a[N]; float avg;
avg = average(N,a);
Record or Struture เป็นโครงสร้างข้อมูลที่ประกอบขึ้นมาจากข้อมูลพื้นฐ่นต่างปรพเภทกัน รวมเป็น 1 ชุดข้อมูล จะประกอบด้วย data element หรือ field ต่างประเภทกันอยู่ร่วมกัน
Struture เป็นโครงสร้างที่สมาชิกแต่ละตัวมีประเภทข้อมูลแตกต่างกันได้ การกำหนดค่าเริ่มต้นให้กับสมาชิกของ Struture สามารถกกำหนดค่าเริ่มต้นให้กับสมาชิกได้โดยค่าเริ่มต้นที่จะกำหนดให้กับสมาชิกตัวใด จะต้องอยู่ในตำแหน่งที่ตรงกับสมาชิกตัวนั้นค่าเริ่มต้นจะต้องอยู่ในวงเล็บปีกกาและข้อมูล ค่าเริ่มต้นแต่ละตัวแยกกันด้วยเครื่องหมาย ,
การอ้างถึงตัวแปรที่อยู่ในตัวแปรชนิดโครงสร้าง สามารถอ้างถึงตัวแปรที่อยู่ในตัวแปรชนิดโครงสร้างได้
รูปแบบ
struct-variable.element-name
struct-variable ชื่อตัวแปรชนิดโครงสร้าง
element-name ชื่อตัวแปรที่อยู่ภายใน Struture

ประวัติส่วนตัว

นางสาวสุพรรษา ชาติไทย
ชื่อเล่น ฝ้าย
เกิดวันที่ 28 กรกฎาคม 2531
อายุ 20 ปี กรุ๊ปเลือด O
รหัสนักศึกษา 50152792024
คณะวิทยาการจัดการ
หลักสูตรบริหารธุรกิจ(คอมพิวเตอร์ธุรกิจ)