การเขียนโปรแกรมโดย นายจตุพร โอวัฒนาพานิช

วันจันทร์ที่ 6 สิงหาคม พ.ศ. 2555

โปรแกรมคำนวณเกรด

#include<stdio.h>
main(){
int x=0;
printf ("Programing by Jatuporn Owattanapanich M.5-12 NO.12\n\n");
printf("// Input Score : ");

scanf("%d",&x);
printf("\n");
while(x>100){
printf("\nInput must < 100\n// Input Score : ");
scanf("%d",&x);
printf("\n");
}
if(x>=80)
printf("Grade A");
else if(x>=70)
printf("Grade B");
else if(x>=60)
printf("Grade C");
else if(x>=50)
printf("Grade D");
else
printf("Grade 0");
getch();
}

Code ตัวอย่างโปรแกรม และหน้าตาโปรแกรมภาษาซี

Code ตัวอย่างโปรแกรม

และหน้าตาโปรแกรมภาษาซี

ตัวอย่างที่ 1 แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น

#include <stdio.h>

void main( ) {

/* Display message to standard output */

printf(“My first program.”);

ตัวอย่างที่ 2 แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น

#include <stdio.h> void main( ) { /* Display message to standard output */ printf

(“My first program.”); }

ตัวอย่างที่ 3 แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น

#include

<stdio.h>

void

main

()

{

/* Display message

to standard

output */

printf

(

“My first program.”

)

;

}

ตัวอย่างที่ 4 แสดงตัวอย่างการใช้ค่าของตัวแปรชนิด char

#include <stdio.h>

void main( ) {

int no;

char ch;

ch = ‘J’;

printf(“char : %c, dec : %d, oct : %o, hex : %x”, ch, ch, ch, ch);

no = ch;

printf(“\nno : %d, ch : %c”, no, ch);

no = 68;

ch = no;

printf(“\nno : %d, ch : %c”, no, ch);

}

ผลการทำงานของโปรแกรม

char : J, dec : 74, oct : 112, hex : 4a

no : 74, ch : J

no : 68, ch : D

ตัวอย่างที่ 5 แสดงตัวอย่างการรับข้อมูลเพื่อนำมาแสดงผล

#include <stdio.h>

void main( ) {

char name[100];

printf("What is your name ?\n");

scanf("%s", name);

printf("Very glad to know you, ");

printf("%s.",name);

}

ผลลัพธ์ของการทำงาน

What is your name ?

Willy

Very glad to know you, Willy.

ตัวอย่างที่ 6 แสดงการกำหนดค่าจำนวนจริงให้กับตัวแปรจำนวนเต็ม

#include <stdio.h>

void main( ) {

int x;

x = 14.8328;

printf(“x value is %d”, x);

}

ผลการทำงานของโปรแกรม

x value is 14

ตัวอย่างที่ 7 โปรแกรมหาผลรวมของเลขจำนวนเต็ม 2 จำนวนที่รับข้อมูลจากผู้ใช้

#include <stdio.h>

void main( ) {

int x, y, z;

printf(“Enter X value : “);

scanf(“%d”, &x);

printf(“Enter Y value : “);

scanf(“%d”, &y);

z = x + y;

printf(“Summary of X and Y is %d”, z);

}

ผลการทำงานของโปรแกรม

Enter X value : 15

Enter Y value : 20

Summary of X and Y is 35

ตัวอย่างที่ 8 แสดงการใช้ตัวดำเนินการเพิ่มค่า

#include <stdio.h>

void main( ) {

int y, count;

count = 1;

y = count++;

printf(“y = %d, count = %d”, y, count);

count = 1;

y = ++count;

printf(“\ny = %d, count = %d”, y, count);

}

ผลการทำงานของโปรแกรม

y = 1, count = 2

y = 2, count = 2

ตัวอย่างที่ 9 แสดงการใช้ตัวดำเนินการเปลี่ยนชนิดข้อมูล

#include <stdio.h>

void main( ) {

int x;

x = 2.5 * 2;

printf(“x value is %d”, x);

x = (int)2.5 * 2;

printf(“\nx value is %d”, x);

x = (int)(2.5 * 2);

printf(“\nx value is %d”, x);

}

ผลการทำงานของโปรแกรม

x value is 5

x value is 4

x value is 5

ตัวอย่างที่ 10 แสดงของการเปรียบเทียบด้วยตัวกาํเนินการความสัมพันธ์

#include <stdio.h>

void main( ) {

int x, y

printf(“Enter X : “);

scanf(“%d”, &x);

printf(“Enter Y : “);

scanf(“%d”, &y);

printf(“X > Y is %d”, x>y);

}

ผลการทำงานของโปรแกรม

Enter X : 32

Enter Y : 24

X > Y is 1

โปรแกรมแบบวนซ้ำ (คำสั่งประเภท For , while,do while)

คำสั่งควบคุมการทำงาน แบบ for

คำสั่ง For เป็นคำสั่งควบคุมการทำงานและกำหนดการทำงานวนรอบคล้าย ๆ กับคำสั่ง while จะมีรูปแบบแตกต่างกับคำสั่งควบคุมการทำงานอืน ๆ

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

รูปแบบการเขียน คำสั่ง for

for (ค่าเริ่มต้น;เงื่อนไข;การเพิ่มหรือลดค่า)

ตัวอย่างการโปรแกรม

ผลลัพธ์ของโปรแกรม

การเขียนโดยใช้คำสั่ง for จะเห็นได้ว่ามีความกระชับเขียนได้สั้นกว่าคำสั่ง while เพราะสามารถกำหนดได้ในครั้งเดียว แต่การทำงานก็จะได้ผลเหมือนกันกับคำสั่งwhile

ลักษณะการทำงานก็คือโปรแกรมจะทำการเช็คในส่วนของเงื่อนไข หากเงื่อนไขเป็นจริงก็จะเพิ่มค่าของตัวแปรไป 1 และทำคำสั่งในลูป

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

___________________________________________________________

คำสั่งควบคุมการทำงาน แบบ While

คำสั่ง While เป็นคำสั่งสำหรับใช้ควบคุมการทำงานแบบมีเงือนไข อีกแบบหนึ่ง ซึ่งแตกต่างออกไปจากการใช้งานคำสั่ง if และ elseif ก่อนหน้านี้ ซึ่งคำสั่ง While เป็นคำสั่งที่จำเป็นในการนำไปใช้เขียนโปรแกรม ลองเข้ามาดูค่ะ ว่ามีรูปแบบการเขียนและวิธีเขียนอย่างไร

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

รูปแบบการเขียน คำสั่ง While

While (...เงื่อนไข...) {คำสั่งที่ต้องการให้ทำงาน เมื่อเงื่อนไขเป็นจริง

ตัวอย่างการโปรแกรม

ผลลัพธ์ของโปรแกรม

___________________________________________________________

คำสั่งควบคุมการทำงาน แบบ Do...While

คำสั่งนี้มีลักษณะการทำงานคล้ายกับคำสั่ง While แต่มีส่วนแตกต่างอยู่เล็ก ๆ น้อย ๆ ที่มี Do เพิ่มเข้ามานี่ดิ แล้วไอ้ Do นี่จะทำให้แตกต่างจาก While เดี่ยว ๆ

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

รูปแบบการใช้คำสั่ง do while

do {คำสั่ง} while (เงื่อนไข)

ตัวอย่างการโปรแกรม

ผลลัพธ์ของโปรแกรม

จากตัวอย่างการโปรแกรม เราได้ทำการเขียนโปรแกรม โดยสร้างตัวแปร $i แล้วให้มีค่าเท่ากับ 5 หลังจากนั้น ตรงนี้ละที่จะทำงานต่างจาก while เราะจะเจอกับคำสั่ง do เมื่อเจอคำสั่ง do โปรแกรมจะทำเลยทันที (do แปลว่าทำนี่น่า) ซึ่งก็คือแสดงผลค่าตัวแปร i คือ แสดงเลข 5 ออกมา และขึ้นบรรทัดใหม่ แล้วเมื่อเจอคำสั่ง $i-- จำกันได้ไหมเพิ่งผ่านไปในบทความที่แล้ว มีความหมายว่าลบค่า $i ไป 1 ดังนั้นตอนนี้ $i=4 แล้วนะ

จากนั้นโปรแกรมจะเจอคำสั่ง while ซึ่งจะทำการเช็คค่าในตัวแปร i คือ หากตัวแปร i มีค่ามากกว่าหรือเท่ากับ 1 โปรแกรมจะวนลูปทำคำสั่งในลูป do อีกครั้ง การทำงานก็เหมือนคำสั่ง while ก็คือเช็คจนเงื่อนไขเป็นเท็จจึงจะหลุดลูปและจบการทำงาน

คำถามคือ แล้วเมื่อไหร่ละจะหลุดลูป คำตอบก็คือเมื่อมันลดค่า $i ลงรอบละ 1 เรื่อย ๆ จนเมื่อ $i=0 ก็จะหลุดลูปและจบการทำงานค่ะ

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

การเลือกทำงานตามเงื่อนไข (คำสั่ง IF ELSE SWITCH)

8.การเลือกทำงานตามเงื่อนไข (คำสั่ง IF ELSE SWITCH)

1.คำสั่ง 2 ทางเลือก
คำสั่ง 2 ทางเลือกเป็นพื้นฐานของคำสั่งเงื่อนไขในภาษาคอมพิวเตอร์นั้น คำสั่งประเภทนี้จะต้องมีเงื่อนไขการตัดสินใจ เพื่อใช้หาคำตอบว่าจะไปทางไหน ถ้าเงื่อนไขเป็นจริงก็จะไปทำคำสั่งทางหนึ่ง แต่ถ้าเงื่อนไขเป็นเท็จก็จะไปทำคำสั่งอีกทางหนึ่ง ผังการทำงานของคำสั่ง 2 ทางเลือก

If…else คำสั่ง if…else นี้ จะต้องใช้เงื่อนไขเพื่อใช้เลือกว่าจะทำคำสั่งไหน ตามรูปที่ 6-4 แสดง ผังการทำงานของคำ สั่ง if…else ถ้าเงื่อนไขเป็นจริงก็จะไปทำคำสั่งที่ 1 แต่เงื่อนไขเป็นเท็จก็จะไปทำคำสั่งที่ 2 ซึ่งไม่มีโอกาสที่จะทำทั้งสองคำสั่งได้เลย

2. If

If คำสั่ง if ก็คือ คำสั่ง if…else แต่ที่ไม่มี else เพราะคำสั่งทางเป็นเท็จไม่มี หรือจากรูปที่ 6-4 ไม่มีคำสั่งที่ 2 นั่งเอง ซึ่งก็คือจะต้องเป็นจริงเท่านั้นจึงจะทำคำสั่งได้ จากรูปที่ 6-7แสดงให้ เห็นการเปลี่ยนจากคำสั่ง if…else เป็นคำสั่ง if

3.คำสั่งหลายทางเลือก

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

Switch
Switch เป็นคำสั่งที่แปลงมาจากคำสั่ง Nested if คำสั่งนี้จะมีตัวแปรหนึ่งตัวที่ใช้หาว่าจะไปทำที่คำสั่งไหนหรือ case ไหน ซึ่งในรูปที่ 6-11 แสดงผังการทำงานคำสั่ง switch ผู้ใช้สามารถสร้าง case ให้มีจำนวนตามต้องการได้ และชุดคำสั่งของคำสั่ง switch นั้นได้แสดงในรูปที่ 6-12

ประเภทของข้อมูลภาษาซี

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

1	ข้อมูลชนิดตัวอักษร (Character)	คือข้อมูลที่เป็นรหัสแทนตัวอักษรหรือค่าจำนวนเต็ม ได้แก่ ตัวอักษร ตัวเลขและกลุ่มตัวอักขระพิเศษใช้พื้นที่ในการเก็บข้อมูล 1 ไบต ์
2	ข้อมูลชนิดจำนวนเต็ม (Integer)	คือข้อมูลที่เป็นเลขจำนวนเต็ม ได้แก่ จำนวนเต็มบวก จำนวนเต็มลบ และศูนย์ ข้อมูลชนิดจำนวนเต็มใช้พื้นที่ในการเก็บข้อมูล ขนาด 2 ไบต์
3	ข้อมูลชนิดจำนวนเต็มที่มีขนาด 2 เท่า (Long Integer)	คือข้อมูลที่เป็นเลขจำนวนเต็ม ใช้พื้นที่ในการเก็บเป็น 2 เท่าของ Integer คือมีขนาด 4 ไบต ์
4	ข้อมูลชนิดเลขทศนิยม (Float)	คือข้อมูลที่เป็นเลขทศนิยม ขนาด 4 ไบต์
5	ข้อมูลชนิดเลขทศนิยมอย่างละเอียด (Double)	คือข้อมูลที่เป็นเลขทศนิยม ใช้พื้นที่ในการเก็บข้อมูลเป็น 2 เท่าของ float คือมีขนาด 8 ไบต์

โครงสร้างข้อมูล (Data Structure)

โครงสร้างข้อมูล (Data Structure) คืออะไร

คือ รูปแบบของการจัดระเบียบของข้อมูล ซึ่งมีอยู่หลายรูปแบบ เช่น เขตข้อมูล(Field), แถวลำดับ(Array), ระเบียน(Record), ต้นไม้(Tree), ลิงค์ลิสต์(Link List) เป็นต้น (ทักษิณา สวนานนท์, 2544, หน้า 161) [4]p.12

คือ รูปแบบวิธีการจัดระเบียบของข้อมูลที่ได้จากการดำเนินการทางคณิตศาสตร์(Operations) เพื่อให้สามารถจัดการกับข้อมูลที่ใช้กับระบบคอมพิวเตอร์ได้ [4]p.12

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

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

โอภาส เอี่ยมสิริวงศ์, "โครงสร้างข้อมูล (Data Structures)"
บริษัท ซีเอ็ดยูเคชั่น จำกัด., กรุงเทพฯ, 2549.

โครงสร้างข้อมูล (Data Structure)
- บิท (Bit) คือ ข้อมูลที่มีขนาดเล็กที่สุด เป็นข้อมูลที่เครื่องคอมพิวเตอร์เข้าใจ และใช้งานได้ ได้แก่ 0 หรือ 1
- ไบท์ (Byte) หรือ อักขระ (Character) คือ ตัวเลข หรือ ตัวอักษร หรือ สัญลักษณ์พิเศษ จำนวน 1 ตัว
- ฟิลด์ (Field) หรือ เขตข้อมูล คือ ไบท์ หรือ อักขระตั้งแต่ 1 ตัวขึ้นไปรวมกันเป็นฟิลด์ เช่น เลขประจำตัว หรือ ชื่อพนักงาน
- เรคคอร์ด (Record) หรือระเบียน คือ ฟิลด์ตั้งแต่ 1 ฟิลด์ขึ้นไป ที่มีความสัมพันธ์เกี่ยวข้องกันมารวมกัน
- ไฟล์ (File) หรือ แฟ้มข้อมูล คือ หลายเรคคอร์ดมารวมกัน เช่น ข้อมูลที่อยู่นักเรียนมารวมกัน
- ฐานข้อมูล (Database) คือ หลายไฟล์ข้อมูลมารวมกัน เช่น ไฟล์ข้อมูลนักเรียนมารวมกันในงานทะเบียน แล้วรวมกับไฟล์การเงิน

ศัพท์เทคนิค (Technical Terms)

phrase "a picture is worth a thousand words" [2]p.1
โครงสร้างข้อมูลพื้นฐาน ประกอบด้วยแบบของข้อมูลเบื้องต้น คือ 1)บิท(Binary) 2)อักขระ(Character) 3)ฟิลด์(Field) 4)เรคอร์ด(Record) 5)ไฟล์(File) 6)ฐานข้อมูล(Database) [4]p.12
วิเคราะห์ปัญหา (Problem Analysis) คือ การแยกปัญหาใหญ่ออกเป็นส่วน เพื่อนำไปสู่การแก้ปัญหาแต่ละส่วน
อัลกอริทึม (Algorithm) (มีความเป็นนามธรรมอยู่ในตัวเป็นธรรมชาติ)
คือ กลุ่มของขั้นตอนหรือกฎเกณฑ์ที่จะนำพาไปสู่การแก้ปัญหา [3]p.37

คือ ขั้นตอนวิธีที่ประกอ้บด้วยชุดคำสั่งเป็นขั้นเป็นตอนที่ชัดเจน และรับประกันว่าเมื่อได้ปฏิบัติถูกต้องตามขั้นตอนจนครบก็จะได้ผลลัพธ์ที่ถูกต้องตามต้องการ [3]p.37

คือ รูปแบบของการกำหนดการทำงานอย่างเป็นขั้นตอน ซึ่งผ่านการวิเคราะห์และแยกแยะ เพื่อการแก้ปัญหาต่าง ๆ ตามลำดับขั้น อาจเลือกใช้ภาษาไทยหรือภาษาอังกฤษตามความถนัด เพื่อนำเสนอขั้นตอนของกิจกรรมก็ได้ [4]p.17
รหัสเทียม หรือซูโดโค้ด (Pseudo Code)
คือ รหัสจำลองที่ใช้เป็นตัวแทนของอัลกอริทึม โดยมีถ้อยคำหรือประโยคคำสั่งที่เขียนอยู่ในรูปแบบของภาษาอังกฤษที่ไม่ขึ้นกับภาษาคอมพิวเตอร์ใดภาษาหนึ่ง [3]p.37

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

คือ รูปภาพ (Image) หรือสัญลักษณ์(Symbol) ที่ใช้เขียนแทนขั้นตอน คำอธิบาย ข้อความ หรือคำพูด ที่ใช้ในอัลกอริทึม (Algorithm) เพราะการนำเสนอขั้นตอนของงานให้เข้าใจตรงกัน ระหว่างผู้เกี่ยวข้อง ด้วยคำพูด หรือข้อความ ทำได้ยากกว่า [#]
การโปรแกรมโครงสร้าง (Structured Programming) คือ การกำหนดขั้นตอนให้เครื่องคอมพิวเตอร์ทำงานโดยมีโครงสร้างการควบคุมพื้นฐาน 3 หลักการ ได้แก่ 1)การทำงานแบบตามลำดับ(Sequence) 2)การเลือกกระทำตามเงื่อนไข(Decision หรือ Selection) และ 3)การทำงานแบบทำงานซ้ำ (Repetition หรือ Iteration หรือ Loop) #
อาร์เรย์ (Array)
คือ ชุดของข้อมูลในชื่อเดียวกันที่มีได้หลายสมาชิก โดยสมาชิกถูกจัดเรียงเป็นลำดับ และมีรูปแบบเป็นแบบใดแบบหนึ่ง

คือ การรวมกลุ่มของตัวแปรที่สามารถใช้ตัวแปรชื่อเดียวกันแทนข้อมูลสมาชิกได้หลาย ๆ ตัวในคราวเดียวกัน ด้วยการใช้เลขดรรชนี (Index) หรือซับสคริปต์ (Subscript) เป็นตัวอ้างอิงตำแหน่งสมาชิกบนแถวลำดับนั้น ๆ [3]p.80
โอเปอเรชั่น (Operation) คือ การกระทำที่สามารถทำกับโครงสร้างนั้น เช่น โอเปอเรชั่นของอาร์เรย์ ได้แก่ 1)การท่องเข้าไป (Traversal) 2)การค้นหาข้อมูลที่ต้องการ(Searching) 3)การแทรกข้อมูลใหม่(Insertion) 4)การลบข้อมูล (Deletion) 5)การเรียงกลับหลัง(Reversing) 6)การเรียงลำดับ(Sorting) [1]p.14
นามธรรม (Abstract) คือ เป็นแนวทางพื้นฐานของมนุษย์ที่ใช้จัดการกับความซับซ้อน (Grady Booch) [3]p.41 โดยเรื่องราวของนวนิยายเป็นจินตนาการในหัวของผู้เขียนถือเป็นนามธรรม เมื่อถ่ายทอดผ่านตัวแทน (Representation) ทางหนังสือด้วยภาษาต่าง ๆ ก็จะออกมาเป็นรูปธรรม ดังนั้นการเขียนโปรแกรมต้องเริ่มต้นด้วยนามธรรม หรือจินตนาการจัดการความซับซ้อนก่อนนำเสนอเป็นรูปธรรม เพื่อประมวลผล
ชนิดข้อมูลนามธรรม (Abstract Data Type) คือ เครื่องมือกำหนดโครงสร้างข้อมูลที่ประกอบด้วยชนิดของโครงสร้างข้อมูล รูปแบบการดำเนินการ หรือแยกได้ 3 ส่วนคือ รูปแบบข้อมูล (Element) โครงสร้าง (Structure) และ การดำเนินการ (Operations) [4]p.25
โปรแกรม (Program) คือ ตัวแทนของอัลกอริทึม
โปรเซส (Process) คือ กิจกรรมที่ประมวลผลตามขั้นตอนของอัลกอริทึม

ความรู้เบื้องต้นเกี่ยวกับการพัฒนาระบบ

การพัฒนาโปรแกรมประกอบด้วยขั้นตอนพื้นฐาน 7 ขั้นตอน [3]p.19
1. กำหนดปัญหา (Define the Problem)
2. ร่างรายละเอียดแนวทางแการแก้ไขปัญหา (Outline the Solution)
3. พัฒนาอัลกอริทึม (Develop Algorithm) อาจนำเสนอด้วย Flowchart, DFD, ER หรือ UML
4. ตรวจสอบความถูกต้องของอัลกอริทึม (Test the Algorithm for Correctness)
5. เขียนโปรแกรม (Programming)
6. ทดสอบโปรแกรม (Testing)
7. จัดทำเอกสารและบำรุงรักษาโปรแกรม (Document and Maintain the Program)

กรรมวิธีการออกแบบโปรแกรม (Program Design Methodology) [3]p.21 #
- การออกแบบโปรแกรมแบบ Procedure-Driven
- การออกแบบโปรแกรมแบบ Event-Driven
- การออกแบบโปรแกรมแบบ Data-Driven

การเขียนโปรแกรมแบบ Procedural และ Object-Oriented [3]p.22
- การเขียนโปรแกรมแบบบนลงล่าง (Top-Down Development)
- การออกแบบโปรแกรมในลักษณะโมดูล (Modular Design)
- การโปรแกรมเชิงวัตถุ (Object-Oriented Programming) 
คือการโปรแกรมที่ให้ความสำคัญกับการรวมวัตถุ และกระบวนการได้ด้วยกัน เพื่อสืบทอด (Inheritance) หรือนำกลับมาใช้ใหม่ได้ (reused)


โดยการนำทั้งวัตถุ และกระบวนการมารวมกัน มักเก็บไว้ใน Class ซึ่งหมายถึง ต้นแบบของวัตถุ
ต.ย. โปรแกรมแบบ Top-Down ด้วยภาษา Pascal


program p01;


begin




Writeln('burin');




Writeln('rujjanapan');


end. 





คอมพิวเตอร์สามารถคำนวณได้ เครื่องหมายทางคณิตศาสตร์ เช่น + - * / ^ ( ) [3]p.164


x = 4 / 2 + 4 ^ 2 - 1 * 2 + 3 19 กด Ctrl + A = คำตอบ


y = 36 / (2 + 4) ^ 2 - 1 * 2 + 3 2


z = 4 / 2 + 4 ^ (2 - 1) * 2 + 3 13



ต.ย. โปรแกรมแบบ Modular ด้วยภาษา Pascal
program p02;
procedure xName;
begin
Writeln('burin');
end;
begin


xName;
end. 

ต.ย. โปรแกรมแบบ OOP ด้วยภาษา Java
class father {
String n;
private void pname () {


n = "burin"; 


return n;
}
}
class child extends father {
child() {


n = "rujjanapan";


System.out.println(pname()); // yonok
}
public static void main(String[] a) {


new child();
}
private void pname () {


n = "yonok"; 


return n;
}
}

















ภาพแสดง ความแตกต่างของ Stack กับ Heap และ pass by value กับ pass by reference

อัลกอริทึม (Algorithm) http://www.thaiall.com/datastructure/pseudocode.htm

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

ต.ย. อัลกอริทึมที่ 1 : ต้มมาม่า [3]p.25
1. หามาม่าไว้ 1 ซอง
2. ฉีกซองมาม่าและเทลงถ้วยเปล่า
3. ฉีกซองเครื่องปรุง แล้วเทลงถ้วยเดิม
4. ต้มน้ำให้ร้อนได้ที่ แล้วเทลงถ้วย
5. ปิดฝาไว้ 3 นาที
6. เปิดฝา แล้วรับประทาน

คำถาม : ต้มมาม่า
1. มีขั้นตอนใดสลับกันได้
2. ถ้าเปลี่ยนข้อความ จะเปลี่ยนอย่างไร
3. ถ้าทำหลายถ้วยจะทำอย่างไร

? คน 3 คนใครอายุมากที่สุด และเป็นเท่าใด

ต.ย. อัลกอริทึมที่ 2 : หาค่าเฉลี่ย ใช้ Pseudo Code 
1. set variable
2. loop
1. read number into variable


2. add number to total


3. increase counter
3. end loop
4. set average = total / counter
5. print average

คำถาม : หาค่าเฉลี่ย
1. เขียนเป็นภาษาไทยอย่างไร
2. แต่ละบรรทัดในจาวาคืออะไร
3. สลับบรรทัดใดในจาวาได้บ้าง
4. ไม่มีตัวแปร avg จะได้หรือไม่

1.


2.



3.
4.
5.

ภาษาจาวา
byte x;
int i = 0;
int total = 0;
while (i < 5) {
  x = System.in.read();
  total = total + x;
  i++;
}
double avg = total/i;
System.out.println(avg);

ปฏิบัติการพื้นฐานของเครื่องคอมพิวเตอร์ [3]p.37

1. รับข้อมูล (input device)
2. แสดงผล (output device)
3. คำนวณ (limit and sequence)
4. กำหนดค่าตัวแปร (storage)
5. เปรียบเทียบ หรือเลือกทำงาน (compare or decision)
6. ทำซ้ำ (repeation or loop)

หน่วยความจำ (Memory)

โครงสร้างหน่วยความจำ (Memory Architecture)
การจัดสรรหน่วยความจำ (Memory Allocation)
- แบบคงที่ (Static)
- แบบเปลี่ยนแปลงได้ (Dynamic)
ตารางแฟท (FAT = File Allocatio Table)
- Directory Table
- Memory Pointer
File Attribute
- Archive file
- System file
- Readonly file
- Hidden file

ต.ย. แฟ้ม adisinit.exe มีขนาด 35.1 KB ใช้พื้นที่ 9 Block ๆ ละ 4 KB
เพราะเครื่องนี้แบ่ง 1 Cluster มีขนาด 8 Sectors

ชนิดข้อมูลนามธรรม (Abstract Data Type : ADT)

ชนิดข้อมูลนามธรรม (Abstract Data Type) คือ เครื่องมือกำหนดโครงสร้างข้อมูลที่ประกอบด้วยชนิดของโครงสร้างข้อมูล รูปแบบการดำเนินการ 
หรือแยกได้ 3 ส่วนคือ รูปแบบข้อมูล (Element) โครงสร้าง (Structure) และ การดำเนินการ (Operations) [4]p.25

แบบประเภทข้อมูลตามลักษณะความสัมพันธ์ในข้อมูล
1. ข้อมูลเชิงเดี่ยว (Atomic Data)
2. ข้อมูลเชิงประกอบ (Composite Data) 

ชนิดข้อมูลนามธรรม (ADT) มิใช้โครงสร้างข้อมูล [3]p.50
แต่เป็นรูปแบบระดับแนวคิดหรือรูปแบบข้อมูลเชิงลอจิคอล 
1. รูปแบบข้อมูลเชิงลอจิคอล (Logical Form) เป็นการนิยามด้วย ADT
2. รูปแบบข้อมูลเชิงฟิสิคัล (Psysical Form) เป็นการนำ ADT มาใช้

ประสิทธิภาพของอัลกอริทึม (Algorithm Efficiency)

ประเด็นที่ใช้วัดประสิทธิภาพ [3]p.58

1. เวลาที่ใช้ประมวลผล (Running Time)

2. หน่วยความจำที่ใช้ (Memory Requirement)

3. เวลาที่ใช้แปลโปรแกรม (Compile Time)

4. เวลาที่ใช้ติดต่อสื่อสาร (Communication Time)

ปัจจัยที่ส่งผลต่อความเร็วในการประมวลผล

1. ความเร็วของเครื่องคอมพิวเตอร์ (CPU, Main Board)

2. อัลกอริทึมที่ออกแบบเพื่อใช้งาน

3. ประสิทธิภาพของตัวแปลภาษา

4. ชุดคำสั่งที่สั่งประมวลผลเครื่องคอมพิวเตอร์

5. ขนาดของหน่วยความจำในเครื่องคอมพิวเตอร์

6. ขนาดของข้อมูลนำเข้า และผลลัพธ์จากการประมวลผล

- การวัดประสิทธิภาพของอัลกอริทึม (Efficiency Algorihm)

คือ วัดจากพื้นที่ทำงาน และเวลา แต่กับคอมพิวเตอร์ในปัจจุบันที่มีศักยภาพสูง การวัดประสิทธิภาพจากเวลาอาจไม่เห็นความแตกต่าง
- การวิเคราะห์บิ๊กโอ (Big-O Analysis)

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

ปัจจุบันมีการเปลี่ยนจาก f() มาเป็น Big-O notaion เพื่อใช้ Big-O วัดประสิทธิภาพของอัลกอริทึม
- ขั้นตอนการเปลี่ยน f() เป็น Big-O Notation [4]p.23

1. ปรับฟังก์ชันให้อยู่ในรูปสัมประสิทธิ์อย่างง่าย คือตัดตัวประกอบออก ให้เหลือเพียงค่าของโพลิโนเมียน (คือ n ยกกำลัง)

f(n) = n( (n + 1) / 2 )

= ((1/2)(n ^ 2)) + (1/2(n))

= (n ^ 2) + n

2. ตัดค่าของตัวประกอบออก

= n ^ 2

3. นำฟังก์ชันมาตรฐานมาเขียนในรูปของ Big-O Notation

O(f(n)) = O(n ^ 2)

ความหมายของลอการิทึม
- ลอการิทึม (อังกฤษ: logarithm) เป็นการดำเนินการทางคณิตศาสตร์ที่เป็นฟังก์ชันผกผันของฟังก์ชันเลขชี้กำลัง
- ค่าลอการิทึมของจำนวนหนึ่งโดยกำหนดฐานไว้ให้ จะมีค่าเทียบเท่ากับ การเอาฐานมายกกำลังค่าลอการิทึม ซึ่งจะให้คำตอบเป็นจำนวนนั้น

ลูปแบบเพิ่ม 2 เท่า
for(i=1;i<1000;i*=2){ echo i; }
เช่น 1 2 4 8 16 32 64

ลูปแบบลด 2 เท่า
for(i=1;i<1000;i/=2){ echo i; }
เช่น 1000 500 250 125 62.5 31.25

- ต.ย.1 จงหาผลบวกของการบวกจำนวนที่เริ่มต้นตั้งแต่ 1 - 10
ฟังก์ชัน คือ f(n) = n( (n + 1) / 2 )


= ((1/2)(n ^ 2)) + (1/2(n))


= (n ^ 2) + n


= n ^ 2


O(f(n)) = O(n ^ 2)
- ต.ย.2 จงแปลง  f(n) = a*n^k + a*n^k-1 +  .. a*n^0 เป็น Big-O Notation


ฟังก์ชัน คือ f(n) = a*n^k + a*n^k-1 +  .. a*n^0


= n^k + n^k-1 +  .. n^0 (ปรับให้อยู่ในรูปสัมประสิทธิ์อย่างง่าย)


= n^k (ตัดค่าของตัวประกอบออก)


O(f(n)) = O(n ^ k) (เขียนในรูปของ Big-O Notation)
- ต.ย.3 จงแปลง  f(n) = 4n + 7 เป็น Big-O Notation [6]p.50


ฟังก์ชัน คือ f(n) = 4n + 7


= n + 7 (ปรับให้อยู่ในรูปสัมประสิทธิ์อย่างง่าย)


= n (ตัดค่าของตัวประกอบออก)


O(f(n)) = O(n) (เขียนในรูปของ Big-O Notation)
- ต.ย.4 จงแปลง  f(n) = 1009 เป็น Big-O Notation [6]p.51


ฟังก์ชัน คือ f(n) = 1009


= 1009 (ปรับให้อยู่ในรูปสัมประสิทธิ์อย่างง่าย)


= 1 (ตัดค่าของตัวประกอบออก)


O(f(n)) = O(1) (เขียนในรูปของ Big-O Notation)



ดร.บุญญฤทธิ์  อุยยานนวาระ

เปรียบเทียมประสิทธิภาพของ Big-O กับความเร็วของยวดยาน ดังนี้
+ O(1) เหมือนเครื่องว๊าบ หรือเครื่องย้ายมวลสาร คือ ไกลแค่ไหนไม่เกี่ยว 
+ O(log n) เหมือนเครื่องบินโดยสาร 
+ O(n) - เหมือนรถฟอร์มูล่าวัน ระยะทางไกลขึ้น ก็ขับนานขึ้น
+ O(n log n) - เหมือนรถยนตทั่วไป ยิ่งไกลยิ่งช้า
+ O(n^2) - เหมือนมอร์เตอร์ไซด์ 
+ O(n^3) - เหมือนจักรยาน 
+ O(2^n) - เหมือนคนเดิน

การทำซ้ำ หรือลูป มีหลายแบบ
- ลูปแบบเชิงเส้น (Linear Loops)
- ลูปแบบลอการิธมิค (Logarithmic Loops)
- ลูปแบบซ้อน (Nested Loops)

ลูปแบบเชิงเส้น (Linear Loops) [3]p.59
f(n) = n
for (i=0; i< n; i++)




application code
f(n) = n / 2


for (i=0; i< n; i+=2)




application code
ลูปแบบลอการิทึม (Logarithmic Loops)
f(n) = logn


for (i=0; i< n; i*=2)




application code
f(n) = log2n


for (i=0; i< n; i/=2)




application code
ลูปแบบซ้อน (Nest Loops)
ลูปแบบซ้อนชนิดกำลังสอง (Quadratic)
f(n) = n^2


for (i=0; i< n; i++)




for (j=0; j< n; j++)






application code
ลูปแบบซ้อนชนิดลอการิทึมเชิงเส้น (Linear Logarithmic)
f(n) = nlogn


for (i=0; i< n; i++)




for (j=0; j< n; j*=2)






application code
ลูปแบบซ้อนกำลังสองชนิดขึ้นต่อกัน (Dependent Quadratic)
f(n) = n( (n + 1) / 2 )


for (i=0; i< n; i++)




for (j=0; j< i; j++)






application code

อาร์เรย์ (Array)

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

คือ การรวมกลุ่มของตัวแปรที่สามารถใช้ตัวแปรชื่อเดียวกันแทนข้อมูลสมาชิกได้หลาย ๆ ตัวในคราวเดียวกัน ด้วยการใช้เลขดรรชนี (Index) หรือซับสคริปต์ (Subscript) เป็นตัวอ้างอิงตำแหน่งสมาชิกบนแถวลำดับนั้น ๆ [3]p.80

- อาร์เรย์หนึ่งมิติ (One Dimension Array)
รูปแบบของอาร์เรย์ คือ arrayname[L:U]


arrayname คือ ชื่อของตัวแปรอาร์เรย์ เช่น x[5]


L คือ ขอบเขตล่างสุด (Lower Bound) 


U คือ ขอบเขตบนสุด (Upper Bound)


จำนวนสมาชิก = U - L + 1
- อาร์เรย์สองมิติ (Two Dimension Array)


จำนวนสมาชิก = (U1 - L1 + 1) * (U2 - L2 + 1)


ตัวอย่างอารย์เรย์ ภาษาเบสิก เช่น Dim x(7, 24) As Byte


ตัวอย่างอารย์เรย์ ภาษาซี เช่น int a[][] = new int[4][3]; 


ตัวแรกมักหมายถึง แถว (rows) ตัวที่สองหมายถึง หลัก (columns)
- เมทริกซ์ คล้ายกับอาร์เรย์ 2 มิติ
- ตำแหน่งในหน่วยความจำ


B คือ ตำแหน่ง หรือแอดเดรสเริ่มต้น (Base Address)


w คือ จำนวนช่องของหน่วยความจำที่จัดเก็บข้อมูลต่อหนึ่งสมาชิก


ตำแหน่งในหน่วยความจำ LOC( a[i] ) คือ B + w (i - L)

http://msdn.microsoft.com

เรคอร์ด (Record)

ระเบียนข้อมูล หรือเรคอร์ด


ตารางข้อมูลในฐานข้อมูล NorthWind ประกอบด้วย 8 ตาราง คือ
Categories, Customers, Shippers, Products, 
Orders, Order Details, Employees, Suppliers

แบบฝึกหัด : จงเขียนความสัมพันธ์ระหว่างตาราง

ลิงค์ลิสต์ (Linked List) [3]p.101

ลิสต์ (Lists) หรือรายการ ถือเป็นการจัดเก็บข้อมูลชนิดหนึ่ง ซึ่งข้อมูลเชื่อมต่อกันแบบเชิงเส้น แต่ละข้อมูลมักเรียกว่า อีลิเมนต์ (Element) หรือสมาชิก (Member) โดยแบ่งโดยพื้นฐานได้ 2 แบบคือแบบทั่วไป (General) และแบบจำกัด (Restricted) ซึ่งแนวคิดของลิงค์ลิสต์จะกำหนดให้แต่ละสมาชิกจะประกอบด้วย ข้อมูล (Data) และลิงก์ (Link) โดยข้อมูลอาจประกอบด้วยหลายฟิลด์ก็ได้
การดำเนินงานพื้นฐานของลิสต์ (Basic Operations of List)
1. การแทรก (Insertion)
2. การลบ (Deletion)
3. การปรับปรุง (Updation)
4. การท่องเข้าไปในลิสต์ (Traversal)

ตัวชี้ข้อมูลด้วยภาษาปาสคาล [2]p.220 Binary Tree type nodeptr = ^trnode; trnode = record data : integer; leftptr : nodeptr; rightptr : nodeptr; end;	ตัวชี้ข้อมูลด้วยภาษาซี [3]p.193 Abstract Data Type ของ คิว typedef struct node { void* dataptr; struct node* next; } QUEUE_NODE; typedef struct { QUEUE_NODE* front; QUEUE_NODE* rear; int count; } QUEUE; QUEUE* createQueue (void); bool enqueue (QUEUE* q, void* itemptr);
สร้างคิว [2]p.221 var root : nodeptr; begin maket(root); procedure maket(var t:nodeptr); begin new(t); t^.data := 123; t^.leftptr := nil; t^.rightptr := nil; end;	สร้างคิว QUEUE* createQueue (void) { QUEUE* q; q = (QUEUE*) malloc (sizeof (QUEUE)); if (q) { q->front = NULL; // node ชี้ตัวแรก q->rear = NULL; // node ชี้ตัวสุดท้าย q->count = 0; } }
เพิ่มข้อมูลในคิว [2]p.224 new(n); inserted := false; o := t; while not inserted do begin if num <= o^.data then if o^.leftptr <> nil then o := o^.leftptr; else begin o^.leftptr := n; inserted := true; end else if o^.rightptr <> nil then o := o^.rightptr; else begin o^.rightptr := n; inserted := true; end; end; n^.data := num; n^.leftptr := nil; n^.rightptr := nil;	เพิ่มข้อมูลในคิว bool enqueue (QUEUE* q, void* itemptr) { QUEUE_NODE* newptr; if (!(newptr = (QUEUE*) malloc (sizeof(QUEUE)))) return false; newptr->dataptr = itemptr; newptr->next = NULL; if (q->count == 0) q->front = newptr; else q->rear->next = newptr; (q->count)++; q->rear = newptr; return true; }

// Test of Linked List #1/2
class BlankNode {
  public Object data;
  public BlankNode next;
  public BlankNode(Object data) {
    this.data = data;
    this.next = null;
  }
  public String toString() { 
    return data.toString(); 
  }
}

// Test of Linked List #2/2
class ActiveNode {
  public BlankNode head;
  public BlankNode tail;
  ActiveNode() {
    this.head = null;
    this.tail = null;
  }
  void createFirstNode(Object data) {
    BlankNode newNode = new BlankNode(data);
    head = newNode;
    tail = newNode;
  }
  void createNextNode(Object data) {
    BlankNode newNode = new BlankNode(data);
    newNode.next = head;
    head = newNode;
  }
  ActiveNode removeNode(String data, ActiveNode myNode) {    
    BlankNode previousNode = null;
    BlankNode currentNode = myNode.head;
    while(currentNode != null) {
      if (currentNode.data.equals(data))  { 
        System.out.println("del: " + currentNode.data.toString()); 
        if(previousNode == null) { // กรณี node ที่ต้องการลงเป็น node แรก
          myNode.head = currentNode.next; 
        } else {
          previousNode.next = currentNode.next;
        }
      }
      previousNode = currentNode; 
      currentNode = currentNode.next;
    } System.out.println("===");     
    return myNode;
  }
  void printNode(ActiveNode myNode) {
    BlankNode pointtonode = myNode.head;
    while(pointtonode != null) {
      System.out.println(pointtonode.data.toString()); 
      pointtonode = pointtonode.next;
    } System.out.println("===");     
  }
  void findNode(String data, ActiveNode myNode) {
    BlankNode pointtonode = myNode.head;
    while(pointtonode != null) {
      if (pointtonode.data.equals(data))  { System.out.print("*"); }
      System.out.println(pointtonode.data.toString()); 
      pointtonode = pointtonode.next;
    } System.out.println("===");     
  }
  public static void main(String arg[]) {
    ActiveNode myNode = new ActiveNode();
    myNode.createFirstNode("ant");
    myNode.createNextNode("bat");
    myNode.createNextNode("cat");
    myNode.printNode(myNode);
    myNode = myNode.removeNode("bat", myNode);
    myNode.findNode("cat",myNode);
    myNode = myNode.removeNode("ant", myNode);
    myNode.printNode(myNode);
    myNode = myNode.removeNode("cat", myNode);
    myNode.printNode(myNode);
  }  
}

สแต็ก (Stack)

- Push คือ เพิ่มข้อมูลลงสแต็ก [3]p.137
- Pop คือ นำข้อมูลบนสุดไปใช้ และลบออกจากสแต็ก
- Stack Top คือ นำข้อมูลบนสุดไปใช้ แต่ไม่ลบออกจากสแต็ก
- Infix คือ นิพจน์ทางคณิตศาสตร์ทั่วไปที่เราใช้กัน [3]p.159
- Postfix คือ นิพจน์ที่โอเปอเรเตอร์อยู่หลังโอเปอแรนต์ เช่น AB+
- Prefix คือ นิพจน์ที่โอเปอเรเตอร์อยู่หน้าโอเปอแรนต์ เช่น +AB

อาจกล่าวอีกอย่างได้ว่า
- ตัวดำเนินการ คือ เครื่องหมายทางคณิตศาสตร์ (Operator)
- ตัวถูกดำเนินการ คือ สัญลักษณ์หรือตัวแปร (Operand)
- Infix คือ ตัวดำเนินการอยู่ระหว่างตัวถูกดำเนินการ
- Postfix คือ ตัวดำเนินการอยู่หลังตัวถูกดำเนินการ
- Prefix คือ ัวดำเนินการอยู่ก่อนตัวถูกดำเนินการ


กฎเกณฑ์สำหรับการแปลงนิพจน์ Infix มาเป็นนิพจน์ Postfix [3]p.160
ขั้นตอนที่ 1. ใส่เครื่องหมายวงเล็บให้ทุกนิพจน์ แยกลำดับการคำนวณ เช่น คูณ หาร มาก่อน บวก ลบ
ขั้นตอนที่ 2. เปลี่ยนสัญลักษณ์ Infix ในแต่ละวงเล็บให้มาเป็นสัญลักษณ์แบบ Postfix โดยเริ่มจากวงเล็บในสุดก่อน
ขั้นตอนที่ 3. ถอดวงเล็บออก

ฟังก์ชันที่เกี่ยวกับสแต็ก [3]p.143
1. Create Stack คือ สร้างหัวสแต็ก
2. Push Stack คือ เพิ่ม
3. Pop Stack คือ ดึงออก
4. Stack Top คือ อ่านบนสุด
5. Empty Stack คือ ตรวจการว่าง
6. Full Stack คือ ตรวจการเต็ม
7. Stack Count คือ นับสมาชิก
8. Destroy Stack คือ ลบข้อมูลและหัวสแต็ก

infix	postfix	prefix ?
A * B + C / D	A B * C D / +	+ * A B / C D
A * (B + C) / D	A B C + * D /	/ * A + B C D
A * (B + C / D)	A B C D / + *	* A + B / C D

กฎเกี่ยวกับการแปลง infix เป็น postfix
1. ถ้า input เป็น operand ให้ออกเป็น postfix
2. ถ้า input เป็น operator แล้ว stack ว่างให้ลง stack
3. ถ้า input มีลำดับสำคัญกว่าใน stack ให้ลง stack
4. ถ้า input สำคัญน้อยกว่าใน stack ย้ายใน stack ไปเป็น postfix

ต.ย. 1 แปลง A - B / C เป็น Postfix

ขั้นตอนที่ 1 :

A - (B / C)

ขั้นตอนที่ 2 :

A - (BC /)

A(BC/)-

ขั้นตอนที่ 3 :

ABC/-

โจทย์ให้ฝึกแปลงจาก infix เป็น postfix
1. a + b - c * d / e - f + g * h
2. a * b - c * d + e - f + g * h
3. a + b * c * d / (e * f) * g + h
4. a + b - (c * d) - e - f + g - h
5. a + (b + c) * d / e + f / g * h
6. a / b * c * d * (e - f) + g ^ h
7. (a ^ b) / c * d / e - f + g + h
8. a * b ^ c * ((d - e) - f) * g - h
9. a + b - c ^ ((d - e) - f) * (g - h)
10. a / (b + c) * (d + (e + f)) ^ g + h
+ stack_cal_postfix

คิว (Queue) : คิว ใน wikipedia.org

- คิว (Queue)

คือ โครงสร้างข้อมูลเชิงเส้น มีลักษณะเป็นแถวเรียงต่อกัน ซึ่งมีลักษณะแบบเข้าก่อนออกก่อน (FIFO : First In First Out)
- ตัวอย่างของคิวที่พบได้ในปัจจุบัน เช่น แถวซื้ออาหาร รอฝากเงิน คิวรอพริ้น เป็นต้น

ฟังก์ชันที่เกี่ยวกับคิว ประกอบด้วย enqueue, dequeue, queue front, queue rear

ทรี (Tree) :

- ไบนารีเสิร์ชทรี (Binary Search Tree)

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

คือ ทรีที่คิดค้นโดย G.M.Adelson-Velskii และ E.M.Landis โดยทรีแบบนี้จะมี ความสูงของซับทรี มาหักลบกันแล้วต้องมีค่าไม่มากกว่า 1
- ฮีพทรี (Heap Tree)

คือ ไบนารีทรีแบบสมบูรณ์หรือเกือบสมบูรณ์ ซึ่งโหนดพ่อจะมีค่ามากกว่าหรือเท่ากบับซับทรีด้านซ้าย และด้านขวา
แนวคิดพื้นฐานของทรี [3]p.211
- โหนดราก (Root Node) คือ โหนดแรก เริ่มต้นที่อยู่บนสุด
- โหนดพ่อ (Parents) คือ โหนดที่มีลูก
- โหนดลูก (Children) คือ โหนดที่มีพ่อ
- โหนดพี่น้อง (Siblings) คือ โหนดเป็นพี่่น้อง และนับแยกครอบครัว
- โหนดใบ (Leaf Node) คือ โหนดที่่อยู่ปลายสุด
- ดีกรีทั้หมดของทรี คือ ที่มีฐานะเป็นลูกทั้งหมด
- ดีกรีทั้หมดของพ่อ A คือ ที่มีฐานะเป็นลูกทั้งหมดของ A
- ระดับความสูง (Level) คือ จำนวนชั้นของทรี

Binary Serch Tree

Heap Tree

กราฟ (Graph)

การจัดเก็บข้อมูลในกราฟ
1. เมทริกซ์ประชิด (Adjacency Matrix)
2. ลิสต์ประชิด (Adjacency List)

- ดีกรี (Degree) คือ จำนวนของเวอร์เท็กซ์ประชิด
- เอาต์ดีกรี คือ เส้นที่ออกจากเวอร์เท็กซ์
- อินดีกรี คือ เส้นที่เข้ามายังเวอร์เท็กซ์
- เส้นทาง (Path) คือลำดับของเวอร์เท็กซ์ที่ประชิดต่อกันไปยังตัวถัดไป
- เอดจ์ (Edges) คือ เส้นที่เชื่อมระหว่างเวอร์เท็กซ์ แบบไม่มีทิศทาง
- อาร์ค (Arcs) คือ เส้นที่เชื่อมระหว่างเวอร์เท็กซ์ แบบมีทิศทาง
- เวอร์เท็กซ์ (Vertex) คือ โหนด

V = {A,B,C,D,E}

การเรียงลำดับข้อมูล (Sorting)

สำหรับอธิบายการจัดเรียงแบบน้อยไปมาก เป็นการเริ่มต้น
- แบบเลือก (Selection Sort) O(n2)

คือ การสแกนหาค่าน้อยที่สุด แล้วสลับตำแหน่งกับตัวแรก
- แบบฮิพ (Heap Sort)

คือ การย้าย root note ไปอยู่ตำแหน่งสุดท้าย แล้วทำการ reheap ใหม่
- แบบแทรก (Insertion Sort)

คือ การเปรียบเทียบค่ากับตำแหน่งถัดไป หากพบค่าใหม่ก็จะนำมาแทรกในตำแหน่งที่เหมาะสม เหมือนการเรียงไพ่
- แบบฟองสบู่ (Bubble Sort)

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

- แบบควิค (Quick Sort)

คือ การจัดเรียงคล้าย Bubble Sort ที่มีการ exchange แต่แบบนี้จะแบ่งส่วนเป็น Partition โดยข้อมูลแบ่งได้ 3 ส่วนคือ 1)ค่า pivot สำหรับแบ่งส่วน 2)ค่าที่น้อยกว่า pivot 3)ค่าที่มากกว่า pivot
1)ก่อนดำเนินการจะนำค่า Pivot Key ตัวแรก และค่าแรก และค่าสุดท้ายมาเรียกให้ถูกต้องก่อน
2)หลังจากนั้น จะย้าย Pivot Key ตัวแรก สลับกับค่าแรก และให้ตัวที่อยู่ถัดค่าแรกเรียกว่า sort left และตัวสุดท้ายเรียกว่า sort right
3)ย้าย sort left ไปทางขวา แล้วย้าย sort right มาทางซ้าย จะหยุดเมื่อ sort left มากกว่า pivot key และ sort right น้อยกว่า pivot key แล้วสลับทั้ง 2 ค่า พร้อมเลื่อนต่อด้วยหลักการเดิม
4)ก่อนเสร็จสิ้นการแบ่ง ให้ย้ายค่าที่เคยเป็นค่าแรก กับ pivot key
5)การดำเนินการหลังแบ่งส่วนแล้ว ให้เริ่มจากด้านซ้าย แล้วค่อยทำทางขวา ในขณะจัดเรียงทางซ้ายก็จะแบ่งส่วนด้วย pivot key ของด้านซ้าย และแบ่งย่อยลงไปอีก ในขณะจัดเรียงทางขวาก็จะแบ่งส่วนด้วย pivot key ของด้านขวา และแบ่งย่อยลงไปอีก ทำเรื่อยไปจนแบ่งส่วนไม่ได้ ก็จะได้ผลการจัดเรียง

การเรียงแบบนี้ปรับปรุงโดย R.C.Singleton ปีค.ศ.1969 ให้เลือกค่า Pivot Key จากค่ากลาง Median Value คือตำแหน่งที่อยู่ตรงกลาง (ตำแหน่งแรก + ตำแหน่งสุดท้าย/2 แล้วปัดเศษทิ้ง)

- แบบผสาน (Merge Sort)

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

สำหรับการจัดเรียงจะทำการแบ่งข้อมูลจนเหลือเพียง 2 ส่วน แล้วจัดเรียงกลุ่มเล็กทุกกลุ่มจนหมด แล้วนำทั้งหมดมารวมกัน ก็จะได้ผลการจัดเรียง

งานที่มอบหมาย

รายงานประกอบด้วย ปกนอก ปกใน คำนำ สารบัญ เนื้อหา สรุป ประเมินตนเอง ประเมินอาจารย์

1. ออกแบบคำถามคำตอบบทละ 20 ข้อ ๆ ละ 3 บรรทัดสำหรับคำตอบ จำนวน 5 บท ซึ่งถัวเฉลี่ยได้

2. สรุปเนื้อหาบทละ 1 หน้า

3. ปก สารบัญ เนื้อหา สรุป และประเมิน ให้เขียนด้วยมือ ยกเว้นภาพ ที่ต้องพิจารณาตามความเหมาะสม

แหล่งอ้างอิง (Reference)

โครงสร้างข้อมูลฉบับภาษาจาวา โดย อ.สมชาย ประสิทธิ์จูตระกูล	http://www.cp.eng.chula.ac.th/~somchai/ULearn/DataStructures
Source Code by Mark Allen Weiss	http://users.cs.fiu.edu/~weiss/dsaajava/code/DataStructures/
DS. with JAVA by William H. Ford & William R. Topp	http://www1.pacific.edu/~wford/fordtopp/javabook/java_index.html
DS & Algo with OOP by Bruno R. Preiss, P.Eng. All	http://www.brpreiss.com/books/opus5/html/book.html
Dictionary of Data Structure	http://www.itl.nist.gov/div897/sqg/dads/
โครงสร้างข้อมูลฉบับภาษาจาวา : อ.สมชาย ประสิทธิ์จูตระกูล	http://www.cp.eng.chula.ac.th/~somchai/ # # # # # # # # # # # # # #

Special lecture by Prof. Dr.-Ing. habil. Herwig Unger,
Faculty of Mathematics and Informatics, FernUniversitat in Hagen, Germany
Topic: Pattern generation in decentralized communities