Final TrkEb

‫د‬
‫ھ ا د ت‬ ‫م ا وارز ت‬ ‫تو‬ ‫ر با‬

‫د ت‬ ‫تا‬ ‫ا‬ ‫‪1289‬‬
‫ا د ت‬ ‫ط ت‬
‫ا و دة‬
‫ا ـد ـــ ت‬
‫د ري‬ ‫درس ا رر‪ /‬أ‪.‬‬
‫دا‬ ‫وا‬ ‫ا د ت وا وب "‬ ‫ھـو ا دس ؟ ‪Stack‬‬

‫‪3‬‬
‫دأ ل ا د ت ھو ا ذف وا(' & ‪%‬ر ن ن طرف وا د‬ ‫< ; ل ‪: ) :‬ذف و‬ ‫ا دس ھو أ د ھ ل ا ت ا‬

‫وب ن ن ا ب " ل‬ ‫ا دس ھو ‪ , -‬ن ا م ز‬ ‫; ‪:‬وم )ا ‪:‬رص ا رأ ‪( :‬‬ ‫إ' & ( ن ‪ %‬وا دة & ط و ھ‬
‫آ را ‪ /‬در أو( ‪Last in First‬‬ ‫ا وا‪,‬م و ل و&ق دأ ن‬ ‫ن ا " ر ‪ :‬ظ ‪:‬ر‬ ‫ن ا ب ا رأ ـ أو ‪ %‬و‬ ‫"ل ‪ %‬و‬
‫‪(LIFO)Out‬‬ ‫& ا ور أد ه‪.‬‬
‫‪,‬ص ا دس‬ ‫ن‬
‫ب ا ر‪3‬‬ ‫وا ر – زداد و ص‬ ‫م د‬
‫ا و ول ا ‪4‬ر‬ ‫و&ر ا‬
‫ا د&‪ 6‬وا(ط‪5‬ق ‪Push / Pop‬‬ ‫ت ا ذف وا(' & ط ق‬
‫ا ذف وا(' &‬ ‫اذا وت & ‪7‬‬ ‫ون ا دس‬
‫زم ؤ‪4‬ر وا د ‪ 4‬ر ا ا د ‪Top‬‬ ‫ل ا دس‬ ‫ط‬
‫ا ط‬ ‫"لا د ت نا‬ ‫ر ا دس؟‬ ‫ھ‬
‫‪5‬‬
‫"ل ا د ت طر ن‬ ‫ر ا ‪ , ,‬و ( و‪%‬د‬ ‫ر "‬ ‫ون ا دس ن‬

‫دام ا ;و& ت ا@ د‬ ‫ا طر ا(و ‪ " -:‬ل ا‬ ‫‪5‬ھ ‪.‬‬ ‫م‬ ‫<‬ ‫تا‬ ‫وى ا‬ ‫&روق أ دا‬
‫دام ا وا‪,‬م ا‬ ‫ل‬ ‫ا طر ا " ‪-:‬ا " ل ا‬
‫وا ؤ‪4‬رات‬
‫ا' & ا ا ‪ 7‬ن ا دام ا ;و& ت ا واز او ا ;و& ت‬ ‫‪Top‬‬ ‫‪7‬‬
‫& ‪ /‬ت ا ر ‪ %‬ا ( و&ر ا‬ ‫ا ر وا دا(ت ا‬
‫ر ‪ ( %‬دام ا ؤ‪4‬رات‪.‬‬ ‫‪1‬‬
‫‪6‬‬
‫ر ا دس؟‬ ‫ھ‬ ‫ا د ت‬ ‫ا ط ت‬
‫‪8‬‬
‫ر ا ‪ , ,‬و ( و‪%‬د‬ ‫ر "‬ ‫ون ا دس ن‬ ‫ن& ا ر ‪%‬‬ ‫‪ %‬نا‬ ‫دم ا د ت &‬

‫‪5‬ھ ‪.‬‬ ‫م‬ ‫<‬ ‫تا‬ ‫وى ا‬ ‫&روق أ دا‬ ‫ا د ء ا را ‪ B‬ا ;ر‬ ‫ظم‬ ‫‪.1‬‬
‫ا( د ء ا ذا‬ ‫‪.2‬‬
‫ر‪%‬‬ ‫‪-5‬‬ ‫ط ت ا رى‬ ‫دم &‬ ‫ا‬

‫‪7‬‬ ‫‪infix and postfix‬‬ ‫اط‬ ‫و'‬ ‫رار ' ا‬ ‫ولا‬ ‫‪.1‬‬
‫‪Top‬‬
‫ا ;رز ا ر ‪6‬‬ ‫ت ا ;رز & ك‬ ‫‪.2‬‬
‫‪1‬‬
‫‪6‬‬
‫ ن ا وظ; ن‬Stack ‫ء‬ ‫ ن ا وظ; ن‬Stack ‫ر‬
10 9
1. class Employee {
2. public int salary;
1. class EmployeeStack 3. public String name;
2. { 4. public Employee()
3. Employee Top = null; 5. {
4. int length =0; 6. salary = 300;
5. // ; ‫تا‬ ‫ھ 'فا‬ 7. name = "no name";
6. } 8. }
9. public Employee(int salary, String name)
10. {
11. this.salary = salary;
12. this.name = name;
13. }
14.‫ا‬E‫ ود }ر& ق ا ;ــر‬.‫ أ‬/‫ا دة ا إ داد‬ ‫ت‬ ‫ق را ب ا‬
Push operation & 'F‫ا‬ Push operation & 'F‫ا‬

12 11
: ‫ل ا‬5 ‫ر م ن‬ ‫إ' & أي‬

1. public void Push(Employee NewEmp) { Top ‫ر‬4‫ ا ؤ‬7 ‫ ر‬4 ‫ ر إ‬4 ‫د د‬% ‫ر ا‬ ‫ر ا‬4‫ ل ؤ‬%
2. Employee newe = NewEmp;
.‫د د‬% ‫ر ا‬ ‫ ر إ ا‬4 Top ‫ر‬4‫ ل ا ؤ‬%
3. if (Top == null) {
4. Top = newe;
5. newe.next = null; } 7
6. else { Top Top Top
7. newe.next = Top;
8. Top = newe; } 1 1
9. length++;
10. Console.WriteLine("A new Employee has been added to Stack: 6 6 6
"+length);
11. }
Push operation & 'F‫ا‬ Pop operation ‫ا ذف‬
14 13
1. public void Pop() : ‫ل ا‬5 ‫ر م ن‬ ‫ذف ا‬

2. { .‫ر ا@ول‬ ‫را‬ ‫ا‬ ‫ ر إ‬4 Top ‫ ل‬%
3. if (Top == null)
4. Console.WriteLine("Stack is Empty!!");
5. else
7 7
6. { Top Top
7. Top = Top.next;
8. length--; 1 1
9. Console.WriteLine("Now Top Points to: " +
Top.name); 6 6
10. }
11.
12. }
Peek ‫ر ا@ ر‬ ‫تا‬ ‫رض‬ Peek ‫ر ا@ ر‬ ‫تا‬ ‫رض‬

16 15
‫م‬:: ‫ر‬:: ‫ر‬:: ‫ر )آ‬:: @‫ر ا‬:: ‫ت‬: ‫رض ا‬:: : ‫رف‬::
1. public void Peek() .Peek ‫ـ‬ (7 & '‫إ‬
2. { TOP ‫ـر‬4‫ؤ‬ 7 ‫رإ‬4 ‫ر‬ ‫و ھذا ا‬
3. if (Top == null)
4. Console.WriteLine("The Stack is Empty!!");
5. else 7
Top
6. Console.WriteLine("The Employee Data:\n"+ Top.name
7. "Name: "+Top.name+"\nSalary: "+Top.salary);
8. }
1 Top.salary
…
6
‫ا دس‬ ‫تا‬ ‫;ذا‬ ‫د ت‬ ‫تا‬ ‫ا‬
StackCreate ‫ ء ا دس‬4 ‫ا‬ Push 6&‫ا(' & او ا د‬ ‫ا د تھ‬ ‫ت‬ ‫اھم ا‬
‫ء‬4‫تا‬ ‫ (' & ا‬Pop ‫ق‬5‫ا ذف او ا(ط‬ ‫و‬
top ‫ ھو ا ط ء‬7 ‫وم‬ ‫)ا ;و& ت( & ن‬ ‫ا "لا‬ &
, ‫ او‬3‫ا دس و& ص ا دس اذا ن & ر‬
‫;ر‬ ,‫ا( دا‬ ‫ا‬
Push: & '(‫ا‬
Void AStack::stackCreate(AStack& Q)
, ‫ر ا ا دس اذا م ن‬ & '‫ا‬ ‫وم ھذه ا‬
{ Q.top= -1;
‫دم‬ ‫ وا ط ق ا‬B ‫ا ر‬ ‫ط‬ ‫د‬ ‫ر‬ ‫و و ھذا ا‬
}
Void push(AStack& Q, int element);
Null ‫ ا‬top ‫م( ط‬,‫ل )ا وا‬ ‫ا "لا‬ &‫و‬
Pop : ‫ا ذف‬
Void PtrStack::StackCreate()
3‫ر ن ا دس اذا م ن & ر‬ ‫ذف‬ ‫وم ھذه ا‬
{ top=NULL;
Void pop(AStack& Q, int& element);
}
6 ..‫ا دس‬ ‫تا‬ ‫;ذا‬ ‫ا دس‬ ‫تا‬ ‫;ذا‬

StackEmpty ‫& ص اذا ن ا دس‬
‫ا "ل‬ &‫;ر و‬ ‫ وي‬top - ‫اذا ت‬ ‫ون ا دس‬ ‫ا "لا‬ &
StackFull(‫ض‬, ; ‫ء)ا‬5 (‫& ص ل ا‬
NULL ‫ وي‬top - ‫ اذا ت‬3‫ل ون ا دس & ر‬ ‫ا‬ -‫ل‬ ‫ض د‬, ; ‫ل ا دس ا ا‬ ‫ا "لا‬ &
bool AStack::stackEmpty(AStack Q)
{ if (Q.top==0) - ‫ ا ا ر‬top
return true; bool AStack::stackFull(AStack Q)
else return false;
} { if (Q.top==n)
bool AStack::stackEmpty(AStack Q)
{ if (Q.top==Null)
return true;
return true; else return false;
else return false;
} }
‫ل‬4; ‫ض د‬, ; ‫ل ل ا دس ا ا‬ ‫ا "لا‬ &
I‫ط‬ ‫د د و ط ر‬% ‫ر ا‬ ‫ص ذا رة‬ & new
6 ..‫ا دس‬ ‫تا‬ ‫;ذا‬ 6 ..‫ا دس‬ ‫تا‬ ‫;ذا‬
‫ل‬ ‫ا "لا‬ & & '(‫ ا‬6 Push & '(‫ا‬
Void PtrStack::push(int element) ‫ اول‬6 ‫و ذا ون و ا دس‬ ‫ن ان ون ا دس‬ ‫ھ‬
& ‫ ط‬7 - ‫ ز دة‬top ‫ و م ا د ل‬7 & '‫ر م ا‬
SPtr * ptr; ‫و‬ &‫د ( ون رو‬- ‫م ا دس‬% ‫ا" "ل ا‬
Ptr=new SPtr;// creat new node '‫م ا& را‬% ‫; رض ا‬
Void AStack::push(AStack& s, int element)
ptr->value=element; If (s.top==n)
Ptr->next=top; Cout<<“the stack is full… overflow”;
Top=ptr; Else
} {s.top++;
s.data[s.top]=element;
}}
6 ... ‫ت‬ ‫ا‬

Pop ‫ا ذف‬
‫ & ذا وي دد رات‬7 ‫"ر ا دس دار ا ذف ا ذي م‬I
‫نا م‬ ‫< ا دس‬ & '(‫ دد ا‬6 ‫ا ذف‬
Void AStack::pop(AStack& s, int& element)
If (s.top==0)
Cout<<“the stack is empty…”;
Else
element =data[s.top];
{s.top--;
}}
Pop & Push
item to push
1
23 4
top of ‫ل‬ ‫دام ا " ل ا‬ ‫ا ذف‬

Stack 3
2
top of Void PtrStack::pop(int element)
Stack
1
SPtr * ptr;
BEFORE PUSH AFTER PUSH
If (top==NULL)
popped item Cout<<“stack is empty…..”;
top of 4 else
4 3 top of
3
2
Stack 2
1
Stack { element=top->value;
1
Ptr=top;
BEFORE POP AFTER POP
Top=top->next ;// update top
Delete(ptr);// delete from memory
}}
‫دام ا د ت‬ ‫ا‬ ‫ا ط ت‬ Pushing an Object (1 of 7)
‫دام ا د ت‬ ' ‫رر‬ -‫د‬%‫ا‬ • push gets passed a reference to an object and creates
‫تا‬ ‫ھ ك او و ت‬ new node to hold it, putting this node on top of the Stack
(Postfix) ‫( و ظ م‬infix) ‫ ا و ط‬6 ‫ھ ك ا ظم ار ' ا‬ Remainder of Stack then follows the new node
prefix -‫ظم‬ new node’s _nextNode gets reference to former top of Stack
‫ا و ط‬infix Postfix ‫ا دي‬ Prefix

public class Stack<ElementType> {
. . .
A/B AB/ /AB
public void push(ElementType newData) {
A+B-C AB+C- -+ABC Node<ElementType> nodeToAdd =

new Node<ElementType>(newData);
A(B+C) ABC+* *A+BC nodeToAdd.setNext(_topNode);
_topNode = nodeToAdd;
A+B/C ABC/+ /+ABC }
}
Let’s look at what this does...

‫ر ا د د ‪Postfix‬‬ ‫ا‬ ‫ت‬ ‫دس ا‬ ‫‪Prefix‬‬ ‫را‬ ‫ا‬ ‫ا‬ ‫ا ول نا ظم او ط ا‬
‫‪A+B*C‬‬ ‫ن‬ ‫ا‬ ‫را‬ ‫ر ا ر ' ر زا د ر ز ن ا‬ ‫رض ا‬
‫ت‬ ‫دس ا‬ ‫وا "‬ ‫ر ا(‬ ‫و‪%‬ود "‪5‬ث را ب ا(ول‬ ‫د‬
‫‪A‬‬ ‫‪+B*C‬‬ ‫‪ /‬ا ‪%‬د دة‬ ‫ر‬ ‫وا " ث‬
‫‪A‬‬ ‫‪+‬‬ ‫‪B*C‬‬ ‫و‬ ‫ت‬ ‫دس ا‬ ‫دأ‬
‫ر ار ' و‬ ‫را‬ ‫دأ ‪6 %‬‬ ‫ر ا(‬ ‫ا ر با ص‬
‫‪AB‬‬ ‫‪+‬‬ ‫‪*C‬‬
‫ر ار '‬ ‫و دا ‪ 6 % 7‬ر وز ا‬ ‫و‬ ‫ر ا ‪%‬د د دأ‬ ‫ا ر ب‬
‫‪AB‬‬ ‫*‪+‬‬ ‫‪C‬‬ ‫دا ا(‪-‬واس‬
‫‪ABC‬‬ ‫‪*+‬‬
‫*‪ABC‬‬ ‫‪+‬‬
‫‪ABC*+‬‬
‫ر ا د د ‪Postfix‬‬ ‫ا‬ ‫ت‬ ‫دس ا‬ ‫‪Prefix‬‬ ‫را‬ ‫ا‬ ‫ر ا د د ‪Postfix‬‬ ‫ا‬ ‫ت‬ ‫دس ا‬ ‫‪Prefix‬‬ ‫را‬ ‫ا‬
‫‪(A+B)*C‬‬ ‫‪A*B+C‬‬
‫(‬ ‫‪A+B)*C‬‬ ‫‪A‬‬ ‫‪*B+C‬‬
‫‪A‬‬ ‫(‬ ‫‪+B)*C‬‬
‫‪A‬‬ ‫*‬ ‫‪B+C‬‬
‫‪A‬‬ ‫‪(+‬‬ ‫‪B)*C‬‬
‫‪AB‬‬ ‫*‬ ‫‪+C‬‬
‫‪AB‬‬ ‫‪(+‬‬ ‫‪)*C‬‬
‫*‪AB‬‬ ‫‪+‬‬ ‫‪C‬‬
‫‪AB+‬‬ ‫‪*C‬‬
‫‪AB*C‬‬ ‫‪+‬‬
‫‪AB+‬‬ ‫*‬ ‫‪C‬‬
‫‪AB*C+‬‬
‫‪AB+C‬‬ ‫*‬
‫*‪AB+C‬‬
‫ر ا د د ‪Postfix‬‬ ‫ا‬ ‫ت‬ ‫دس ا‬ ‫‪Prefix‬‬ ‫را‬ ‫ا‬
‫‪A*(B*C+D)+E‬‬
‫ر ار '‬ ‫ما‬ ‫‪A‬‬ ‫‪*(B*C+D)+E‬‬
‫‪ 6‬ا طوات ا‬ ‫ر ار '‬ ‫ما‬ ‫‪A‬‬ ‫*‬ ‫‪(B*C+D)+E‬‬
‫‪A‬‬ ‫(*‬ ‫‪B*C+D)+E‬‬
‫ن‬ ‫نا را ا‬ ‫ا رض ا ر ا ر '‬
‫‪AB‬‬ ‫(*‬ ‫‪*C+D)+E‬‬
‫ار زن‬ ‫ت ط ق ھذه ا‬ ‫اذا د&ت ر ز @ دي ا‬ ‫‪AB‬‬ ‫*(*‬ ‫‪C+D)+E‬‬
‫ن ر ز ‪4‬رة‬ ‫ا‬ ‫‪ABC‬‬ ‫*(*‬ ‫‪+D)+E‬‬
‫ت‬ ‫‪ %‬ا‬ ‫ن ور ز ا‬ ‫ا دل ھذ ن ا‬ ‫*‪ABC‬‬ ‫‪*(+‬‬ ‫‪D)+E‬‬
‫‪ABC*D‬‬ ‫‪*(+‬‬ ‫‪)+E‬‬
‫تا‬ ‫ا ر د رار ا‬ ‫اذا م‬
‫‪ABC*D+‬‬ ‫*‬ ‫‪+E‬‬
‫*‪ABC*D+‬‬ ‫‪+‬‬ ‫‪E‬‬
‫‪ABC*D+*E‬‬
‫‪ABC*D+*E+‬‬
‫! ذا‬ ‫دس‬ ‫ا‬ ‫را"‬ ‫ا‬ ‫را‪ $‬ث‬ ‫ا‬ ‫را‪!$‬‬ ‫ا‬ ‫ر ا&ول‬ ‫ا‬
‫‪--------‬‬ ‫*‪AB+C‬‬ ‫‪A-B^C‬‬ ‫‪(A+B)*C‬‬ ‫‪A+B*C‬‬
‫‪---------‬‬ ‫‪4‬‬ ‫*‪B+C‬‬ ‫‪ABC^-‬‬ ‫*‪AB+C‬‬ ‫‪ABC*+‬‬
‫‪--------‬‬ ‫‪4,5‬‬ ‫*‪+C‬‬ ‫‪922^-‬‬ ‫*‪72+3‬‬ ‫‪345*+‬‬
‫‪5+4=9‬‬ ‫‪9‬‬ ‫*‪C‬‬ ‫‪9(22^)-‬‬ ‫*‪(72+)3‬‬ ‫‪3(45*)+‬‬
‫‪--------‬‬ ‫‪9,6‬‬ ‫*‬ ‫‪94-‬‬ ‫‪9*3‬‬ ‫‪320+‬‬
‫‪9*6=54‬‬ ‫‪54‬‬ ‫‪5‬‬ ‫‪27‬‬ ‫‪23‬‬

‫ا( ‪,‬‬
‫‪38‬‬
‫ا ء‪..........‬‬ ‫‪ 4‬را ‪ F‬ھ م وا‬

‫د‬
‫دم ا د ء ا ذا‬ ‫فو‬ ‫ت و ! م ا وارز ت‬ ‫ر با‬
‫ا د ء ا ذا‬ ‫ذ ر‬ ‫‪1289‬‬
‫ا راج ھ وي‬
‫ا و‪%‬دة ا ‪#‬‬
‫ا د ء ا ذا‬
‫د ء ا ذا ؟‬ ‫دم ا‬ ‫فو‬
‫ز ن‬ ‫ز‬ ‫( ا 'روب‬ ‫ان‬ ‫د ء ا ذا‬ ‫‪ #‬ر ن ا ‪ %‬ت ط)ب ‪ )%‬ا دام ا‬
‫ط)ب ‪ %‬ب ا 'روب ا د ء ذا وھ ‪1‬‬ ‫ھ ك‪%‬‬ ‫'روب ا ر‪/‬م ‪ #‬ل ) ا د ء ا ذا‬
‫د ‪ %‬ا ط ن‬ ‫د ‪ ,‬ا دا ا د ء ذا‬ ‫‪ ,‬ل رة‬ ‫‪ %‬ث ان 'روب ا ! ر =‪ 1‬و 'روب أي ر‪/‬م ا ر ن ! ر‬
‫وي ‪! %‬ل 'رب ذ ك ا ر‪/‬م ‪' ,‬روب ا ر‪/‬م ا ذي ‪3‬ل ‪2‬‬
‫ا ‪ %‬ا !)‬ ‫وا‪%‬د‬
‫)‪int fact(int num‬‬
‫{‬
‫)‪if(num == 0‬‬
‫;‪return 1‬‬
‫‪else‬‬
‫;)‪return num * fact(num – 1‬‬
‫}‬
4 ‫ و‬,
1! = 1
0,1,1,2,3,5,8,13,21,…. N! = N * (N-1)!
5 6 ‫ !ل‬% ‫ ن وي‬/‫دا اول ر‬ ‫ ا‬, ‫م‬/‫ل ر‬
، 0=(0)‫ف‬,(‫ ف )ن‬+ (1+‫( = ف )ن‬2+‫ ن ف)ن‬3 ‫ ن ا‬/‫ا ر‬ 5! 120
1=(1)‫ف‬ 5 * 4! 24
long fibonacci(long n){
int fib; 4 * 3! 6
if (n <= 1) Base case
3 * 2! 2
return 1;
else 2 * 1!
return fibonacci(n-1) + fibonacci(n-2);
1
}
Recursive case
Execution Trace Execution Trace

(decomposition) (decomposition)
fibonacci(3) fibonacci(3)
fibonacci(2) fibonacci(1) fibonacci(2) fibonacci(1)
Execution Trace (composition) Execution Trace (composition)
+ +
fibonacci(2)->2 fibonacci(1)->1 fibonacci(2) fibonacci(1)

+
fibonacci(1)->1 fibonacci(1)->1
‫د ء ا ذا‬ ‫ا‬ ‫ذ را‬

Execution Trace (composition)
‫ث‬% 3 ‫ ت ا‬% ‫ ب ا‬% ‫دس‬ ‫ جا‬% ‫ظ ا‬% ‫ ا دام ا 'روب‬,
/ ‫) ا 'رب وان اول‬ , ‫دم‬ / ‫ز ت ھ اول‬ / ‫ان آ ر‬ fibonacci(3)->3
‫) ا 'رب‬ , ‫دم‬ /‫زتھ آ ر‬
N=1
N=2 N=2 N=2
Towers of Hanoi: Three Disk
Tower of Hanoi ‫ا راج ھ وي‬
Solution
Towers of Hanoi Problem with Three Disks
Towers of Hanoi: Three Disk

Solution
‫; ل ظ م ا دس‬ ‫<ث <ت و ل‬# ‫ ل ا ق د‬# ‫ ا‬,
‫ ن‬% ‫د أن ( ذ‬ ) 4 ‫ل ھذه ا‬% ‫ل طروح‬% ‫ان أي‬
‫ا => أ رى‬0 ) ‫ل ن‬3 ‫; ) ا‬
// Precondition: count ‫ا ! ا‬
// Postcondition: count disks are moved from from_needle
// to to_needle using via_needle for help
void moveDisks(int count, int from_needle, int to_needle,
int via_needle)
{
if(count > 0) Recursive call
{
moveDisks(count - 1, from_needle, via_needle, to_needle);
cout<<"Move disk "<<count<<“ from "<<from_needle
<<“ to "<<to_needle<<"."<<endl;
moveDisks(count - 1, via_needle, to_needle, from_needle);
}
}
Recursive call
‫‪)A‬‬ ‫ا‬
‫‪18‬‬
‫ا )‪ 3‬ء‪..........‬‬ ‫‪ 4‬را ‪ B‬ھ م وا‬

‫د‬
‫ر‬ ‫نا لا‬ ‫د‬ ‫ت و ‪ #‬م ا !وارز ت‬ ‫ر با‬
‫ا لا ر ا‬ ‫‪1289‬‬
‫ر‬ ‫ا لا‬ ‫تا‬ ‫ا‬
‫ا واع ا ل ا ر ا‬
‫ا لا ر‬ ‫ط ت‬
‫ا و&دة ا‬
‫ا ل ا ر ‪B-Tree‬‬ ‫ل ا ر ‪Trees‬‬ ‫ا‬
‫' ‪....‬‬ ‫د‬

‫و ن ر ف ا ل ا ر ‪ : Tree structures‬ر ب‬ ‫ن را ب ا ت ‪ 4‬ر ا !ط‬ ‫ر‬ ‫را لا‬
‫ن ا ت & ث ل ا ) وى ‪ +‬ا در‬ ‫و‬ ‫ھر )‬ ‫ت ذات ا ‪ /6‬ت ا ر ‪ )+‬ا &ث وا ‪5‬رز‬ ‫لا‬ ‫!دم‬
‫!دام ا ؤ رات‬ ‫‪ Root‬ا ‪ )/‬ا و ت ‪ +‬ر ط ‪+‬‬ ‫ط تا ! ‪5‬‬ ‫و‪ )+‬ا د د ن ا‬
‫ن ؤ رات‬ ‫و و ز‬ ‫ل‬ ‫‪ pointers‬و ط ق‬ ‫ري ن ‪#‬ر ‪ Nodes‬و & وي ل ‪#‬ر‬ ‫ون ا ل ا‬
‫ر ط) ‪#‬ر ‪.(Node‬‬ ‫ن‬ ‫ز نر‬
‫وى ‪ )+‬ا رة‬ ‫ق ا ل ا ري ھو ا‬ ‫ت‬ ‫لا‬ ‫ا زء ا ول‬
‫ل‬ ‫أي زء ن‬ ‫رة ‪subtree‬‬ ‫طق ا م‬ ‫‪8‬‬ ‫‪#‬ر‬ ‫و ت ا!‪ #‬رط ا‬ ‫لا‬ ‫ا زء ا )‬
‫!دام ؤ رات ا ر ط‬ ‫و ن ا ' ل ا ‪ /6‬ت ا ر‬
‫لا ر ا‬ ‫ا‬ ‫م ا &د ث ‪ )+‬ھذه ا و&دة‬
‫' ‪Tree‬‬ ‫ھـ) ا ـ ‪Tree‬؟‬
‫‪5‬‬
‫ت ا م ا ء ا ذر‬ ‫ا‬ ‫ط ق ل ا ‪#‬ر ا ذي & وي‬ ‫‪ 8‬ا > ض >ن !>‪6‬ل >‬ ‫‪#‬ر ا ر ط‬ ‫نا‬ ‫و‬ ‫ھ)‬
‫‪ )+‬ا ل ‪.‬‬ ‫رة ن ا ذر‬ ‫&در‬ ‫رف ـ ‪Edges‬‬
‫ا ؤ ر ا ر ط ن ا ھل وا ن ‪ /‬ط ق ‪ :‬ا م & ‪edge +‬‬
‫ا م ر‬ ‫ن ا &واف ‪ /‬ط ق‬ ‫و ا‬ ‫ا‬
‫&در ‪ :‬ا ء ‪ +‬ط ق ‪ :‬ا م ا ور‪leaf )/‬‬ ‫أ ا ‪#‬ر ا ذي‬
‫‪ terminal node‬ا ‪#‬ر ا )‪.‬‬ ‫‪ node‬او‬
‫ا ا ر ا ذي دأ ن ‪#‬ر و ) ‪#‬ر ورق ‪+‬‬
‫;‪#‬ن‪.‬‬
‫ق ا رة ‪ -:‬ھو ار ‪ : 5‬او ‪ :‬و ) ا ر دد ن ا ‪#‬ر‬
‫و وة ‪ )+‬ا‪ #4‬ن ا رة‪.‬‬
‫ھـ) ا ـ ‪Tree‬؟‬ ‫ھـ) ا ـ ‪Tree‬؟‬

‫‪8‬‬ ‫‪7‬‬
‫‪@8‬‬ ‫ن ا ذي ' ‪,: +‬‬ ‫ت& با‬ ‫و ا ‪#‬ر ھذه‬

‫‪ )+‬ا ل ا )‪.‬‬
‫‪root node‬‬
‫‪internal‬‬
‫‪nodes‬‬
‫‪leaf nodes‬‬
‫‪Binary Trees‬‬ ‫ر ا‬ ‫لا‬ ‫ا‬
‫ر‬ ‫ا‬ ‫و ود ؤ ري ر ط‬ ‫ر ا‬ ‫زا لا‬ ‫‪Animal‬‬
‫‪root‬‬ ‫‪interio‬‬ ‫‪Level‬‬
‫ل ا ري‬ ‫‪#‬ر ا‬ ‫‪A‬ي ‪#‬ر ن‬ ‫‪r node‬‬ ‫‪1‬‬
‫‪parent‬‬
‫‪Bird‬‬ ‫‪Reptile‬‬ ‫‪Mammal Level‬‬
‫‪2‬‬
‫‪edge‬‬
‫‪child‬‬
‫‪Parrot‬‬ ‫‪Cat‬‬ ‫‪Dog‬‬ ‫‪Level‬‬

‫‪node‬‬ ‫‪3‬‬
‫‪leaf‬‬
‫ر ا‬ ‫لا‬ ‫لا‬ ‫طرق‬ ‫'‬
‫!دام ا ‪5#‬و‪ +‬ت ذات ا د ا وا&د‬ ‫ا ل‬ ‫‪#‬ر‬ ‫! او & وي‬ ‫‪/‬د ون ا ل ا ر ا‬

‫ذري وا&د ‪ root node‬و ر ن ‪ #5‬ن وا&دة رى‬
‫ل ا !ط) ‪linear‬‬ ‫ھذا ا وع ن ا ل ا‬ ‫طق‬
‫‪representation‬‬ ‫‪right subtree‬‬ ‫‪ left subtree‬وا!رى‬
‫ن ل ذ ك ‪6‬ث طرق‬ ‫‪A‬ي ھ ل ري ) آ!ر‬ ‫ر ا ل ا رى ا )‬
‫دد ن ا وا‪'/‬‬ ‫ل ‪ )+‬ا طر ا و ‪5#‬و‪ +‬ذات د وا&د و & وى‬ ‫ا ر ب ‪; : 5‬ض ا ظر ن ا ت ا اذا‬ ‫اذا ن‬
‫و ‪ & 2^d-1‬ث ‪ d‬ل ق ا ل ا ري ا ) وذ ك & واء ل ‪#‬ر‬ ‫‪copies‬‬ ‫! نا‬ ‫تا ت‪ +‬را و‬
‫ا ر‬ ‫ودن‬ ‫ن ‪#‬ر ا ل ا ري ا )‬
‫ص ‪.349‬‬
‫) ص ‪301‬‬ ‫ل نا با‬
‫اذا ن و‪# '/‬ر ‪ + I‬ن ا ‪ :‬ا ر ھو ‪i*2‬‬
‫اذا ن و‪# '/‬ر ‪ + i‬ن و‪ '/‬ا ‪ :‬ا ن ھو ‪i*2+1‬‬
‫اذا ن و‪# '/‬ر ‪ + i‬ن و‪ '/‬وا ده )‪INT(i/2‬‬
‫ر‬ ‫لا‬ ‫لا‬ ‫' ‪ .....‬طرق‬ ‫ر‬ ‫لا‬ ‫لا‬ ‫' ‪ .....‬طرق‬
‫ا‬ ‫ا‬
‫ل ا &واف ‪EDGES‬‬ ‫ؤ رات‬ ‫ل ‪ /‬م دد‬ ‫ا‬ ‫د‬ ‫‪+‬‬ ‫ا‬ ‫ا طر‬
‫‪ +‬ل !ز ن ا ‪#‬ر ‪ )+‬ا ‪5#‬و‪ & +‬ب‬ ‫ا طر ا‬ ‫;‪Const treeSize =100‬‬
‫راض ا ‪6‬ث ا رو‪+‬‬ ‫ا&دى طرق ا‬ ‫;‪Typeefe int edge‬‬
‫;‪Typedef char elementType‬‬
‫ن !دم ا و‬ ‫ل ل ‪#‬ر ا ! ن‬ ‫& ج‬ ‫{ ‪Typedef struct‬‬
‫دل ان ن ذا ا ‪#‬ر ا ن ا ر ام و !دم ا‬ ‫;‪elementType info‬‬
‫دل ان ن ‪ :‬ا ن ا ن ام ‪+‬ن ن ‪ :‬ا ن ‪/ @ #‬‬ ‫;‪Edge left‬‬
‫;‪Edge right; } node‬‬
‫ا ! ‪ True‬وا ‪ False‬ل ‪359‬‬
‫‪Index‬‬ ‫‪Info‬‬ ‫‪Left‬‬ ‫‪Right‬‬
‫‪Index‬‬ ‫‪Info Left Right‬‬ ‫‪1‬‬ ‫‪A‬‬ ‫‪2‬‬ ‫‪3‬‬
‫‪2‬‬ ‫‪B‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪1‬‬ ‫‪A‬‬ ‫‪T‬‬ ‫‪T‬‬
‫‪3‬‬ ‫‪C‬‬ ‫‪6‬‬ ‫‪0‬‬
‫اط‬
‫ر ا‬ ‫لا‬ ‫لا‬ ‫'‪ ...‬طرق‬ ‫!دام ا ‪5#‬و‪ +‬ت‬ ‫ل‬ ‫وئ ا‬

‫!دام ا وا م ا ‪#‬‬ ‫‪:‬ا ل‬ ‫او ‪ :‬ا ل‬ ‫دم ا ;‪6‬ل ا ذا رة‬
‫م ا ‪#‬ر ا وا&د ا ‪6‬ث ا‪ /‬م‬ ‫وھ‬ ‫ذ ك د ا‪# + 8‬ر او &ذ‪ :+‬ذ ك ط ب ازا& ا ر ن‬
‫ت ‪data‬‬ ‫‪ /‬ما‬ ‫‪ /6‬ھذه ا ‪#‬ر ' ‪ 8‬ا ض‬ ‫ا ‪#‬ر &‪ 5‬ظ‬
‫ر ‪LeftChild‬‬ ‫ا نا‬ ‫و ‪.‬‬ ‫وا & ‪+‬ظ‬
‫ن ‪RightChild‬‬ ‫ا نا‬
‫ط او‬ ‫ن ا واع ا‬ ‫تا‬ ‫ن ان ون وع ا‬ ‫&ث‬
‫ن ا واع ا ت‬ ‫ا ر‬
‫ر‬ ‫لا‬ ‫ا‬ ‫تا‬ ‫ا‬
‫ب '‬ ‫) و رن و ل و‬ ‫وب د‬ ‫م ا !دام ؤ رات ا ر ط ‪ Pointers‬ون ھذا ا‬ ‫‪Binary Tree Creation‬‬ ‫ا ءا لا ر‬
‫ا لا ر ا‬ ‫تا‬ ‫ا‬
‫‪Class treePtr‬‬ ‫ر ‪Binary Tree Traversal‬‬ ‫ا راض ا ل ا‬
‫{‬ ‫ن ‪ )+‬ا ل ا ري ا ) ‪Search‬‬ ‫ا &ث ن ‪#‬ر‬
‫;‪treePtr * LeftChild‬‬
‫;‪treePtr * RightChild‬‬
‫ري ا ) ‪Insertion‬‬ ‫ا ‪ )+ + 8‬ا ل ا‬
‫;‪int info‬‬ ‫ري ا ) ‪Deletion‬‬ ‫ا &ذف ن ا ل ا‬
‫;‪char ch‬‬ ‫ل ا ري ا ) ‪Sort‬‬ ‫ر ب ا ‪#‬ر ‪ )+‬ا‬
‫‪Public:‬‬
‫;)*‪treePtr* treeInit(treePrt‬‬
‫;)‪treePtr* insertNode(treePtr*,int val‬‬
‫‪………………..‬‬
‫ر ا‬ ‫لا‬ ‫ءا‬ ‫'ا‬ ‫ر ا‬ ‫لا‬ ‫ءا‬ ‫ا‬

‫ا ‪ /‬ما‬ ‫ءا‬ ‫م ر ‪H‬ا‬ ‫ن‬ ‫ا ء ھ ل ر ب ا ‪#‬ر‬
‫ا زء ا دي ‪ treeInit :‬م ‪ )+‬ھذه ا دا ا ء ‪#‬ر ا ذر م‬ ‫وا د‬ ‫ا‬ ‫ا ر ‪ )+‬ا‬ ‫ز ذ ك ط ب !ز ن ا‬
‫ن و& ا ‪ @ 5‬و !زن ھذا‬ ‫ا داد د!‬ ‫‪/‬راءة ا دد ا ول ن ‪/‬‬ ‫ا رى وا د‪.‬اي ا اي ‪ #‬ر‬ ‫ا ‪;#‬ر ‪ )+‬ا‬ ‫و !زن ا‬
‫ا دد ‪ )+‬ا ذر وا د ‪ Null /‬ا ل ن ؤ ر ا ن ا ن و ؤ ر‬
‫ا ن ا ر ‪# )+‬ر ا ذر‬
‫ذر‪..‬‬
‫‪ )+‬ا ذر ا ن ون ا ر ن اي ‪#‬ر ‪ )+‬ا ذر ا ر‬
‫ا دا ا !د ‪ )+‬ا ‪InsertNode + 8‬‬
‫رة ا رى‬ ‫وا ذر ‪ : 5‬ون ا ر ن اي ‪#‬ر ‪ )+‬ا‬
‫‪#‬ر د دة ‪ )+‬ا ل ‪ .‬رن‬ ‫ؤو اد! ل ا م ا‬ ‫وف و‬ ‫وھذه ا ! ‪ #‬ط ق‬ ‫رة ا‬ ‫وا‪;#‬ر ن اي دة ‪ )+‬ا‬
‫' ‪ /‬ا ذر &د د ا‪ )+ + 8‬ا طرف ا ن ام ا ر‬ ‫ا‬ ‫ا‬ ‫رة ‪+‬ر ‪.‬‬ ‫اي‬
‫‪ +‬ن ت ا‪/‬ل ن ا ذر ا‪5 8‬ت ‪ )+‬ا طرف ا ر وا ا‪5 8‬ت ‪)+‬‬ ‫‪ :‬ل وذج ا & م ‪ )+‬ا ر ‪ H‬وا ذي د ) ا دوال ا‬
‫ا طرف ا ن ‪ ) -‬رح ل و‪(@ 8‬‬
‫ا م ا ! ر ‪ -:‬ل ‪ )+‬وذج ا & م ‪ )+‬ا ر ‪ H‬وا ذي & م‬
‫د ء ا دا )‪(treeInit‬‬
‫ر‬ ‫لا‬ ‫راض ا‬ ‫‪Traversal‬ا‬ ‫ر ‪Traversal‬‬ ‫لا‬ ‫راض ا‬ ‫ا‬
‫راض & ث م ا &ث‬ ‫ا‬ ‫م ا !دام ‪recursion‬‬ ‫و ) ز رة ل ‪#‬ر ن ‪#‬ر ا ل ا ري رة‬
‫ه ا ر & ‪ #‬دف ‪Null /‬‬ ‫وا ر‬ ‫وا&دة وذ ك & ب ر ب ن و ن م ن ا راء أي‬
‫)‪Void treePtr::inorder(treeptr* root‬‬ ‫ھذه ا ‪#‬ر‬
‫{ )‪{ if(root!=NULL‬‬ ‫راض ا‪+‬رض ان ‪ ) L‬ؤ ر‬ ‫و‪ @ 8‬ا طرق ا ! ‪ 5‬ا‬
‫;)‪inOrder(root->leftChild‬‬ ‫ا ن ا ر وان ‪ ) R‬ؤ ر ا ن ا ن وان ‪ ) D‬ط‬
‫ا ت‬
‫;”“<<‪Cout<<root->info‬‬
‫ن ”“و ط)‬ ‫ت ما‬ ‫ر ما‬ ‫ها نا‬ ‫ا &رك‬ ‫‪: Inorder LDR‬‬
‫)‪inOrder(root->rightChild‬‬ ‫)‬ ‫ت ”“‬ ‫ن ما‬ ‫ر ما‬ ‫ها نا‬ ‫&رك‬ ‫‪ : Postorder LRD‬ا‬
‫}}‬ ‫ن ”““ ا )‬ ‫ر ما‬ ‫ت ما‬ ‫ا‬ ‫‪ Preorder DLR‬ط‬
‫ري‬ ‫لا‬ ‫ن ‪ )+‬ا‬ ‫‪#‬ر‬ ‫ا &ث ن‬ ‫ل‬ ‫راض‬ ‫و رد ت &ول ا‬ ‫أ‬

‫‪Search‬‬ ‫ا ر‬
‫ا ‪ + 8‬او‬ ‫وا ‪6‬ز ‪ /‬ل‬ ‫تا‬ ‫ر نا‬ ‫راض ص ‪ 370‬و در ت و‪+‬ق ‪LDR‬‬ ‫&ل ا &ول ا‬
‫ري ا ) وذ ك &د د و‪ '/‬ا ‪#‬ر‪.‬‬ ‫لا‬ ‫ا &ذف ن ا‬ ‫اي‬ ‫مط‬ ‫ا ‪ 8‬در ت و‪+‬ق ا ق ا ) ‪ LRD‬وھ‬
‫ل ص ‪326‬‬ ‫رة ا رى‬ ‫‪#‬ر ا د ا راض ل ا ‪#‬ر ا و‬
‫رة ا‬ ‫وا ‪#‬ر ا و‬
‫راض ا )) ‪preorder‬‬ ‫‪ DLR‬ر ت &ول ا‬
‫رة ا رى ‪/‬م‬ ‫‪ (Traversal‬م ز رة ا ‪#‬ر م ا ز رة‬
‫‪.‬‬ ‫ا‬
‫!دام ا ) وا و ط) ل ‪8‬‬ ‫ر م ا رة‬
‫)‬ ‫ري ا‬ ‫لا‬ ‫ا &ذف ن ا‬
‫ر‬ ‫لا‬ ‫ا واع ا‬
‫‪Deletion‬‬
‫ا‬ ‫ا لا ر ا‬ ‫ن ان ون ا ‪#‬ر ا راد &ذ‪ 4 :+‬ر و ود‬
‫‪#‬ر أي‬ ‫ن دد ا‬ ‫ا &د ا‬ ‫وھ) ا ل ا ) & وي‬ ‫دم و ود ا ء ‪#‬ر ا راد &ذ‪:+‬‬
‫و‪+‬ر ل ‪#‬ر ا ن ا ر وا ن ا ن‬ ‫و ود ا ن وا&د ‪ +‬ط ‪#‬ر ا راد &ذ‪:+‬‬
‫و ود ا ن ‪#‬ر ا راد &ذ‪:+‬‬
‫و‪ 5 & 8‬د دم‬ ‫ر‬ ‫دم و ود ا ‪#‬ر ‪ )5‬ط‬ ‫‪& )5+‬‬
‫و ود ا ‪#‬ر‬
‫ا ‪ & )+‬و ود ا ‪#‬ر ‪ & +‬ا ; ر ؤ ر ا وا د ر‬
‫ا ‪ Null‬د ن ا رة ا ا ‪#‬ر‬
‫ل ص ‪328‬‬
‫ر‬ ‫لا‬ ‫ا‬ ‫ط ت‬

‫ا و‬ ‫و‬ ‫‪#‬ر ا‬ ‫نرط‬‫و ت ‪ :‬و‪+‬‬ ‫لا‬ ‫ا ل ا ر ا وا‬
‫او ا س‬
‫و ا‬ ‫‪#‬ر ا‬ ‫& ق ‪ +‬ا ل أي س ل ‪#‬ر ن‬ ‫وھ) ا ل ا )‬
‫ا ن ا ر وا ن‬ ‫ا ‪#‬ر & وي‬
‫ل ص ‪343‬‬ ‫ا واز‬ ‫ا لا ر ا‬
‫ا !دام ا ل ا ر ‪ )+‬ا ! ذ ا رار‬ ‫و ن ان ون واز ن & ث‬ ‫و ن ان ون ا واز‬
‫وا ف ن‬ ‫ا !دا ‪ )+‬ا ‪6‬ت ا‬ ‫و نا‬ ‫ا ق او ا ر ‪ 5‬ع وھذا & ق اذا ن ق ا طرف ا ن‬
‫ا ز ‪ 5‬وا ) ل ا!‪ )+ +6‬ا وزن ‪/K‬ل دد ن ا ر ت‬ ‫ا‬ ‫وي ق ا طرف ا ر او ز د ‪ :‬وا&د وھذا‬
‫ن ل ص ‪340‬‬ ‫ا ا ءا‬ ‫وع ‪AVL‬‬
‫ا ب ‪5‬ر‪/‬‬ ‫ا ل ا ر ا دة ‪HEAP‬‬
‫ل ا ب ا طر ‪ H‬و ك ك و‬ ‫ا !ز ‪ )+‬أي ‪#‬ر‬ ‫ھو ھ ل ري ) ل و‪ +‬ا‬
‫ن ‪6‬ن‬ ‫م ا !ز ‪ )+‬ا ‪#‬ر ن ا‬ ‫ون ا ر او و‬
‫ا ن وا ر‬
‫ل ص ‪342‬‬
‫ن وع ‪B‬‬ ‫ر‬ ‫لا‬ ‫ا‬
‫ل ' ‪/‬وا د‬ ‫دا‬
‫!دم ‪! )+‬ز ن ض ا‬ ‫و تا م‬
‫ا ت وا ‪ 5‬ت‬
‫ر ا ل وى أ ر دد ن ا د ا و ودة ‪ )+‬اى ‪#‬ر‬
‫‪ + 8‬ا وا&د‬
‫ا وى ‪: 5‬‬ ‫' ا ‪#‬ر ا ور‪/‬‬
‫ء ا ذر ق ن ا ‪#‬ر دد ن ا ء ز د ن ر‬
‫ا ء‪..........‬‬ ‫را ‪ L‬ھ م وا‬ ‫ا ل ا رى ‪ d‬و ل ن ‪d/2‬‬
‫ھ) ‪Binary Search Tree‬؟‬ ‫ھـ) ا ـ ‪Binary Tree‬؟‬

‫‪32‬‬ ‫‪31‬‬
‫‪>>#‬ر ن > ا‪>> A‬ر >>ن‬ ‫ھ>>) > رة > ر ‪>> > +‬ل ‪>>#‬ر إ >‬ ‫‪#‬ر ن >ن‬ ‫أ‪& #/‬د‬ ‫ر‬‫ن ‪#‬ر ا وا&د أن‬ ‫د‬
‫ا‪ A‬ء‪ ,‬ر طـ أن ون ‪ /‬ا ن ا‪ A‬ن أ‪;>#‬ر >ن ‪ > /‬ا‪A‬ب‪,‬‬ ‫ا رة ـ ‪Binary Tree‬‬ ‫ا‪ A‬ء‪,‬‬
‫و أن ون ‪ /‬ا ن ا‪ A‬ر أ ر ن ‪ /‬ا‪A‬ب‪.‬‬
‫ت‬ ‫ت ‪ L‬راء‬ ‫ر ن أ‪8+‬ل ا‬ ‫و ذ ك ‪O+‬ن‪ N‬ھذه ا‬
‫ا &ث ر ‪ +‬ـ ‪.‬‬
‫‪B‬‬
‫‪A‬‬ ‫‪D‬‬
‫‪C‬‬
‫إ داد‪ /‬أ‪ & .‬ود ر‪ +‬ق ا ‪5‬ــر‪N‬ا‬ ‫ا دة ا‬ ‫ت‬ ‫ق را ب ا‬ ‫إ داد‪ /‬أ‪ & .‬ود ر‪ +‬ق ا ‪5‬ــر‪N‬ا‬ ‫ا دة ا‬ ‫ت‬ ‫ق را ب ا‬
‫؟‬Binary Search Tree )‫ھ‬
33
5
10 10
2 45
5 30 5 45
30
2 25 45 2 25 30
10
..........‫ا ء‬ ‫ ھ م وا‬L ‫را‬
25
Binary Not a binary
search trees search tree
‫ا‬N‫ــر‬5 ‫ ق ا‬+‫ & ود ر‬.‫ أ‬/‫إ داد‬ ‫ا دة ا‬ ‫ت‬ ‫ق را ب ا‬
‫ا‬
35
‫ٔ‬
‫ا&‪%‬اف ا دة ا‬
‫م ا وارز ت‬ ‫تو‬ ‫ر با‬
‫‪.‬‬ ‫ت وا ت و‬ ‫ما‬ ‫‪.1‬‬ ‫‪1289‬‬
‫‪.‬‬ ‫ت وا ت ق‬ ‫ا‬ ‫‪! .2‬‬
‫‪ ,‬ا‪% +‬ام * ارز ‪ . /Dijkstra‬د‬ ‫‪ .3‬ﺳ‬ ‫ا و دة ا رة‬
‫‪ 1‬زو‪ 1 1 2‬ا ‪. 0‬‬ ‫ا‪34‬‬ ‫ت وا ت‬ ‫ا‬
‫‪ ,‬ا‪% +‬ام * ارز ‪ . / Floyed‬د‬ ‫‪ .4‬ﺳ‬ ‫‪Graphs & Networks‬‬
‫‪ 1‬زو‪ 1 1 2‬ا ‪. 0‬‬ ‫ا‪34‬‬ ‫د ري‬ ‫درس ا رر‪ /‬أ‪.‬‬
‫ت )‪(Graphs‬‬ ‫اوﻻ‪:‬ا‬
‫ٔ‬
‫ا ‪ . :7‬ا ﺤ ‪ +‬ب ‪ 7‬ن ا ـ ت ﺳ‬ ‫ت‬ ‫ا‬
‫<‪ 1‬ا ; ا ‪.‬‬ ‫=‬
‫&‬ ‫و‬ ‫&‪ :‬ا; ‪ > D‬ت ﻪ ا ; ا ‪.‬‬
‫‪ 4‬ا= د<‬ ‫‪ :7‬ا ! ا ‪:G‬‬
‫ٔ‬
‫; ا ‪ .‬و ‪1‬ا ‪0 1‬‬ ‫= ر>‬ ‫ﺣ ‪ ! I‬ا ; ا ‪ > .‬ع ‪ 1‬ا> اع‬
‫ٔ‬ ‫ت‬ ‫ا‬
‫ان ‪ AB‬ا ﻰ ?‬
‫ٓ‬
‫و< ﻰ اي ﺣـ ل‬ ‫ﻰ ا*‬
‫‪ M‬ﻻ ‪ L‬ا ا‪ ,4‬ا ‪ K.‬ا‪7‬‬ ‫‪ 7‬نا‬ ‫ٔ ٔ‬
‫ت‬ ‫‪ & L‬ك <‪ 4N‬ا ة وا ء ‪ :7‬ا‬
‫‪ L‬وا‪ ,4‬ا ‪ 4N‬ت ‪ 1‬ا ا‪ ,4‬وا !‬ ‫ٔ‬
‫ﺣ‪%‬‬ ‫ت ‪ :7‬ا‪ D Y‬اﻻﺣ ن ‪A‬‬ ‫‪7‬‬
‫‪ :7‬ا = ـ‪(Vertices) O‬‬ ‫[‬ ‫!‬
‫)‪(Edges‬‬ ‫وا ق ا ا‪0‬‬ ‫‪ 1 N! 7‬ان ! ‪ < .‬ا ؤوس ‪ :7‬ا ‪ M‬ا ‪%‬ن‬
‫ٔ‬
‫و ‪ 1‬ان ! ا ﺤ اف ‪ T :7‬اﻻﺣ ن < ﻰ ‪A‬‬ ‫ا ﺤ اف ‪ 1‬ان ! ا ] ا ا‪0‬‬
‫ٔ‬ ‫‪ ^_& 1‬ا ‪%‬ن‬
‫ا‪ 4‬اس ‪ 7 G/‬ا ﻰ ا ط ا ﺳ =‬
‫ت‬ ‫ا>ـ اع ا‬ ‫ت ‪ 1 ` 2 1‬ر` ﺳ ‪: & 1‬‬ ‫نا‬
‫‪Graphs Type‬‬ ‫)‪(Element‬‬ ‫‪ 1 < . .1‬ا ‪0‬‬

‫ت &‪::‬‬ ‫‪ < > %2‬ن ر` ﺳ ن ‪ 1‬ا‬ ‫او ا =‪ (Node) %‬و ﺳ ﻰ ا ؤوس ‪V‬‬
‫‪.‬‬ ‫ت ا‪K‬‬ ‫ا‬ ‫)‪(Vertices‬‬

‫)‪(UNDIRECTED GRAPHS‬‬ ‫اف )‪E (edge‬‬ ‫‪ < . .2‬ا ﺤ‬
‫تا ‪.‬‬ ‫ا‬ ‫‪::‬‬ ‫را ﻪ;‬ ‫‪M‬‬ ‫و ء< ﻪ‪ 7‬نا‬
‫) ‪(DIGRAPH‬‬ ‫)‪G=(V,E‬‬
‫و;_ ‪ c‬إذا ‪ O‬ﺤ‪%‬د ا ﺤ اف ا ‪M :‬‬ ‫‪.‬‬ ‫تا‪K‬‬ ‫ا‬ ‫اوﻻ‪:‬‬
‫)‪(UNDIRECTED GRAPHS‬‬
‫‪ 1‬رؤوس ا ‪1 ^ . M‬‬
‫ن ا ‪. Y M‬ﻪ‬
‫و‪ ^_& :7‬ا ﺤ ‪:‬‬
‫ن ; ﺣ ‪ 1 3 7‬زوج‬ ‫<‪%‬‬
‫ن ا = )‪(v1,v2‬‬
‫‪1‬ا= ‪O‬ا‪K‬‬
‫‪(v2,v1) = d7‬‬
‫تا ‪.‬‬ ‫ا‬ ‫‪: >g‬‬

‫)‪(DIGRAPHS‬‬
‫‪v2‬‬
‫‪1 M M‬‬ ‫‪ M‬ﺳ ﻰ ‪.‬ﻪ إذا ; >‪ ; f‬ﺣ ‪ :7 7‬ا‬ ‫ا‬
‫زوج ‪ 1 D‬ا = ‪O‬‬
‫ٔ‬ ‫‪v1‬‬ ‫‪v3‬‬ ‫‪v5‬‬
‫و ن & ك < ﻰ اﻻ‪ 4‬واﺣ‪%‬‬
‫‪ 4 ; 1‬ا ﻰ ‪ٔ 4‬ا* ى‬ ‫‪v4‬‬
‫و ﺤ‪%‬دا ﺳ ‪ O‬ا ﻰ ‪ c‬ا =‬
‫ت‬ ‫! ا‬
Representation of Graphs
v1 v2
: ‫ت‬ ‫ة [ ق ! ا‬%< ‫& ك‬
v3 v4 v5
(Linked Representation) 3 ‫ ا‬O`‫ ا = ا‬.1
(Adjacency Matrices) ‫ ار‬. ‫ ا‬7 3 .2 v6 v7
: ‫اوﻻ‬
‫ ي‬. ‫ اض ا‬+‫ * ارز اﻻ‬c _ (Linked Representation) 3 ‫ ا‬O`‫ا = ا‬

ٔ
:` > ‫دي ا ﻰ ار ﻻ‬B ‫ ان‬1 ‫ ا‬1 ‫ا‬% +‫ ا ق إ‬M‫ ا ﺳ‬1
‫ ة‬M ‫ ا‬:7 4 ; ‫ ز رة‬1 ? M ‫ اض ا‬+k7
‫وث‬%‫ ا ﺤ‬1 c ‫ ذ‬, ] : ‫ ارز ت ا‬7 M=7 ‫ة‬%‫واﺣ‬
ٔ ٔ ٔ
.‫ ان ﺳ‬1 ‫ ز رﻪ‬f ‫; راس‬ & ] ‫ ان‬1 ‫ ﻻ‬. ‫ ا ; ا‬:7
‫ ز رﻪ ة ٔا* ى‬D . ‫ ﺤ ي < ﻰ دوران‬%4 M ‫ﻻن ا‬
‫!ـ ل‪:‬‬
‫‪ M‬ا ‪% + :‬ام ‪ AB‬ات ا ‪M‬‬ ‫! ا‬ ‫ٔ‬

‫ت‬ ‫‪ ,‬ذ ‪ 1 c‬ا ‪ 1‬ان ﺤ ي ا‬
‫‪1‬‬ ‫< ﻰ ‪ O 4‬و )‪( 3 Y‬‬
‫ٔ‬ ‫ٔ‬
‫‪2‬‬ ‫‪4‬‬ ‫‪ :‬ان ‪ T‬ا‪ 2‬اءا ‪M‬‬
‫ٔ‬
‫‪ 1‬ا ‪ 1‬ان ﺤ_ف إذا ‪l ] O‬‬
‫‪3‬‬ ‫اﻻ‪ +‬اض ا ‪ .‬ي‬
‫‪`4‬‬ ‫‪ ` 4‬ـ ا ﺤ اف‬

‫ا ‪0‬‬
‫ا ﺤـ ‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪NULL‬‬
‫‪1‬‬ ‫‪3‬‬ ‫‪4‬‬
‫‪:1 ` 4‬‬ ‫‪:; M‬‬ ‫‪ ! O‬ا‬
‫‪2‬‬ ‫‪NULL‬‬
‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪NULL‬‬

‫‪ ` 4 .1‬ا ‪0‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪NULL‬‬
‫‪4‬‬
‫‪ ` 4 .2‬ا ﺤـ اف‬
: >g
7 ‫اذا ; ن & ك ﺣ‬ (Adjacency Matrices) ‫ ار‬. ‫ ا‬7 3
j =‫ اﻰا‬i =‫ا‬1
ٔ
‫ ` اﻻ د‬g 7 3 1< ‫ < رة‬:&
ٔ
1 +‫ ا ا‬1 M 7 ‫ & ك ﺣ‬1 O ‫ اذا‬0 ,G ‫و‬ ‫ ورة‬. ‫ ا‬O = ‫ ا‬, 2‫د‬%‫ ﺤ‬: ‫ا‬
: ‫ ار‬. ‫ ا‬7 3 ! ‫ ا‬4N ‫< م ا‬ ‫و‬ M ‫ ا‬:7 4
aij := 1 if there is an edge from i to j
O.‫ ا ﺤ‬1 7 3 :&A(aij) ‫ ار‬. ‫ ا‬7 3 7
0 if there is no edge ‫ ا زن‬4 aij ,4 ‫ ا‬:7 ,G I ‫ ﺣ‬n x n
: ‫ا ﺤـ‬ ‫ !ـ ل‬:
: ‫ ار ا‬. ‫ ا‬7 3 ] ‫ ا ﺳ‬M ‫ ! ا‬1 ‫ ار‬. ‫ ا‬7 3 ‫ام‬% + : ‫ا‬ ‫! ا‬
V1 V2 V3 V4 V5 V6 V7
V1 0 1 0 0 0 0 0 v1 v2
V2 0 0 0 0 1 0 0
V3 1 0 0 0 0 1 0
V4 0 0 1 0 1 0 0 v3 v4 v5
V5 0 0 0 0 0 0 1
V6 0 0 0 0 0 0 0 v6 v7
V7 0 0 0 0 0 1 0
‫ﺣﺳ ب ا ﺤ اف ا ‪%‬ا* وا ر‪2‬‬
‫‪ 4 ;1‬ـ‬
‫‪ :7‬ا ‪% + M‬ام ‪ 7 3‬ا ‪ .‬ار‬ ‫>‪N‬ﺣ‪ m‬ان ‪ 7 3‬ا ‪ .‬ار ﺤ ي دا`‬
‫< ﻰا ‪01 3‬و‪1‬‬
‫ﺤﺳ ب <‪%‬د ا ﺤ اف ا ‪%‬ا* ‪:‬‬
‫د‬ ‫ر‪ O4‬ا ‪%; n 3‬‬ ‫>ﺳ‬ ‫و _ا ا ﺳ ‪D‬‬
‫]< ا ‪ 7 3‬ا ّ‬
‫‪ 7 3 :7‬ا ‪ .‬ار و>ﺤﺳ‪%< D‬د ات ار‬
‫ا ‪ 7 3 :7 1 O4‬ا ‪ .‬ار‬
‫!ـ ل ‪:‬‬
‫= ﺤﺳ ب ا ﺤ اف ا ر‪: 2‬‬ ‫و ‪L‬ا‬

‫ﺤﺳ ب ا ﺤ اف ا ‪%‬ا* وا ر‪ 1 2‬وا ﻰ ;‬
‫< ‪ :7 3‬ا ‪% + M‬ام ! ‪7 3‬‬ ‫ﺣ ‪> I‬ﺳ ‪%‬م ر‪ O4‬ا =‪%‬ة ‪ %; n‬ا ‪3‬‬
‫ا ‪ .‬ار > ـ ‪ D‬ا ‪%‬وال ا ‪:‬‬ ‫‪ 7 3 :7‬ا ‪ .‬ار و>ﺤﺳ‪%< D‬د ات ﺣ‪ 3‬ل‬
‫ا ‪ :7 1 O4‬ذ ‪ c‬ا ‪ 3‬و !ـ <‪%‬د ات‬
‫)‪buildadjm(intadj[][MAX], int n‬‬ ‫ﺣ‪ 3‬ل ا ‪%< 1 O4‬د ا ﺤ اف ا ر‪; 1 2‬‬
‫<=‪%‬ة ‪ :7‬ا ‪.M‬‬
:‫ﺣ ا ! ل‬
void buildadjm(int adj[][MAX], int n)
‫ا‬% ‫ ا‬: > Og { int i,j;
indegree for(i=0;i<n;i++)
for(j=0;j<n;j++)
1 O4 ‫ ر ا‬o ‫د ات‬%< D‫ ﺤﺳ‬I ‫ﺣ‬
‫ام‬% + ‫ ار‬. ‫ ا‬7 3 :7 ‫ ; < د‬:7 { cout<<"Enter 1 if there is an
edge from "<< i <<" “
! ‫ا* وا _ي‬% ‫ ﺣﺳ ب ا ﺤـ اف ا‬O + : ‫ة ا‬%= ‫ ا‬O4‫ر‬ << "to" <<" "<< j <<"
otherwise enter 0 "<<endl;
7 3 ‫د ا‬ cin>>adj[i][j];
} }
‫ﺣ ا ! ل‬: :: ; :&‫و‬
‫ا‬% ‫ ا‬: > Og indegree Int

(intadj[][MAX],intx,int n)
outdegree
‫ ر‬o ‫د ات‬%< D‫ ﺤﺳ‬I ‫ﺣ‬ { int i, count =0;
7 3 1 0 ; :71 O4 ‫ا‬ for(i=0;i<n;i++)
ٔ if( adj[i][x] ==1
(‫ة )ا اس‬%= ‫ ا‬O4‫ ل ر‬+ ‫ ار‬. ‫ا‬
count++;
‫د ا ﺤ اف‬%< D‫ ﺤﺳ‬+ : ‫ا‬
return(count); }
‫ﺣ ا ! ل‬: :: ; :&‫و‬
: : ; :‫ ا ` ﺳ‬l > ‫ن ا‬ &‫و‬
void main()
{ int outdegree(int adj[][MAX],int x,int n)
int adj[MAX][MAX], n, i;
cout<<"Enter the number of nodes { int i, count =0;
in graph maximum = for(i=0;i<n;i++)
“ <<MAX<<endl; if( adj[x][i] ==1)
cin>>n; count++;
buildadjm(adj,n); return(count); }
:l > ‫ ح ا‬A
ٔ for(i=0;i<n;i++){ cout<<"The indegree
‫ ار‬. ‫ ا‬7 3 ‫ اوﻻ ء‬l > ‫ = م &_ا ا‬.1 of the node "<<i<<" is”
<<indegree(adj,i,n)<<endl;
% buildadjm ‫ا‬% ‫ل داة ا‬N* 1
*‫ا‬% ‫ ﺣ = ا ار ﺤﺳـ ب ا ﺤ اف ا‬:7 *% c ‫ذ‬ cout<<"The outdegree of the
M ‫ ا‬:7 ‫ة‬%=< 2‫وا ر‬ node“<<i<<"is”
<<outdegree(adj,i,n)<< endl;
...........‫وال‬% ‫ل داة ا‬N* 1 }
.: ‫< ﻰ ا ا‬outdegree‫و‬indegree }
‫‪ .3‬ا ‪%‬ا ‪ outdegree‬ﺤﺳ‪%< D‬د‬
‫‪ .2‬ا ‪%‬ا ‪ indegree‬ﺤﺳ‪%< D‬د ات‬
‫ات ‪ o‬ر ا ‪0 ; :7 1 O4‬‬
‫‪ o‬ر ا ‪ < ; :7 1 O4‬د ‪7 3 :7‬‬
‫‪ 7 3 1‬ا ‪ .‬ار ‪ +k‬ل ر‪O4‬‬
‫ا ‪ .‬ار ‪% +k‬ام ر‪ O4‬ا =‪%‬ة ا ـ ‪:‬‬
‫ا =‪%‬ة ا ‪ + :‬ﺤﺳ‪%< D‬د ا ﺤ اف‪.‬‬
‫‪ O +‬ﺣﺳ ب ا ﺤ اف ا ‪%‬ا* وا _ي‬
‫! د ا ‪.7 3‬‬
‫‪: >g‬‬
‫ت‬ ‫ا‬
‫); ﺣ ‪ 1 => 1 3 7‬او ا;ـ! (‬ ‫‪NETWORKS‬‬
‫و ﺣ ‪ 1 7‬ﺣ ا‪7‬ﻪ ‪%< 4‬د ‪2‬‬ ‫ن‬ ‫‪Diagram‬‬ ‫‪:+% & M‬‬ ‫< ﻰ ا>‬ ‫فا‬
‫!‬ ‫‪< .‬‬ ‫‪% => 1‬ا ‪ A‬و>= > ‪N3 F‬ت ‪7‬‬
‫‪ 1‬ا =‪Nods %‬‬
‫وزن ‪ c‬ا ﺤ ‪7‬‬
‫‪%‬د ‪ 1‬ا ﺤ اف ‪Edges‬‬ ‫‪3‬‬
‫‪:N! 7‬‬ ‫[ ق ا ‪ .‬د ا‪ 34‬ا ات‬
‫ٓ‬ ‫ٔ‬
‫‪ . /‬د ا ] اﻻ‪ +‬ع ‪ 0‬ل ‪ ,4 1‬ا ﻰ ا*‬
‫‪SHORTEST PATH‬‬
‫‪ M :7‬ا ق‬
‫> < ﻰ ا ‪ .‬د ا‪ 34‬ا ات ‪ ^_& 1‬ا ا‪,4‬‬ ‫ان ا ‪ .‬د ا‪ 34‬ا ات ‪ :7‬ا ‪ M‬ا ‪:‬‬
‫‪N* 1‬ل ‪7‬ﺤ‪ , 2 q‬ا ق ا ‪B‬د ا ﻰ ا ‪ ,4‬ا ب‬ ‫‪ :7 1 4 ; 1‬ا ‪ M‬ﺤ ‪I‬‬ ‫‪ < %‬ﻰ و‪ 2‬د‬
‫‪%‬ا ‪ => 1‬اﻻ> ‪N‬ق‬ ‫ن ‪ .‬ع اوزان ا ﺤ اف & اﻻ‪4‬‬
‫و> ـ ا ﻰ ا ‪ 2‬ا =‪ 3‬دة‬
‫= اﻻو ﻰ ‪:‬‬ ‫• ا‬ ‫= ‪:1‬‬ ‫و‪ . /‬د ا‪ 34‬ا ات >ﺳ ‪%‬م اﺣ‪%‬ى ا‬
‫ا ‪Dijkstra‬‬ ‫‪% +‬ام * ارز د ‪ .‬ﺳ‬

‫& ك ا ‪ 1 % %‬ا ارز ت‬ ‫= اﻻو ﻰ ‪:‬‬ ‫‪ .1‬ا‬
‫‪ . /‬د ا ﺳ ‪ 4 1 7‬ا ﻰ ا* ى ‪ :7‬ا ‪M‬‬ ‫‪%‬ام * ارز د ‪ .‬ﺳ ا )‪(Dijkstra‬‬ ‫‪+‬‬
‫* ارز ‪ Dijkstra‬ﺣ ‪ = I‬م &_^ ا ارز < ﻰ‬ ‫= ا! > ‪:‬‬ ‫‪ .2‬ا‬
‫ﺤ‪ % %‬ا ﺳ ‪ 4 1 7‬ﺤ‪%‬دة و‪ , 2‬ا = ‪ O‬اﻻ* ى ‪:7‬‬ ‫‪%‬ام * ارز ‪(Floyd) % 7‬‬ ‫‪+‬‬
‫ا ‪M‬‬
!‫ ﺢ ا;ـ‬G ‫و‬
ٔ
1 ‫ < ﻰ‬Dijkstra ‫* ارز‬ 4 1 Dijkstra ‫ا * ارز‬%
‫ا‬% ‫ >= ا‬1 ‫ﺤ اف‬ 4‫ ع ا‬. : ‫ ا‬M ‫ ا‬:7 (source) ‫ر‬%3 ‫ﺳ ﻰ >= ا‬
;_ %. ‫ ا‬1 ‫ا ﻰ >= ا و‬ ‫ اﻻ* ى‬O = ‫ ا‬, 2 ‫ ا ﻰ‬3 ‫ ﺣ ﻰ‬% ‫و‬
‫ ا‬7 ‫ ا ﺳ‬1 ‫ و = م < ﻰ‬M ‫ ا‬:7
& ‫ان ;ـ ءة &_^ ا ارز‬
‫ر‬%3 ‫ ا = ا‬1
O(n2)
‫ ل ا‬0 ‫ا ﻰ ا = ا اد ا‬
ٔ
:‫ اﻻو ﻰ‬7 3 ‫ا‬
: :&‫ ت و‬7 3 , ‫ﺤ ج &_^ ا ارز ا ﻰ ار‬
‫ ار‬. ‫ا‬ 7 3
(Adjacency Matrix Cost) (Adjacency Matrix Cost) ‫ ار‬. ‫ا‬ 7 3
( Distance Matrix) ‫ ا ل‬7 3
: ‫ا‬ ‫ ا‬:7 (Path Matrix) 1 ‫ ا‬7 3
‫ ـ ا‬A s (Include Matrix) 0 ‫ ا‬7 3
7 3 ‫ام‬% + ] ‫ا ﺳ‬ ‫ ! ا‬1
:: ; ‫ ار‬. ‫ا‬
A B C D
A
B
0
0
A TO B
0
A TO C
B TO C
A TO D
B TO D
A B
C 0 0 0 C TO D
D 0 0 D TO C 0
:: ; C++ K 7 3 ‫ ا‬1< ‫ن‬N<‫ اﻻ‬O ‫و‬ C D

int COST[N][N] ;
: ! !‫ ا‬7 3 ‫ا‬ : > !‫ ا‬7 3 ‫ا‬

1 ‫ ا‬7 3 ‫ ا ل‬7 3
(Path Matrix) (Distance Matrix)
‫ ا ات‬34‫ ا‬:7 : ‫ ا‬0 ‫ا‬1 ‫ق‬N >‫ >= ﻪ اﻻ‬1 ‫ ا ق‬34‫ [ ل ا‬1
^ A ‫ ﺤ ي < ﻰ ا = ا ﺳ = ا‬path[ j ] ‫ ان‬I ‫ﺣ‬ ,4 ‫ ا‬:7 c ‫ وذ‬J ‫ا ﻰ ا = ﻪ‬
‫ ا ات‬34‫ ا‬:7 j = DISTANCE[J ]
:: ; C++ K 7 3 ‫ ا‬1< ‫ن‬N<‫ اﻻ‬O ‫و‬ :: ; C++ K 7 3 ‫ ا‬1< ‫ن‬N<‫ اﻻ‬O ‫و‬
int PATH[N]; int DISTANCE[N][N];
: ‫ اا‬7 3 ‫ا‬
ٔ 0 ‫ ا‬7 3
j 4 ‫ ا = ط‬1 ‫ ل اي‬A ‫ ﺣ‬: 7
(Include Matrix)
Included ‫ ا ات‬34‫ ا‬1 G
‫=ﻪ‬ ‫ ّ ﻪ‬7 3 :&‫و‬
True ‫ﺳ وي‬
0‫ >= اﻻ‬c ‫ ذ‬:7 ، ‫ ا‬0 ‫ﺤ ي< ﻰا‬
] 1 ‫ﻪ‬s‫&_^ ا ﺤ‬ K ‫ ا ات‬34‫ ا‬1 G (‫ق‬N >‫)اﻻ‬
:: ; C++ K 7 3 ‫ ا‬1< ‫ن‬N<‫ اﻻ‬O ‫و‬ ‫ق‬N >‫اﻻ‬ => 1 ‫ءا‬% ‫ا ارز‬
bool INCLUDE[N];
‫ ا ات‬34‫ د ا‬. / ‫ ﺳ ا‬. ‫ * ارز د‬0‫و‬

Initialize ( SOURCE ) ; Const int N=50 ;
Do Typedef bool Boolean Type [N] ;
{ FINDMIN (J) ; Int cost [N][N] ;
INCLUDE[J] = true ; Int DISTANCE [N] ;
For (i=0;i<N ;i++) Int PATH [N] ;
If ( ! INCLUDED[J] Bool INCLUDE [N] ;
UPDATE ( I, J ) ; PRINT () ;
Void SHORTPATH ( int SOURCE );
Boolean Type Included;
While ALL( Included ) ;
Int I , j ;
PrintPath () ; }
ReadMat ();
‫و< ‪ %‬اد* ل ! &_^ ا = ‪ D. O‬اد* ل ا = ﻪ‬
‫‪ :7 0‬ﺣ ‪: & 1‬‬ ‫ا ‪%‬وال ا ﺳ ‪ %‬ﻪ ‪ * :7‬ارز د ‪ .‬ﺳ ا‬
‫اوﻻ‪:‬‬ ‫‪ .1‬ا ‪%‬ا ﻪ ‪: ReadMAT‬‬

‫ٔ‬
‫اذا ; >‪ f‬ا ﺤ ‪7‬ﻪ )‪ (Vi ,Vi‬اي ‪ 1‬وا ﻰ ا = ‪.‬‬ ‫ﺣ ‪ ^_& ] [ 1< O I‬ا ‪%‬ا ﻪ‬
‫‪: >g‬‬ ‫‪ 4‬اءة ‪ 7 3‬اوزان ا ‪ .‬ار‬
‫اذا ‪ %2 O‬ﺣ ‪. 7‬‬
‫ا ‪%‬ا ﻪ ‪: FINDMIN‬‬ ‫‪.3‬‬

‫‪ .2‬دا ‪: Initialize‬‬
‫و&‪ :‬دا ﻪ ‪ %‬ا‪ 34‬ا ات ‪ => 1‬ا ‪%‬ا‬
‫ﺣ ‪ ^_& :7 O I‬ا ‪%‬ا ﺤ‪ % %‬ا = ‪ O‬اﻻ ‪%‬ا`‬
‫اﻰا = ﻪ‪J‬‬
‫و _ ‪ 3 c‬ﺢ ا = ﻪ ‪ 1 G J‬ا‪ 34‬ا ات‬ ‫]‪ INCLUDE [ SOURCE‬ﺤ‪%‬د ‪ :7‬ا ‪%‬ا‬
‫ﺣ ‪Included [j] 4 % O I‬‬ ‫< ﻰ ا> ﺳ وي ‪INCLUDE [i] true‬‬
‫‪true‬‬ ‫‪3‬ﺢ ﺳو =‬ ‫ا = ط ا = ﺳ وي ‪false‬‬

: UPDATE ‫ا ﻪ‬% ‫ ا‬.4
Distance Matrix 7 3 ‫ ا‬% ‫م‬% ‫ﺳ‬
c ‫ ذ‬% %‫و ﺤ‬
! => ‫ د‬. ‫ ﺣ ا‬:7 Path Matrix 7 3 ‫وا‬ ‫ ا ات‬, 2 ‫ ا د‬q‫ﺤ‬7 O
j => ‫ا ا ﻰ‬% ‫ >= ا‬1
(INCLUDE [i]= false) ‫ ان‬I ‫ ﺣ‬i
7 ‫ ـ‬3 ‫ ا‬:7 ‫و&_^ اﻻ د ن‬
‫ دة‬2 ‫ ا ات ا‬34‫ [ ﻪ ا‬:
Distance Matrix
‫ ا< ر &_^ ا = ﻪ‬4
: ALL ‫ا ﻪ‬% ‫ ا‬.5

‫ا ﻪ = ﻪ‬%; ‫م‬% ‫و ﺳ‬
‫ &_^ ا ﺤ ﻪ‬:7‫و‬
, 2 O 4 ‫ ﺢ‬3 % < true ‫ ا = ﻪ‬% ‫و‬
‫? ف &_^ ا = ﻪ ا ﻰ ا = ط ا‬
Include Matrix 7 3 ‫ ا‬:7 ,4‫ا ا‬
‫ ا ات‬34‫ ا‬:7
true ‫ﺳ وي‬
c ‫ف ذ‬N* false ‫ا ﻪ ا = ﻪ‬% ‫ &_^ ا‬% ‫و‬
‫دا ا <ﻪ ‪: PRINT‬‬ ‫‪.7‬‬ ‫‪ .6‬ا ‪%‬ا ﻪ ‪: SHORT PATH‬‬
‫و ﺳ ‪%‬م ;‪%‬ا ﻪ ‪ 1 O‬دا*‬
‫ﺳ ‪%‬م &_^ ا ‪%‬ا ﻪ‬
‫ا‪ <% +‬ء ا ‪%‬وال ا ﺳ =ﻪ‬
‫< ‪ O 4‬ا ‪7 3‬ـ ت‬
‫‪DISTANSE , INCLUDE , PATH‬‬
‫ﻻ‪7 G‬ﻪ ا ﻰ دا ا <ﻪ ا ‪ = :‬م <‬
‫ٔ‬
‫‪ * 1 ^ * ; %‬ات ا ارز ﻪ‬ ‫ت ا* ى > ‪7 DY‬‬ ‫ا `‪ l‬واي‬
‫و‪ ^_& > :7‬ا ‪%‬ا ﻪ ‪ < [ O‬ا‪ 34‬ا ات و &_ا ا‬
‫‪ . /‬د ا‪ 34‬ا ات ‪% + 1 => 1‬ام * ارز‬

‫ا ‪%‬ا ﻪ ‪: PRINTPATH‬‬ ‫‪.8‬‬
‫د‪ .‬ﺳ ا‬
‫ﺳ ‪%‬م &_ا اﻻ‪ 2‬اء‬
‫ا ‪ .‬ار ا ‪G‬ﺤﻪ‬ ‫‪% +‬ام ‪7 3‬‬
‫< ا‪ 34‬ا ات ‪ => 1‬ا ‪%3‬ر‬
‫ا ‪:‬‬ ‫‪ :7‬ا‬
‫و>= ا ‪ 2‬ﻪ ا =‪ 3‬د^‬
‫‪ +‬ف >‪ %.‬ا‪ 34‬ا ات‬
‫‪1‬ا = ﻪ‪ 1‬اﻰا = ﻪ ‪3‬‬
‫‪ G‬ﺤ ت‪:‬‬
‫ٔ‬
‫اذا ‪ & 1 O‬ك ﺣ ‪ 1 7‬ا = ﻪ )ا(‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪800‬‬ ‫‪2985‬‬ ‫‪310‬‬ ‫‪200‬‬
‫ا ﻰ ا = ﻪ)ب( ‪ 7‬ن ‪ 4‬ا ‪,4‬‬ ‫‪2‬‬ ‫‪800‬‬ ‫‪0‬‬ ‫‪410‬‬ ‫‪612‬‬ ‫‪0‬‬
‫ٔ‬ ‫‪3‬‬ ‫‪2985‬‬ ‫‪410‬‬ ‫‪0‬‬ ‫‪1421‬‬ ‫‪0‬‬
‫‪ :7‬ا ‪ 3‬ا وا د ب ﺳ وي ﻻ> ‪.‬‬ ‫‪4‬‬ ‫‪310‬‬ ‫‪612‬‬ ‫‪1421‬‬ ‫‪0‬‬ ‫‪400‬‬
‫‪5‬‬ ‫‪200‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪400‬‬ ‫‪0‬‬
‫ﺣ ا ! ل‪:‬‬
‫ٔ‬ ‫‪ 7 l‬ن ا ‪%‬ا ﻪ ‪Initialize‬‬
‫< ‪% %‬ء ا >‬
‫‪%‬ا * ارز د ‪ .‬ﺳ ا = اءة ‪7 3 O 4‬‬
‫ا ‪ .‬ار ‪ ،‬و ‪ c 1 O‬ا = ‪ :7 O‬ا ‪ 7 cost 7 3‬ﻰ‬ ‫< ﻰ ﺤ اﻻ‪ 0‬ر ا ‪%< 1< .‬م‬
‫‪ +‬ا !ل‬ ‫و‪ 2‬د ﺣ اف ‪ 1‬ا = ط ‪ :7‬ا ‪ M‬ا ﻰ ا;‬
‫ﺳ وي ]‪ cost [2,3‬ا = ‪ 410‬و&_ا ‪:‬‬ ‫ﻪ ‪ C++ K :7‬و ا ﻰ‬ ‫‪ 4‬ﻪ ‪0‬ﺤ ﺤ‬
‫ان وزن ا ﺤ ‪7‬ﻪ ا ‪ 1 3 :‬ا = ‪1‬‬ ‫‪ MAXINT‬و& ﺳ وي‬ ‫&_^ ا = ﻪ‬
‫‪ 2‬و ‪410 & 3‬‬ ‫‪. 32767‬‬
:‫اوﻻ‬
:: ; DISTANCE 7 3 ‫ﺤ تا‬
‫ اء‬2‫< ء اﻻ‬% +‫ ا‬O c ‫ ذ‬%
‫ ا = ﻪ > ﺳ‬:&‫ا و‬% ‫ >= ا‬1 1 ‫ ا = ﻪ‬% initialize
ٔ
0 ‫ ﺳ وي‬DISTANCE [ 1 ] ‫اي‬ ‫ت‬7 3 `‫ا‬% ‫ اﻻ‬O = ‫د ا‬%‫وا _ي ﺤ‬
‫ا‬% ‫ >= ا‬1 2 ‫ ا = ﻪ‬% Included ‫ و‬Path ‫ و‬Distance
ٔ : ;
800 ‫ ﺳ وي‬DISTANCE [ 2 ] ‫اي‬
:c_‫و‬ ‫ا‬% ‫ >= ا‬1 = ‫ا‬%3‫ﻪ‬

:: ; DISTANCE 7 3 ‫نا‬ ٔ
‫ا‬% ‫ >= ا‬1 4 ‫ ا = ﻪ‬%
2985 310 200 800 Distance : 0 ٔ
‫ا‬% ‫ >= ا‬1 5 ‫ ا = ﻪ‬%
ٔ
‫‪:! g‬‬ ‫‪: >g‬‬
‫ﺤ ت ا ‪INCLUDE 7 3‬‬ ‫ﺤ ت ا ‪PATH 7 3‬‬
‫‪ 7‬ن ‪ & 0 < , 2 O 4‬ﺳ وي ‪false‬‬ ‫‪ => 4 : 7‬ا ‪%‬ا ‪ :7‬ﺣ ل و‪ 2‬د ﺣ ‪ 7‬او ‪=> 1‬‬
‫‪ ! +‬ء ‪ 4‬ا ‪INCLUDE [ 1 ] 3‬‬ ‫ا ‪%‬ا ا ﻰ ا = ط اﻻ* ى ‪.‬‬
‫ٔ‬
‫ﺣ ‪ I‬ان ا = ﻪ ‪ => ! 1‬ا ‪%‬ا وا ‪:‬‬ ‫و _ا ن ﺤ ت ا ‪ PATH 7 3‬ﺳ و = ‪)1‬اي‬
‫ﺳ وي ‪true‬و&_ا ‪ :‬ان ا = ﻪ ‪1‬‬
‫>= ا ‪%‬ا (‬
‫‪ :7‬ا‪ 34‬ا ات ‪.‬‬ ‫‪ :K‬ان‬ ‫‪ ! +‬ء ]‪ PATH[1‬ﺣ ‪ I‬ﺳ وي ‪ 4‬ﻪ ‪ 0‬ا ‪.‬‬
‫‪Path:‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪7 3‬ت‬ ‫و _ ‪> c‬ﺤ‪ < 3‬ﻰ ا = ‪ O‬اﻻ ‪%‬ا`‬

‫و‪ :7‬ا ﺣ ا‬ ‫‪ DISTANCE‬و ‪ INCLUDE‬و ‪PATH‬‬
‫‪ _ 1‬ا ارز‬
‫‪::‬‬ ‫;‬
‫‪ % O‬ﺤ ت ا ‪ 7 3‬ت ا !‪N‬ث‬
‫ﺤ ‪ c L I‬ا ‪N %‬ت ا د ا‪ 34‬ا ات‬ ‫ا= ﻪ‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪ => 1‬ا ‪%‬ا ; ‪ ^_& 1‬ا ‪N %‬ت ا = ط‬ ‫‪Distanc‬‬
‫‪0‬‬ ‫‪800‬‬ ‫‪2985‬‬ ‫‪310‬‬ ‫‪200‬‬
‫ا ‪ O :‬ا*_& ‪ 1‬اﻻ< ر وا = ط ا‬ ‫‪e‬‬
‫‪Path‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪ :7‬ا‪ 34‬ا ات‬
‫‪Include‬‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬
‫و _ ‪ 3 c‬ﺢ ]‪ INCLUDE [5‬ﺳ و =‬ ‫_‪c‬‬
‫‪ true‬و =ﻰ ا = ﻪ ‪ 0 1‬ا = ﻪ ا ‪ 1 :‬ا ور‬ ‫‪ :7 O‬ا ة ا ! > ﻪ ‪ 1‬ا ارز ﻪ إ‪ 2‬اء ا ‪N %‬ت ا‬
‫ﺣ ﻰ &_^ ا ﺤ‪s‬ﻪ ‪ 1‬ا ارز ﻪ‬ ‫< ﻰ ا ‪ 7 3‬ت ا !‪N‬ث‬
‫‪ 7‬ان ‪ %‬ا = ﻪ ‪ 1 5‬ا = ﻪ‬
‫و =ﻰ ا> ‪ => 1 4N‬ا ‪%‬ا )و&‪ :‬ا = ﻪ‪ A (1‬ة ا ﻰ‬ ‫‪ & 1‬اﻻ‪ 1 4‬ا د ا = ط اﻻ* ى‬
‫ا = ط اﻻ* ى ; =ﻰ ﺤ ت ا ‪:& ; PATH 7 3‬‬ ‫‪ 7‬ن ا = ﻪ ‪ :K 5‬ان ن ‪1 G‬‬
‫ا‪ 34‬ا ات‬
‫ﺳ‬ ‫و< ﻪ ن ﺤ ت ا ‪ 7 3‬ا !‪N‬ث‬

‫ٔ‬ ‫اﻰا = ‪:: ;5‬‬
‫‪1 A‬ا = ‪5‬اﻰا = ‪1 3‬‬ ‫]ا‪K‬‬ ‫> *_ ا‬
‫*‪N‬ل ا = ‪2‬‬
‫ا= ﻪ‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫ا= ﻪ‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪Distanc‬‬ ‫‪Distanc‬‬
‫‪200‬‬ ‫‪1000‬‬ ‫‪1410‬‬ ‫‪400‬‬ ‫‪0‬‬ ‫‪200‬‬ ‫‪1000‬‬ ‫‪1821‬‬ ‫‪400‬‬ ‫‪0‬‬
‫‪e‬‬ ‫‪e‬‬
‫‪Path‬‬ ‫‪5‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪5‬‬ ‫‪0‬‬ ‫‪Path‬‬ ‫‪5‬‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪0‬‬
‫‪Include‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪Include‬‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬
‫ا ‪ G‬ﺢ‪:‬‬
‫ٔ‬ ‫‪::‬‬ ‫‪ 3 7‬ﺢ;‬

‫ا*_> ا = ﻪ ‪ G 2‬ﺢ ﻰ ا = ‪ O‬ا ‪ 2‬دة‬
‫‪ :7‬ا ‪ 7 3‬ت ا !‪N‬ث‬
‫ا= ﻪ‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫>‪N‬ﺣ‪ m‬ان ﺤ ت ا ‪ ,4‬ا ! >‪ :7 :‬ا ‪ 7 3‬ت ا !‪N‬ث &‪:‬‬ ‫‪Distanc‬‬
‫‪200‬‬ ‫‪1000‬‬ ‫‪1410‬‬ ‫‪400‬‬ ‫‪0‬‬
‫‪e‬‬
‫)‪ (false , 1 , 800‬و&_ا ‪ :‬ان [ ل ا‪ 34‬ا ات ‪1‬‬ ‫‪Path‬‬ ‫‪5‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪5‬‬ ‫‪0‬‬
‫ا = ﻪ ‪ 1‬ا ﻰ ا = ﻪ ‪ 2‬ﺣ ﻰ &_^ ا ﺤ‪s‬ﻪ & ‪800‬‬ ‫‪Include‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫ا ^ا ﻪ‬
‫‪1‬ا ‪ 0‬لاﻰا = ﻪ‪3‬‬
‫‪ 0‬لاﻰ‬ ‫‪ :‬ا = ﻪ ‪ 1‬ان ا = ﻪ ا ‪ O :‬ا‪% +‬ا‬ ‫;‬
‫ا = ﻪ ‪ :& 2‬ا = ﻪ ‪1‬‬
‫&_ا ا ‪2985‬‬ ‫إ ‪1‬ا = ﻪ ‪ A 1‬ةو‬
‫‪800‬‬ ‫او <‪ ] [ 1‬ا = ﻪ ‪ 2‬و &_ا ا‬
‫‪ 1‬ا = ﻪ ‪ 1‬او <‪ ] [ 1‬ا = ﻪ ‪4‬‬
‫و ‪ :‬ا = ﻪ ‪ false‬ان ا = ﻪ ‪_*B O 2‬‬
‫‪ 1‬اﻻ< ر ﺤ‪ % %‬ا‪ 34‬ا ات‬
‫و ا ‪ 0‬ل ‪ ^_& :7‬ا ﺤ ﻪ‬
‫&‪310 :‬‬
‫ﺣ ﻰ &_^ ا ﺤ‪s‬ﻪ‬
‫ﺤ ت ‪PATH [ 4 ] = 1‬‬ ‫; ‪3‬ﺢ‬ ‫‪800 1‬‬ ‫و ان ‪ 310‬ا‪K0‬‬
‫ٔ‬
‫ل ا ﻰ ا = ﻪ ‪ ] [ 1< 3‬ا = ﻪ ‪4‬‬ ‫اي ان ا ‪0‬‬ ‫_ ‪ A c‬ل ا = ﻪ ‪ 1 G 4‬ا‪ 34‬ا ات‬
‫ٔ‬ ‫و< ﻪ ‪ 3‬ﺢ ‪4‬‬
‫لاﻰ‪4‬‬ ‫و ان ‪ PATH [ 4] = 1‬اي ان ا ‪0‬‬
‫<‪ ] [ 1‬ا = ﻪ ‪ => ) 1‬ا ‪%‬ا (‬ ‫]‪DISTANCE [ 3‬‬
‫ﺳ وي‬
‫ﻪ‪3‬‬ ‫و ا>ﻪ و ‪ O‬ا* ر ا = ‪ 0 4‬ل ا ﻰ ا =‬ ‫) ‪( 1731 = 1421+310‬‬
‫و‪ 3‬ﺢ ﺤ تا ‪ 3‬ا ا‪7 3 ,‬‬

‫ا= ﻪ‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪INCLUDE‬‬
‫‪Distance‬‬ ‫‪0‬‬ ‫‪800‬‬ ‫‪1731‬‬ ‫‪310‬‬ ‫‪200‬‬
‫ﺳو =‬
‫‪Path‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪true‬‬
‫ٔ‬
‫‪Include‬‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪:‬‬ ‫اي ان ﺤ ت ا ‪ 7 3‬ت ا !‪N‬ث ;‬
‫ً‬
‫إذا ‪ :7‬ا ^ ا ﻪ ‪ 1‬ا ارز ﻪ‬ ‫‪INCLUDE‬‬ ‫و ان ‪ O 4 T‬ا ‪7 3‬‬
‫ٔ‬ ‫ٔ‬
‫‪11‬اﻰ‪2‬اﻰ‪3‬‬ ‫‪N +‬ﺣ‪ m‬ان [ ل ا‬ ‫‪ * Y‬ذة ‪ 1‬اﻻ< ر‬
‫‪1‬ا = ﻪ‪1‬اﻰ‪4‬‬ ‫ا‪ [ 1 K0‬ل ا‬ ‫ا ﻪ ا = ﻪ ‪(false‬‬ ‫)و&‬
‫_ ا ارز ﻪ‬ ‫‪+‬فﺳ‬
‫و> ‪ 3 c _ .‬ﺢ [ ل ا ﺳ ‪7‬‬
‫ﺣ ﻰ ‪ 3‬ﺢ‪c 0 <O 7, 2‬ا ‪7 3‬‬
‫‪1210 = 410+800‬‬ ‫‪ 1 1‬ا ﻰ ‪ 3‬ﺳ وي‬
‫ﺳ و = ‪true‬‬
‫و ‪ c 1 G 1‬ا ‪N %‬ت‬
‫^‬ ‫‪ ^_& :7‬ا‬ ‫و& ا‪ 1 4‬ا ل ا ﺳ ]‬
‫ﻪ ]‪ 4 1 PATH [3‬ا ﻰ ‪2‬‬ ‫‪4 K %‬‬ ‫‪ 1 1‬ا ﻰ ‪ Og 4‬ا ﻰ ‪3‬‬
‫]‪1731 1 DISTANCE[3‬ا ﻰ ‪1210‬‬ ‫و ‪%‬‬ ‫و _ ‪ O c‬إ‪ 2‬اء ا ‪N %‬ت ا ‪N‬ز‬

‫< ﻰ ا ‪ 7 3‬ت <‪ ] [ 1‬ا‪ 2/‬اء‬
‫]‪INCLUDE [2‬‬ ‫و ‪4 %‬‬ ‫‪UPDATE‬‬
‫‪ false 1‬ا ﻰ ‪true‬‬
‫ اﻻ< ر‬1 ‫ ا*_ت‬%4 2 ‫ ان ا = ﻪ‬:
ٔ ٔ ‫ث‬N! ‫ ت ا‬7 3 ‫ ﺢ ﺤ ت ا‬3 ‫و< ﻪ‬
‫ ا ات‬34‫ ا‬%.> ‫ اﻻ* ة‬7 3 ‫ ا‬1 ‫و‬
ٔ
( ‫ ) اي >= ا‬3 ‫ ا ﻰ ا = ﻪ‬s c ‫وذ‬
PATH [ 3 ] =2 ‫ ان‬m‫ﺣ‬N> I ‫ﺣ‬ ‫ا= ﻪ‬ 1 2 3 4 5
ٔ
2 1 O 3 ‫ ل ا ﻰ‬0 ‫اي ان ا‬ Distance 0 800 1210 310 200
2 ‫ ل ا ﻰ‬0 ‫ ; ا‬1< ‫ا‬ Path 0 1 2 1 1

ٔ Include true true true false true
PATH [ 2 ] = 1 ‫ ﻻن‬1 < O ‫ﺢ ا>ﻪ‬G‫ ا ا‬1 7
ٔ
‫ ا ات‬34‫ ن ا‬7 ‫ا‬% ‫ >= ا‬:& 1 ‫و ان‬
‫ا= ﻪ‬ 1 2 3 4 5 3 ‫ اﻰ‬2 ‫ اﻰ‬1 &
Distance 0 800 1210 310 200 ‫ [ـ ل &_ا ا‬7 ‫و‬
Path 0 1 2 1 1 DISTANCE 7 3 ‫م ا‬% ‫>ﺳ‬
Include true true true true true
(1210) ‫ ا = ﻪ‬DISTANCE [ 3 ] 7
‫ [ ل ا‬:&‫و‬
‫‪ G‬ﺢا ! ل‬
‫‪: >g‬‬ ‫ا ‪ .‬ار‬ ‫‪7 3 M‬‬ ‫>= م ‪ O+‬ا‬
‫>= م ﺤﺳ ب ا‪ 34‬ا ات ‪ 1‬ا = ﻪ ‪ 1‬و ا = ﻪ ‪3‬‬
‫‪2985‬‬
‫اﻻﺣ ﻻت ‪:‬‬
‫‪800‬‬ ‫‪410‬‬
‫=‪1210‬‬ ‫‪410+800‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬
‫=‪2985‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪1421‬‬
‫=‪3233‬‬ ‫‪1421+612+800‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪612‬‬
‫=‪1731‬‬ ‫‪1421+310‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪310‬‬
‫‪200‬‬
‫=‪2021‬‬ ‫‪1421+400+200‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪1‬‬
‫=‪1622‬‬ ‫‪410+612+400+200‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪1‬‬
‫‪4‬‬ ‫‪5‬‬
‫=‪1332‬‬ ‫‪410+612+310‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪400‬‬
‫‪ G‬ﺢا ! ل‬
‫= ا! > ‪:‬‬ ‫ا‬
‫و ‪ %‬ﺣﺳ ب اوزان ‪ , 2‬اﻻﺣ ﻻت‬
‫* ارز ‪Floyd % 7‬‬
‫‪ 1‬ا = ‪ 1‬و ا = ‪? 3‬ﺢ ان ا‬
‫‪ * %‬ارز ‪ < N % % 7‬ﻰ * ارز ‪ Dijkstra‬ﺣ ‪I‬‬ ‫‪1‬ا = ‪1‬اﻰا = ‪2‬اﻰا = ‪3‬‬
‫= م &_^ ا ارز < ﻰ ﺣﺳ ب ‪ 7 3‬ا‪ 34‬ا ات ‪1‬‬ ‫ٔ‬
‫& ا‪ 34‬ا ات = ر> ‪ :4 l` > ,‬ا ات‬
‫‪ :7 1‬ا ‪ M‬ا ‪:‬‬ ‫>= ‪1‬‬
‫= ‪1‬‬ ‫و&‪ L > :‬ا ‪ :7 .‬ﺣ ا ! ل‬
‫‪1210 = 410 + 800 = 3‬‬ ‫‪2‬‬ ‫‪1‬‬
‫ﺤ ج &_^ ا ارز ا ﻰ ‪Ng‬ث ‪ 7 3‬ت و&‪: :‬‬ ‫ٔ‬
‫‪ O 4 ,‬ا د اﻻول‬ ‫‪2‬‬ ‫‪N* 1‬ل = ر>‬
‫ار )‪(Adjacency Matrix Cost‬‬ ‫ا‪.‬‬ ‫‪7 3‬‬ ‫‪ 7‬ا ﺳ ‪ 7‬و = ر>‬ ‫‪3‬‬ ‫وا ‪ 3‬اﻻو ‪:‬‬
‫‪ AO‬ﺣ ‪. = +‬‬ ‫‪ = ,‬ا = ‪ O‬اﻻ* ى‬ ‫<‬ ‫‪ .‬ع ا = ‪ O‬ا ‪AB‬‬
‫د ‪ :7‬ا ‪7 3‬‬ ‫وا‬ ‫‪ L > :7‬ا ‪3‬‬
‫‪(Path Matrix) 1‬‬ ‫‪ 7 3‬ا‬
‫اذا ; ن ا ‪ .‬ع ا‪ 1 4‬ا = ا ‪< AB‬‬
‫ا‬ ‫ﺤ ي &_^ ا ‪ < 7 3‬ﻰ ا = ‪ O‬ا ‪%‬د ﻪ‬
‫ٔ‬ ‫د‬ ‫‪ L > :7‬ا ‪ 3‬وا‬ ‫>‪ K‬ا = = ا ‪ .‬ع ا =‬
‫‪ 34‬ا ات ‪1 => 1‬‬ ‫وا‬
‫;ـ ءة &_^ ا ارز & )‪O(n3‬‬
‫‪ I‬و ‪ J‬و ر ا ﻰ ذ ‪ c‬ب ]‪PATH [I][J‬‬
‫ٔ‬
‫و>‪ 1 %.‬ا ارز و ﻻ*‪ 1 q‬ا ‪%‬ور^ ا ‪%‬ا* ﻪ‬
‫ا>ﻪ ‪ %‬ا ‪%‬ور^ ‪> K‬ﺤ‪ < 3‬ﻰ‪:‬‬ ‫‪P 7 3‬‬
‫‪:‬‬ ‫‪ d O‬ا ‪% :7 7 3‬ا ا ارز ;‬
‫) ]‪P[I][J] = MINIMUM(P[I][K]+P[K][J],P[I][J‬‬
‫ﺳو ‪3‬‬ ‫‪COST [I][J] 1‬‬ ‫اذا ‪O‬‬

‫و&_ا ‪%‬ور^ ? ‪ 1‬ا‪ 34‬ا ات‬
‫و ]‪COST[I][J]=P[I][J‬‬
‫‪1‬ا = ﻪ‪I‬اﻰا = ﻪ‪J‬‬ ‫ٔ‬
‫ٔ‬ ‫اذا ; >‪ ) J=I f‬اي < ‪ 0‬ا = ( ﺳ وي ‪0‬‬
‫دون ا ور *‪N‬ل اي >= ﻪ ر‪ 4‬ا; ‪ < J 1‬ﻰ ‪ 7‬ض‬ ‫ٔ‬
‫و‪ :7‬ا ﺤ ﻻت اﻻ* ى ‪ MAXINT‬او ﻻ >‬
‫‪ 4 M‬ﻪ ا ﻰ ‪N-1‬‬ ‫ان >= ط ا‬
‫ا ﺤـ‬ ‫!ـ ل‬
‫ٔ‬ ‫ٔ‬ ‫ٔ‬
‫ا ‪ .‬ار‬ ‫اوﻻ >‪7 3 %.‬‬ ‫‪ M‬ا ‪ :7 1‬ا‬ ‫او‪ 7 3 %2‬ا‪ 34‬ا ات‬
‫‪% +‬ام * ارز ‪Floyd % 7‬‬
‫ا ﺳ ‪ 7‬ا ‪ A‬ة ‪ 1‬ا = ا اﺣ‪%‬ة وا = ‪ O‬اﻻ* ى‪.‬‬
‫ٔ‬
‫إ‪ A‬رة ∞ ‪%‬ل < ﻰ <‪%‬م و‪ 2‬د اي [ ] ‪. A‬‬
‫ٔ‬
‫ان <‪%‬د >= ط ا ‪ M‬ﺳ وي‬
‫‪(A,B,C,D,E) 5‬‬
‫‪P1‬‬ ‫‪7 3‬‬ ‫ا ‪.‬‬

‫>ﺤ‪ < 3‬ﻰ ‪ 7 3 5‬ت‬
‫)‪(P1, P2, P3, P4, P5‬‬
‫>‪ AB‬ا ﻰ ا د اﻻول وا ‪ 3‬اﻻول و>= رن‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬
‫‪ 1‬ا = ‪ O‬اﻻ* ى ‪ . ,‬ع ا = ‪ O‬ا ‪AB‬‬
‫‪A‬‬ ‫∞‬ ‫‪23 10‬‬ ‫∞‬ ‫‪18‬‬
‫< ‪ L > :7‬ا ‪ 3‬وا د‪.‬‬ ‫∞ ‪B 23 ∞ 10 48‬‬
‫‪C 10 10 ∞ 19‬‬ ‫‪7‬‬
‫‪ D.‬ان >‪K‬‬ ‫اذا ; ن ا ‪ .‬ع ا‪ 1 4‬ا =‬ ‫‪D‬‬ ‫∞‬ ‫‪48 19‬‬ ‫∞‬ ‫‪20‬‬
‫ا = = ا ‪ .‬ع‪.‬‬ ‫∞ ‪E 18‬‬ ‫‪7‬‬ ‫‪20‬‬ ‫∞‬
ٔ
:: ‫ ; ﻻ‬% ‫ و‬O = ‫ ﺣﺳ ب ا‬O
B+B=23+23=46 is < ∞
ٔ A B C D E
: ‫ & ; ﻻ‬K> ‫ ∞ اذن‬1 K0‫ا‬ = ‫ﺢ ان ا‬G‫ ا ا‬1
A ∞ 23 10 ∞ 18
A B C D E
∞ 23 10 ∞ 18 B 23 ∞ 10 48 ∞
A
B 23 46 10 48 ∞ C 10 10 ∞ 19 7
C 10 10 ∞ 19 7 D ∞ 48 19 ∞ 20
D ∞ 48 19 ∞ 20
E 18 ∞ 7 20 ∞
E 18 ∞ 7 20 ∞
P1 7 3 ` ‫ ا‬. ‫ا‬ ٔ
>‫و>= ر‬ :‫ا‬ = ‫> *_ ا‬
s‫ﺣ‬N C+B=10+23=33 is > 10
= ‫ و = ر> ∞ > ك ا‬2 % > : ‫ ا‬O = ‫ى ا‬%‫ اﺣ‬f> ; ‫اذا‬ :& ; ; > ‫اذن‬ = ‫ ا‬1 4‫ ا‬L ‫ ع‬. ‫دام ا‬
:& ; A B C D E
A ∞ 23 10 ∞ 18
D+B= ∞+23 B 23 46 10 48 ∞
‫ ز‬. ‫اذن ﻻ‬ C 10 10 ∞ 19 7
D ∞ 48 19 ∞ 20
E 18 ∞ 7 20 ∞
‫‪P2‬‬ ‫ا ‪7 3 .‬‬
‫ٔ‬
‫ات‬ ‫اﻻن > *_ ا ار ا ‪ :‬و> _ ا‬ ‫و& _ا ‪ = ,‬ا = ‪ O‬ا ﻰ ان > ‪ = 1 :‬ر>‬
‫; ‪ :7‬ا ات ا ﺳ =‬ ‫‪ , 2‬ا = ‪ . O‬ع ا د اﻻول وا ‪ 3‬اﻻول ن ا ‪.‬‬
‫‪A B C D‬‬ ‫‪E‬‬ ‫ٓ‬
‫; ﻻ‪:‬‬
‫∞ ‪A ∞ 23 10‬‬ ‫‪18‬‬
‫‪B 23 46 10 48‬‬ ‫‪41‬‬ ‫‪A B C D E‬‬
‫‪A‬‬ ‫‪∞ 23 10 ∞ 18‬‬
‫‪C 10 10 20 19‬‬ ‫‪7‬‬
‫‪B‬‬ ‫‪23 46 10 48 41‬‬
‫∞ ‪D ∞ 48 19‬‬ ‫‪20‬‬
‫‪C‬‬ ‫‪10 10 20 19 7‬‬
‫‪E 18 41 7 20‬‬ ‫‪36‬‬
‫‪D‬‬ ‫‪∞ 48 19 ∞ 20‬‬
‫‪E‬‬ ‫‪18 41‬‬ ‫‪7 20 36‬‬
‫‪P3‬‬ ‫ا ‪7 3 .‬‬ ‫‪P2‬‬ ‫‪7 3‬‬ ‫ا ‪ .‬ا `‬

‫ا ار ا ‪:‬‬ ‫ٓ‬
‫اﻻ ‪:‬‬ ‫‪ , 2‬ا = ‪ :7 ; f %< O‬ا ‪ 7 3‬ا‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬
‫‪A B C D E‬‬
‫‪A‬‬ ‫‪46 23 10 71 18‬‬
‫‪A‬‬ ‫‪46 23 10 71 18‬‬
‫‪B‬‬ ‫‪23‬‬ ‫‪46 10 48 41‬‬
‫‪B‬‬ ‫‪23 46 10 48 41‬‬
‫‪C‬‬ ‫‪10 10 20 19‬‬ ‫‪7‬‬
‫‪C‬‬ ‫‪10 10 20 19 7‬‬
‫‪D‬‬ ‫‪71 48 19 96 20‬‬
‫‪D‬‬ ‫‪71 48 19 96 20‬‬
‫‪E‬‬ ‫‪18‬‬ ‫‪41‬‬ ‫‪7‬‬ ‫‪20 36‬‬
‫‪7‬‬ ‫‪20 36‬‬
‫‪E‬‬ ‫‪18 41‬‬
‫‪P4‬‬ ‫‪7 3‬‬ ‫ا ‪ .‬ا `‬ ‫‪P3‬‬ ‫‪7 3‬‬ ‫ا ‪ .‬ا `‬
‫ا ار ا ‪_& :7::‬ا ا ار ﻻ >ﺤ ج ا ﻰ ‪K‬‬ ‫ا ار ا ‪ + D+‬ن ‪ K‬ا د ا‬
‫ٔ‬
‫اي ‪ 1 %‬ا د _ ‪ D&_> c‬ا ﻰ ا ار ا _ي ﻪ‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬ ‫‪A‬‬ ‫‪20 20 10 29 17‬‬
‫‪A 20 20 10 29 17‬‬ ‫‪B‬‬ ‫‪20 20 10 29 17‬‬
‫‪B 20 20 10 29 17‬‬ ‫‪C‬‬ ‫‪10 10 20 19‬‬ ‫‪7‬‬
‫‪C 10 10 20 19 7‬‬ ‫‪D‬‬ ‫‪29 29 19 38 20‬‬
‫‪D 29 29 19 38 20‬‬ ‫‪E‬‬ ‫‪17 17‬‬ ‫‪7‬‬ ‫‪20 14‬‬
‫‪E 17 17‬‬ ‫‪7 20 14‬‬
‫ا ‪ 7 3‬ا `‬ ‫‪P5‬‬ ‫‪7 3‬‬ ‫ا ‪ .‬ا `‬

‫ٔ‬ ‫ٓ‬
‫ا ‪:‬‬ ‫ن ‪ 7 3‬ا‪ 34‬ا ات < ﻰ ‪A‬‬ ‫اذن ‪P5‬‬ ‫‪ ^_& :7‬ا ﺤ & ك دة وﺣ ‪%‬ة >ﺤ ج ا ﻰ ‪ ; & K‬ﻻ ‪:‬‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬ ‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪E‬‬
‫‪A‬‬ ‫‪20‬‬ ‫‪20 10‬‬ ‫‪29‬‬ ‫‪17‬‬ ‫‪A 20 20 10 29 17‬‬
‫‪B‬‬ ‫‪20‬‬ ‫‪20‬‬ ‫‪10 29‬‬ ‫‪17‬‬ ‫‪B 20 20 10 29 17‬‬
‫‪C‬‬ ‫‪10‬‬ ‫‪10‬‬ ‫‪14‬‬ ‫‪19‬‬ ‫‪7‬‬ ‫‪C 10 10 14 19‬‬ ‫‪7‬‬
‫‪D‬‬ ‫‪29‬‬ ‫‪29 19‬‬ ‫‪38‬‬ ‫‪20‬‬ ‫‪D 29 29 19 38 20‬‬
‫‪E‬‬ ‫‪17‬‬ ‫‪17‬‬ ‫‪7‬‬ ‫‪20‬‬ ‫‪14‬‬ ‫‪E‬‬ ‫‪17 17‬‬ ‫‪7‬‬ ‫‪20 14‬‬
‫ا ‪ 7 3‬ا `‬
‫‪ 1‬ا‪% +‬ام ا ‪ 7 3‬اﻻ* ة ‪ 1‬ا‪ 2‬ا< دة‬

‫اﻻ‪ 3 7 0‬ﺢ ; ‪:‬‬ ‫ر‪ O+‬ا‬
‫ا ء‪..........‬‬ ‫ھ م وا‬ ‫را‬
‫ا!‬
‫‪127‬‬
‫‪www.stqou.com‬‬
‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﯿﻢ‬
‫اﺳﻢ اﻟﺪارس‪........................... :‬‬ ‫اﺳﻢ اﻟﻤﻘﺮر‪ :‬ﺗﺮﻛﯿﺐ اﻟﺒﯿﺎﻧﺎت وﺗﺼﻤﯿﻢ اﻟﺨﻮارزﻣﯿﺎت‬
‫رﻗﻢ اﻟﺪارس‪........................... :‬‬ ‫رﻗﻢ اﻟﻤﻘﺮر‪١٢٨٩ :‬‬
‫ﺗﺎرﯾﺦ اﻻﻣﺘﺤﺎن‪٢٠٠٧/7 /11 :‬‬ ‫ﻣﺪة اﻻﻣﺘﺤﺎن‪ :‬ﺳﺎﻋﺘﺎن‬
‫ﻋﺪد اﻷﺳﺌﻠﺔ‪٧ :‬‬
‫ﺟﺎﻣﻌﺔ اﻟﻘﺪس اﻟﻤﻔﺘﻮﺣﺔ‬
‫اﻹﺟﺎﺑﺔ اﻟﻨﻤﻮذﺟﯿﺔ ﻟﻼﻣﺘﺤﺎن اﻟﻨﮭﺎﺋﻲ‬
‫‪ --‬ﻧﻈﺮي ‪--‬‬ ‫ﻟﻠﻔﺼﻞ اﻟﺜﺎﻧﻲ "‪"١٠٦٢‬‬
‫‪٢٠٠٧ / ٢٠٠٦‬‬
‫)‪٣٠‬‬ ‫اﻟﺴﺆال اﻷول‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫ﻋﻼﻤﺘﺎﻥ ﻟﻜل ﺇﺠﺎﺒﺔ ﺼﺤﻴﺤﺔ‬
‫‪١٥ ١٤ ١٣ ١٢ ١١ ١٠‬‬ ‫‪٩‬‬ ‫‪٨‬‬ ‫‪٧‬‬ ‫‪٦‬‬ ‫‪٥‬‬ ‫‪٤‬‬ ‫‪٣‬‬ ‫‪٢‬‬ ‫‪١‬‬ ‫ﺍﻟﻔﺭﻉ‬
‫ﻨﻌﻡ‬ ‫ﻨﻌﻡ‬ ‫ﻻ‬ ‫ﻨﻌﻡ‬ ‫ﻻ‬ ‫ﻻ‬ ‫ﻻ‬ ‫ﻨﻌﻡ‬ ‫ﻨﻌﻡ‬ ‫ﻨﻌﻡ‬ ‫ﻻ‬ ‫ﻻ‬ ‫ﻨﻌﻡ‬ ‫ﺍﻟﺼﺤﻴﺤﻪ ﻨﻌﻡ ﻨﻌﻡ‬
‫)‪١٢‬‬ ‫اﻟﺴﺆال اﻟﺜﺎﻧﻲ‪:‬‬
‫‪m‬‬
‫ﻋﻼﻣﺔ(‬
‫‪ .١‬ﻣﺜﻞ اﻟﻌﺪد اﻟﺤﻘﯿﻘﻲ ‪ (٢٥٫٤)١٠‬ﻓﯿﺰﯾﺎﺋﯿﺎ ﺑﺎﺳﺘﺨﺪام اﻟﻨﻘﻄﺔ اﻟﻌﺎﺋﻤﺔ؟ )‪ ٤‬ﻋﻼﻣﺎت(‬
‫‪co‬‬
‫‪٠‬‬ ‫‪٠‬‬ ‫‪١٠١‬‬ ‫‪١١٠٠١٠١١‬‬
‫‪ .٢‬أرﺳﻢ ﻃﺮﯾﻘﺔ ﺗﺨﺰﯾﻦ اﻟﺘﻌﺒﯿﺮ اﻟﺮﯾﺎﺿﻲ )‪ (a^2+3*c/b+d*h‬ﻓﻲ ذاﻛﺮة ﺣﺎﺳﻮب وذﻟﻚ ﺑﺎﺳﺘﺨﺪام اﻟﺘﻤﺜﯿﻞ اﻟﻤﻨﻄﻘﻲ؟ )‪ ٤‬ﻋﻼﻣﺎت(‬
‫‪u.‬‬
‫‪o‬‬
‫‪tq‬‬
‫‪.s‬‬
‫‪w‬‬
‫‪ .٣‬ﻗﻢ ﺑﻌﻤﻠﯿﺔ ﺗﺤﻮﯾﻞ ﻟﻠﺘﻌﺒﯿﺮ اﻟﺮﯾﺎﺿﻲ ))‪ (A+B*(C*G^F-H/K‬ﻣﻦ اﻟﻨﻈﺎم اﻟﻮﺳﻄﻲ )‪ (infix‬إﻟﻰ اﻟﻨﻈﺎم اﻟﺘﺒﻌﻲ )‪ ٤) (postfix‬ﻋﻼﻣﺎت(‬
‫‪w‬‬
‫‪ABCGF^*HK/-*+‬‬
‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺜﺎﻟﺚ‪:‬‬
‫‪w‬‬
‫ﻋﻼﻣﺔ(‬
‫‪ .١‬ھﻨﺎك ﻋﺪة ﻓﻮاﺋﺪ ﻧﺠﻨﯿﮭﺎ ﻣﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﺮاﻛﯿﺐ اﻟﺒﯿﺎﻧﯿﺔ‪ ،‬أذﻛﺮھﺎ؟ )‪ ٨‬ﻋﻼﻣﺎت(‬
‫‪ -‬ﯾﺴﺘﻄﯿﻊ اﻟﻤﺒﺮﻣﺞ أن ﯾﺮﻛﺰ ﺟﮭﺪه وﺗﻔﻜﯿﺮه ﻋﻠﻰ اﻟﻤﺴﺄﻟﺔ اﻟﺘﻲ ﯾﺤﺎول ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻟﮭﺎ دون اﻟﺤﺎﺟﺔ إﻟﻰ اﻟﺘﻔﻜﯿﺮ ﻓﻲ ﺗﻔﺎﺻﯿﻞ‬
‫ﺗﺮﻛﯿﺒﺔ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫‪ -‬ﻓﻲ ﺣﺎﻟﺔ ﺗﻐﯿﺮ ﻃﺮﯾﻘﺔ ﺗﻤﺜﯿﻞ وﺗﻨﻔﯿﺬ ﺗﺮﻛﯿﺒﺔ ﺑﯿﺎﻧﺎت ﻣﻌﯿﻨﺔ ﻓﺈن اﻟﺒﺮاﻣﺞ اﻟﺘﻄﺒﯿﻘﯿﺔ اﻟﻜﺒﺮى اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﺗﺮﻛﯿﺒﺔ اﻟﺒﯿﺎﻧﺎت ھﺬه ﻟﻦ‬
‫ﺗﺘﺄﺛﺮ وﻻ ﺗﺤﺘﺎج إﻟﻰ ﻋﻤﻞ ﺗﻌﺪﯾﻞ ﻋﻠﯿﮭﺎ‪.‬‬
‫‪ -‬اﻻﺳﺘﺨﺪام اﻟﻤﺘﻜﺮر ﻟﻠﺒﺮاﻣﺞ ﺑﺪون اﻟﺤﺎﺟﺔ إﻟﻰ ﻛﺘﺎﺑﺘﮭﺎ ﻣﺮة أﺧﺮى‪.‬‬
‫‪ -‬ﺗﺴﮭﯿﻞ ﻋﻤﻞ ﻓﺮق اﻟﺘﺼﻤﯿﻢ واﻟﺒﺮﻣﺠﺔ ‪.‬‬
‫‪ .٢‬ﺗﺘﺒﻊ اﻟﺨﻮارزﻣﯿﺔ اﻟﺘﺎﻟﯿﺔ وﺑﯿﻦ ﺗﺄﺛﯿﺮھﺎ ﻋﻠﻰ ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺔ ]‪ .a[3‬ﺿﻊ اﻟﻨﺘﺎﺋﺞ ﻓﻲ اﻟﺠﺪول اﻟﻤﺮﻓﻖ‪ ٧) :‬ﻋﻼﻣﺎت(‬
‫‪i‬‬ ‫]‪j a[j-1] a[j‬‬ ‫‪a‬‬

‫‪---------------------------------------‬‬
‫‪0 2‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪341‬‬
‫‪0 1‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪431‬‬
‫‪1‬‬
www.stqou.com
1 2 3 1 431
1 1 4 3 431
١٥) :‫اﻟﺴﺆال اﻟﺮاﺑﻊ‬

(‫ﻋﻼﻣﺔ‬
Name, ID, Major ‫ ﻟﺘﻌﺮﯾﻒ ﻗﺎﺋﻤﺔ ﻣﺘﺼﻠﺔ ﻣﺰدوﺟﺔ ﯾﺤﺘﻮي ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮات‬DoubleList ‫ ﺑﺎﺳﻢ‬Class ‫ أﻛﺘﺐ‬.١
(‫ ﻋﻼﻣﺎت‬٥) .DeleteNode ‫ و‬InsertNode ‫ اﻟﻌﻤﻠﯿﺘﯿﻦ‬Class ‫ وأﯾﻀﺎ ﻣﻌﺮف ﻋﻠﻰ‬،‫واﻟﻤﺆﺷﺮات‬
Class DoubleList{
Private:
char Name;
int ID;
char Major;
DoubleList *next;
DoubleList *prev;
Public:
m
DoubleList * DeleteNode(DoubleList *list);
DoubleList * InsertNode(DoubleList *list, char, int, char);
};
co
(‫ ﻋﻼﻣﺎت‬٥) .‫ واﻟﺘﻲ ﺗﻘﻮم ﺑﺤﺬف آﺧﺮ ﻋﻨﺼﺮ ﻣﻦ اﻟﻘﺎﺋﻤﺔ اﻟﻤﺰدوﺟﺔ‬DeleteNode ‫ أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ‬.٢
DoubleList *DoubleList::DeleteNode(DoubleList *list){ u.

DoubleList *c = list;
While(c->next != NULL){
c = c->next;
o
}
c->prev->next = c->next;
tq
delete(c);
}
.s
(‫ ﻋﻼﻣﺎت‬٥) .‫ ﺗﻘﻮم ﺑﺎﻹﺿﺎﻓﺔ ﻋﻠﻰ ﺑﺪاﯾﺔ اﻟﻘﺎﺋﻤﺔ اﻟﻤﺰدوﺟﺔ‬InsertNode ‫ أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ‬.٣
DoubleList *DoubleList::InsertNode(DoubleList *list, char name, int id, char major){

w
DoubleList *c = list;
DoubleList *node = new DoubleList;

w
node->Name = name;
node->ID = id;
w
node->Major = major;
node->next = NULL;
node->prev = NULL;
if(list = = NULL) list = node;

else{
node->next = list;
c->prev = node;
list = node;
}
return list;
}
2
‫)‪١٣‬‬ ‫اﻟﺴﺆال اﻟﺨﺎﻣﺲ‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫‪ .١‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻓﺮﻋﯿﺎ ﺑﺎﺳﺘﺨﺪام ﻓﻜﺮة اﻟﻤﻜﺪﺳﺎت )‪ (Stacks‬ﻟﻔﺤﺺ ﻓﯿﻤﺎ إذا ﻛﺎن اﻟﻤﻜﺪس ﻓﺎرغ ‪ StackEmpty‬أم ﻻ ﻓﻲ ﺣﺎﻟﺔ‬
‫اﻟﺘﻤﺜﯿﻞ اﻟﺘﺘﺎﺑﻌﻲ‪ ٥) .‬ﻋﻼﻣﺎت(‬
‫{)‪bool AStack:: stackEmpty(AStack Q‬‬
‫)‪if(Q.top == ٠‬‬
‫;‪return true‬‬
‫;‪else return false‬‬
‫}‬
‫‪ .٢‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻓﺮﻋﯿﺎ ﺑﺎﺳﺘﺨﺪام ﻓﻜﺮة اﻻﺳﺘﺪﻋﺎء اﻟﺬاﺗﻲ ﻟﻄﺒﺎﻋﺔ ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺔ ]‪ numbers[10‬ﺑﺸﻜﻞ ﻋﻜﺴﻲ‪ ٨) .‬ﻋﻼﻣﺎت(‬
‫‪m‬‬
‫{)‪void rec(int numbers[], int size‬‬
‫{)‪if(size != 0‬‬
‫;" "<<]‪cout<< numbers[size-1‬‬
‫‪co‬‬
‫;)‪rec(numbers, size-1‬‬
‫}‬
‫}‬ ‫‪u.‬‬
‫************اﻷﺳﺌﻠﺔ اﻻﺧﺘﯿﺎرﯾﺔ ) اﺟﺐ ﻋﻦ اﺣﺪ اﻟﺴﺆاﻟﯿﻦ اﻟﺘﺎﻟﯿﯿﻦ(************‬
‫‪o‬‬
‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺴﺎدس‪:‬‬
‫ﻋﻼﻣﺔ(‬
‫‪tq‬‬
‫‪ ٥‬ﻋﻼﻣﺎت ﻟﻜﻞ ﻓﺮع‬

‫‪ -١‬ﻋﺮف ‪ class‬ﺑﺎﺳﻢ ‪ array‬ﯾﺤﺘﻮي ﻋﻠﻰ ﻋﻤﻠﯿﺘﯿﻦ ‪ compare‬و ‪ max‬واﻟﻤﺘﻐﯿﺮ ﻋﺒﺎرة ﻋﻦ ]‪.int a[4‬‬
‫{‪class array‬‬
‫‪.s‬‬
‫‪public:‬‬
‫;)‪bool compare(array s, array t‬‬
‫;)‪void Max(array s‬‬
‫‪w‬‬
‫‪private:‬‬
‫;]‪int a[4‬‬
‫;}‬
‫‪w‬‬
‫‪ -٢‬أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ ‪ max‬ﺣﯿﺚ ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ أﻛﺒﺮ رﻗﻢ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ]‪.a[4‬‬

‫‪w‬‬
‫{)‪void array:: Max (array s‬‬

‫;]‪int m = s.a[0‬‬
‫{)‪for(int k=0;k<4;k++‬‬
‫)‪if(s.a[k]>m‬‬
‫;]‪m = s.a[k‬‬
‫}‬
‫;‪cout<<m‬‬
‫}‬
‫‪ -٣‬إذا ﺗﻢ ﺗﻮرﯾﺚ اﻷﺑﻨﺎء ‪ A‬و ‪ B‬ﺧﺼﺎﺋﺺ ‪ ،array class‬أﻛﺘﺐ اﻗﺘﺮان ﺑﺎﺳ ﻢ ‪ compare‬ﯾﻘ ﻮم ﺑﻤﻘﺎرﻧ ﺔ ﻣﺤﺘﻮﯾ ﺎت اﻟﻤ ﺼﻔﻮﻓﺘﯿﻦ ﻟﻜ ﻞ‬
‫ﻣﻦ ‪ A‬و ‪ B‬ﺑﺤﯿﺚ ﯾﻄﺒﻊ رﺳﺎﻟﺔ ﺗﻘﻮل ﺑﻤﺴﺎواة أو ﻋﺪم ﻣﺴﺎواة ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺘﯿﻦ‪.‬‬
‫{)‪bool array:: compare(array A, array B‬‬
‫{)‪for(int k=0;k<4;k++‬‬
‫{)]‪if(A.a[k] != B.a[k‬‬
‫;"‪cout<<"Aren't equal‬‬
‫}‬
‫‪3‬‬
www.stqou.com
else{
cout<<"They are equal";
return 0;
}
}
}
١٥) :‫اﻟﺴﺆال اﻟﺴﺎﺑﻊ‬

(‫ﻋﻼﻣﺔ‬
(‫ ﻋﻼﻣﺎت‬١٠) ‫(؟‬Binary Search Algorithm) ‫ أﻛﺘﺐ ﺧﻮارزﻣﯿﺔ اﻟﺒﺤﺚ اﻟﺜﻨﺎﺋﻲ‬.١
int binarySearch( int a[], int key )

{
int low = 0;
int high = a.length - 1; //zero based array
int middle;
m
while( low <= high )
{
co
middle = ( low + high ) / 2;
if( key == a[ middle ] ) //match

return middle; u.
else if( key < a[ middle ] )
high = middle - 1; //search low end of array
else
o
low = middle + 1; //search high end of array
}
tq
return -1; //search key not found

}
.s
:‫ إذا أﻋﻄﯿﺖ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﺣﺮف وﺗﺮﻏﺐ ﻓﻲ إدﺧﺎﻟﮭﺎ ﻓﻲ ھﯿﻜﻞ ﺷﺠﺮي ﺛﻨﺎﺋﻲ وﻓﻖ اﻟﺘﺮﺗﯿﺐ اﻟﺘﺎﻟﻲ وﻣﻦ اﻟﯿﺴﺎر إﻟﻰ اﻟﯿﻤﯿﻦ‬.٢
w
‫ أرﺳﻢ ھﺬا اﻟﮭﯿﻜﻞ اﻟﺸﺠﺮي ﺑﺤﯿﺚ ﯾﻌﻄﯿﻚ اﺳﺘﻌﺮاض اﻟﻌﻨﺎﺻﺮ وﻓﻖ اﻟﺴﯿﺎق اﻟﻮﺳﻄﻲ ﻣﺮﺗﺒﺔ ﺗﺮﺗﯿﺒﺎ‬. J,R,D,G,T,E,M,H,A,F
(‫ ﻋﻼﻣﺎت‬٥) .‫ﺗﺼﺎﻋﺪﯾﺎ‬
w
w
4
www.stqou.com
‫اﻧﺘﮭﺖ اﻹﺟﺎﺑﺔ‬
m
co
o u.
tq
.s
w
w
w
5
‫ﻧﻤـﻮذج ﻟﻘﯿـﺎس ﺷﻤـﻮﻟﯿـﺔ اﻟﻤـﺎدة واﻻھـﺪاف اﻟﺘﻌﻠﯿﻤﯿـﺔ‬
‫اﺳﻢ اﻟﻤﺸﺮف‪ :‬ﻋﻼء اﻟﺪﯾﻦ إﺳﻤﺎﻋﯿﻞ ﻋﺒﺪ اﻟﺮؤوف ﺟﺒﺮ‬ ‫ﯾﺮﺟﻰ ﺗﻌﺒﺌﺔ ھﺬا اﻟﻨﻤﻮذج ﻋﻨﺪ إﻋﺪادﻛﻢ ﻻﺳﺌﻠﺔ اﻻﻣﺘﺤﺎن وﻣﻦ ﺛﻢ إﻋﺎدﺗﮫ اﻟﻰ داﺋﺮة اﻟﻘﺒﻮل واﻟﺘﺴﺠﯿﻞ واﻻﻣﺘﺤﺎﻧﺎت‬
‫اﺳﻢ اﻟﻤﺎده‪ :‬ﺗﺮﻛﯿﺐ اﻟﺒﯿﺎﻧﺎت وﺗﺼﻤﯿﻢ اﻟﺨﻮارزﻣﯿﺎت رﻗﻢ اﻟﻤﺎدة‪١٢٨٩ :‬‬ ‫ارﻗﺎم اﻟﻮﺣﺪات اﻟﻤﻄﻠﻮﺑﺔ ﻣﻦ اﻟﻜﺘﺎب اﻟﻤﻘﺮر‪١١-١ :‬‬
‫اﻟﻤﻨﻄﻘﺔ ‪ /‬اﻟﻤﺮﻛﺰ‪ :‬ﻗﻠﻘﯿﻠﯿﺔ‬
‫‪m‬‬
‫اﻷھـﺪاف اﻟﺘﻌﻠﯿﻤﯿـﺔ‬
‫‪co‬‬
‫ﺗﺤﻠﯿﻞ وﺗﺮﻛﯿﺐ‬ ‫اﺳﺘﯿﻌﺎب وﺗﻄﺒﯿﻖ‬ ‫ﺗﺬﻛﺮ‬
‫اﻟﻌﻼﻣﺔ‬ ‫اﻟﻮﺣﺪة اﻟﺘﻲ ورد‬ ‫رﻗﻢ اﻟﻔﺮع‬ ‫رﻗﻢ اﻟﺴﺆال‬ ‫اﻟﻌﻼﻣﺔ‬ ‫اﻟﻮﺣﺪة اﻟﺘﻲ ورد‬ ‫رﻗﻢ اﻟﻔﺮع‬ ‫رﻗﻢ اﻟﺴﺆال‬ ‫اﻟﻌﻼﻣﺔ‬ ‫اﻟﻮﺣﺪةاﻟﺘﻲ ورد‬ ‫رﻗﻢ اﻟﻔﺮع‬ ‫رﻗﻢ اﻟﺴﺆال‬
‫‪u.‬‬
‫ﻣﻨﮭﺎ اﻟﺴﺆال‬ ‫ﻣﻨﮭﺎ اﻟﺴﺆال‬ ‫ﻣﻨﮭﺎ اﻟﺴﺆال‬
‫‪2‬‬ ‫‪4‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪6‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪١‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪7‬‬ ‫‪9‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪1‬‬
‫‪o‬‬
‫‪2‬‬ ‫‪6‬‬ ‫‪8‬‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪9‬‬ ‫‪11‬‬ ‫‪1‬‬ ‫‪7‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪5‬‬ ‫‪7‬‬ ‫‪1‬‬
‫‪tq‬‬
‫‪2‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪1‬‬ ‫‪15‬‬ ‫‪4‬‬ ‫‪1,2,3‬‬ ‫‪4‬‬ ‫‪2‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪1‬‬
‫‪4‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪5‬‬ ‫‪7‬‬ ‫‪1‬‬ ‫‪5‬‬ ‫‪2‬‬ ‫‪11‬‬ ‫‪13‬‬ ‫‪1‬‬
‫‪4‬‬
‫‪5‬‬
‫‪7‬‬
‫‪9‬‬
‫‪3‬‬
‫‪2‬‬
‫‪2‬‬
‫‪7‬‬ ‫‪.s‬‬ ‫‪8‬‬
‫‪15‬‬
‫‪10‬‬
‫‪8‬‬
‫‪3‬‬
‫‪11‬‬
‫‪2‬‬
‫‪1,2,3‬‬
‫‪1‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫‪2‬‬
‫‪2‬‬
‫‪8‬‬
‫‪11‬‬
‫‪10‬‬
‫‪3‬‬
‫‪14‬‬
‫‪15‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪3‬‬
‫‪w‬‬
‫‪w‬‬
‫‪w‬‬
‫‪4‬‬
‫اﺳﻢ اﻟﺪارس‪........................... :‬‬ ‫‪www.stqou.com‬‬
‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﯿﻢ‬ ‫اﺳﻢ اﻟﻤﻘﺮر‪ :‬ﺗﺮﻛﯿﺐ اﻟﺒﯿﺎﻧﺎت وﺗﺼﻤﯿﻢ اﻟﺨﻮارزﻣﯿﺎت‬
‫رﻗﻢ اﻟﺪارس‪........................... :‬‬ ‫رﻗﻢ اﻟﻤﻘﺮر‪١٢٨٩ :‬‬
‫ﺗﺎرﯾﺦ اﻻﻣﺘﺤﺎن‪٢٠٠٧/........ /........ :‬‬ ‫ﻣﺪة اﻻﻣﺘﺤﺎن‪ :‬ﺳﺎﻋﺘﺎن‬
‫ﺟﺎﻣﻌﺔ اﻟﻘﺪس اﻟﻤﻔﺘﻮﺣﺔ‬
‫ﻋﺪد اﻷﺳﺌﻠﺔ‪٧ :‬‬
‫‪ --‬ﻧﻈﺮي ‪--‬‬ ‫اﻻﻣﺘﺤﺎن اﻟﻨﮭﺎﺋﻲ ﻟﻠﻔﺼﻞ اﻟﺜﺎﻧﻲ "‪"١٠٦٢‬‬
‫‪٢٠٠٧/٢٠٠٦‬‬
‫ﻧﻤﻮذج اﻟﻮﺣﺪات‬
‫‪ .١‬ﻋﺒﻰء ﻛﺎﻓﺔ اﻟﻤﻌﻠﻮﻣﺎت اﻟﻤﻄﻠﻮﺑﺔ ﻋﻨﻚ ﻓﻲ دﻓﺘﺮ اﻻﺟﺎﺑﺔ وﻋﻠﻰ ورﻗﺔ اﻻﺳﺌﻠﺔ‪.‬‬ ‫ﻋﺰﯾﺰي اﻟﺪارس‪:‬‬
‫‪ .٢‬ﺿﻊ رﻗﻢ اﻟﺴﺆال ورﻣﻮز اﻻﺟﺎﺑﺔ اﻟﺼﺤﯿﺤﺔ ﻟﻼﺳﺌﻠﺔ اﻟﻤﻮﺿﻮﻋﯿﺔ )ان وﺟﺪت( ﻋﻠﻰ اﻟﺠﺪول اﻟﻤﺨﺼﺺ ﻓﻲ دﻓﺘﺮ اﻻﺟﺎﺑﺔ‬
‫‪ .٣‬ﺿﻊ رﻗﻢ اﻟﺴﺆال ﻟﻼﺳﺌﻠﺔ اﻟﻤﻘﺎﻟﯿﺔ واﺟﺐ ﻋﻠﻰ دﻓﺘﺮ اﻻﺟﺎﺑﺔ‪.‬‬
‫)‪٣٠‬‬ ‫اﻟﺴﺆال اﻷول‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫أﺟﺐ ب ﻧﻌﻢ أو ﻻ ﻋﻦ اﻟﻌﺒﺎرات اﻟﺘﺎﻟﯿﺔ ﻓﻲ اﻟﺠﺪول اﻟﻤﺨﺼﺺ ﻹﺟﺎﺑﺔ ھﺬا اﻟﺴﺆال ﻋﻠﻰ دﻓﺘﺮ اﻹﺟﺎﺑﺔ‪.‬‬
‫‪ .١‬اﻷﻋﺪاد اﻟﺤﻘﯿﻘﯿﺔ ﻻ ﺗﻌﺘﺒﺮ ﻣﻦ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت اﻟﺘﺮﺗﯿﺒﯿﺔ‪.‬وﺣﺪة ‪٣‬‬
‫إن اﻟﺨﻮارزﻣﯿﺔ ذات اﻟﻜﻔﺎءة اﻟﻠﻮﻏﺎرﯾﺘﻤﯿﺔ ﺗﻘﻮم ﺑﻌﻤﻞ أﻛﺜﺮ ﻣﻦ اﻟﺨﻮارزﻣﯿﺔ ذات اﻟﻮﻗﺖ اﻟﺜﺎﺑﺖ‪ .‬وﺣﺪة ‪٢‬‬ ‫‪.٢‬‬
‫ﻋﻨﺪﻣﺎ ﻧﺼﻞ ﻓﻲ ﺣﺎﻟﺔ اﻟﻤﺼﻔﻮﻓﺎت اﻷﺣﺎدﯾﺔ إﻟﻰ وﺿﻊ ﻻ ﻧﺴﺘﻄﯿﻊ ﻣﻌﮫ إﺿﺎﻓﺔ ﻗﯿﻢ ﺟﺪﯾﺪة ﯾﺴﻤﻰ اﻟﻔﺎﺋﺾ‪ .‬وﺣﺪة ‪٤‬‬ ‫‪.٣‬‬
‫ﯾﻤﻜﻦ اﺳﺘﻌﺮاض اﻟﻘﺎﺋﻤﺔ اﻟﺪاﺋﺮﯾﺔ ﺑﻄﺮﯾﻘﺔ ﻋﻜﺴﯿﺔ‪ .‬وﺣﺪة ‪٤‬‬ ‫‪.٤‬‬
‫‪m‬‬
‫ﻧﺤﺘﺎج ﻣﺆﺷﺮ )‪ (Pointer‬واﺣﺪ ﻓﻘﻂ ﻟﺤﺬف ﻋﻨﺼﺮ ﻓﻲ ﻗﺎﺋﻤﺔ ﻣﺘﺼﻠﺔ ﻣﻨﻔﺮدة‪ .‬وﺣﺪة ‪٤‬‬ ‫‪.٥‬‬
‫‪ .٦‬ﺑﺎﺳﺘﺨﺪام اﻟﻤﻜﻤﻞ اﻟﺜﻨﺎﺋﻲ ﯾﻤﻜﻦ ﺗﻤﺜﯿﻞ اﻟﺮﻗﻢ ‪ (٤٠)١٠‬ﻓﻲ ذاﻛﺮة ﺣﺎﺳﻮب ﻃﻮل ﻛﻠﻤﺘﮭﺎ ‪ ١‬ﺑﺎﯾﺖ ﻛﻤﺎ ﯾﻠﻲ ‪ (١١٠١١٠٠٠)٢‬وﺣﺪة ‪١‬‬
‫‪ .٧‬ﺗﺘﻤﯿﺰ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺮﻣﺰﯾﺔ ذات اﻟﻄﻮل اﻟﺜﺎﺑﺖ ﺑﺴﮭﻮﻟﺔ اﺳﺘﺨﺪاﻣﮭﺎ ﻓﻲ ﺗﻤﺜﯿﻞ اﻟﺴﻼﺳﻞ اﻟﺮﻣﺰﯾﺔ وﺗﻨﻔﯿﺬ اﻟﻌﻤﻠﯿﺎت‪ .‬وﺣﺪة ‪٥‬‬
‫‪co‬‬
‫‪ .٨‬ﺗﺴﺘﺨﺪم ﻓﻜﺮة اﻟﻄﻮاﺑﯿﺮ )‪ (Queues‬ﻓﻲ إدارة وﺗﻨﻈﯿﻢ أﻋﻤﺎل ﻃﺎﺑﻌﺔ ﻣﻮﺻﻮﻟﺔ ﻋﻠﻰ ﺷﺒﻜﺔ ﺣﻮاﺳﯿﺐ‪ .‬وﺣﺪة ‪٦‬‬
‫‪ .٩‬إذا ﻛﺎن ھﻨﺎك ‪ ٥‬ﻋﻤﻠﯿﺎت إﺿﺎﻓﺔ و ‪ ٤‬ﻋﻤﻠﯿﺎت ﺣﺬف ﻓﺈن اﻟﻤﻜﺪس ﯾﺼﻞ ﻓﻲ ھﺬه اﻟﺤﺎﻟﺔ إﻟﻰ وﺿﻊ ﯾﺼﺒﺢ ﻣﻌﮫ ﺧﺎﻟﯿﺎ ﻣﻦ اﻟﻘﯿﻢ‪ .‬وﺣﺪة ‪٧‬‬
‫‪ .١٠‬ﯾﺤﺘﻮي اﻟﮭﯿﻜﻞ اﻟﺸﺠﺮي اﻟﺜﻨﺎﺋﻲ ﻋﻠﻰ ﻋﻨﺼﺮ ﺟﺬري وﺷﺠﯿﺮﺗﯿﻦ أو أﻛﺜﺮ ﻣﻨﻔﺼﻼت ﻋﻦ ﺑﻌﺾ‪ .‬وﺣﺪة ‪٩‬‬
‫‪ .١١‬ﻟﺘﻤﺜﯿﻞ ﺑﯿﺎﻧﺎت ﻛﺒﯿﺮة اﻟﺤﺠﻢ ﯾﻔﻀﻞ اﺳ ﺘﺨﺪام اﻟﻘ ﻮاﺋﻢ اﻟﻤﺘ ﺼﻠﺔ اﻟﺪاﺋﺮﯾ ﺔ ﺑ ﺪﻻ ﻣ ﻦ اﻟﺘﻤﺜﯿ ﻞ اﻟ ﺸﺠﺮي اﻟﺜﻨ ﺎﺋﻲ وذﻟ ﻚ ﻟ ﺴﺮﻋﺔ ﻋﻤﻠﯿ ﺔ‬
‫‪u.‬‬ ‫اﻟﺒﺤﺚ ﻓﻲ ھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺘﻤﺜﯿﻞ‪ .‬وﺣﺪة ‪٩‬‬
‫‪ .١٢‬ﻣﻦ ﻣﯿﺰات اﻟﻤﺨﻄﻄﺎت اﻟﺸﺒﻜﯿﺔ أﻧﮭﺎ ﺗﺤﺘﻮي ﻋﻠﻰ دوران‪ .‬وﺣﺪة ‪١٠‬‬
‫‪ .١٣‬ﯾﻘﺼﺪ ﺑﺎﻟﻔﺮز ﻋﻤﻠﯿﺔ إﯾﺠﺎد ﻣﻮﻗﻊ ﻋﻨﺼﺮ ﻣﻌﯿﻦ ﺿﻤﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘﯿﻢ‪ .‬وﺣﺪة ‪١١‬‬
‫‪o‬‬
‫‪ .١٤‬ﯾﻌﺘﻤﺪ ﻣﺒﺪأ اﻟﺒﺤﺚ اﻟﺜﻨﺎﺋﻲ ﻋﻠﻰ ﻋﻨﺎﺻﺮ ﻣﺮﺗﺒﺔ ﺗﺼﺎﻋﺪﯾﺎ أو ﺗﻨﺎزﻟﯿﺎ‪ .‬وﺣﺪة ‪١١‬‬
‫‪ .١٥‬ﻧﺘﯿﺠﺔ ﻟﺘﻨﻔﯿﺬ ﻋﻤﻠﯿﺔ اﻟﻔﺮز اﻟﻤﻘﯿﺪ ﻋﻠﻰ اﻟﮭﯿﻜﻞ اﻟﺸﺠﺮي اﻟﺜﻨﺎﺋﻲ ﻓﺈﻧﮫ ﯾﺘﻢ ﻃﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ ﻣﺮﺗﺒﺔ ﺗﺮﺗﯿﺒﺎ ﺗﻨﺎزﻟﯿﺎ‪ .‬وﺣﺪة ‪١٠‬‬
‫‪tq‬‬
‫)‪١٢‬‬ ‫اﻟﺴﺆال اﻟﺜﺎﻧﻲ‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫‪.s‬‬
‫‪ .١‬ﻣﺜﻞ اﻟﻌﺪد اﻟﺤﻘﯿﻘﻲ ‪ (٢٥٫٤)١٠‬ﻓﯿﺰﯾﺎﺋﯿﺎ ﺑﺎﺳﺘﺨﺪام اﻟﻨﻘﻄﺔ اﻟﻌﺎﺋﻤﺔ؟ )‪ ٤‬ﻋﻼﻣﺎت( وﺣﺪة ‪١‬‬
‫‪w‬‬
‫‪ .٢‬أرﺳﻢ ﻃﺮﯾﻘﺔ ﺗﺨﺰﯾﻦ اﻟﺘﻌﺒﯿﺮ اﻟﺮﯾﺎﺿﻲ )‪ (a^2+3*c/b+d*h‬ﻓﻲ ذاﻛﺮة ﺣﺎﺳﻮب وذﻟﻚ ﺑﺎﺳﺘﺨﺪام اﻟﺘﻤﺜﯿﻞ اﻟﻤﻨﻄﻘﻲ؟ )‪ ٤‬ﻋﻼﻣﺎت(‬
‫وﺣﺪة ‪١‬‬
‫‪ .٣‬ﻗﻢ ﺑﻌﻤﻠﯿﺔ ﺗﺤﻮﯾﻞ ﻟﻠﺘﻌﺒﯿﺮ اﻟﺮﯾﺎﺿﻲ ))‪ (A+B*(C*G^F-H/K‬ﻣﻦ اﻟﻨﻈﺎم اﻟﻮﺳﻄﻲ )‪ (infix‬إﻟﻰ اﻟﻨﻈﺎم اﻟﺘﺒﻌﻲ )‪(postfix‬‬
‫‪w‬‬
‫)‪ ٤‬ﻋﻼﻣﺎت( وﺣﺪة ‪٧‬‬

‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺜﺎﻟﺚ‪:‬‬
‫‪w‬‬
‫ﻋﻼﻣﺔ(‬
‫‪ .١‬ھﻨﺎك ﻋﺪة ﻓﻮاﺋﺪ ﻧﺠﻨﯿﮭﺎ ﻣﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﺮاﻛﯿﺐ اﻟﺒﯿﺎﻧﯿﺔ‪ ،‬أذﻛﺮھﺎ؟ )‪ ٨‬ﻋﻼﻣﺎت( وﺣﺪة‪٣‬‬
‫‪ .٢‬ﺗﺘﺒﻊ اﻟﺨﻮارزﻣﯿﺔ اﻟﺘﺎﻟﯿﺔ وﺑﯿﻦ ﺗﺄﺛﯿﺮھﺎ ﻋﻠﻰ ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺔ ]‪ .a[3‬ﺿﻊ اﻟﻨﺘﺎﺋﺞ ﻓﻲ اﻟﺠﺪول اﻟﻤﺮﻓﻖ‪ ٧) :‬ﻋﻼﻣﺎت( وﺣﺪة ‪٢‬‬
‫;}‪int a[3]={3,1,4‬‬
‫{)‪for(i=0;i<2;i++‬‬
‫{)‪for(j=2;j>0;j--‬‬
‫{)]‪if(a[j-1]<a[j‬‬
‫;]‪temp=a[j-1‬‬
‫;]‪a[j-1]=a[j‬‬
‫;‪a[j]=temp‬‬
‫}‬
‫"<<‪cout<<i<<" "<<j‬‬ ‫"<<]‪"<<a[j-1‬‬ ‫"<<]‪"<<a[j‬‬ ‫;"‬
‫;]‪for(k=0;k<3;k++) cout<<a[k‬‬
‫}‬
‫}‬
‫]‪i j a[j-1‬‬ ‫]‪a[j‬‬ ‫‪a‬‬
‫‪1‬‬
‫‪.‬‬ ‫‪www.stqou.com‬‬
‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺮاﺑﻊ‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫‪ .١‬أﻛﺘﺐ ‪ Class‬ﺑﺎﺳﻢ ‪ DoubleList‬ﻟﺘﻌﺮﯾﻒ ﻗﺎﺋﻤﺔ ﻣﺘﺼﻠﺔ ﻣﺰدوﺟﺔ ﯾﺤﺘﻮي ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮات ‪Name, ID, Major‬‬
‫واﻟﻤﺆﺷﺮات‪ ،‬وأﯾﻀﺎ ﻣﻌﺮف ﻋﻠﻰ ‪ Class‬اﻟﻌﻤﻠﯿﺘﯿﻦ ‪ InsertNode‬و ‪ ٥) .DeleteNode‬ﻋﻼﻣﺎت( وﺣﺪة ‪٤‬‬
‫‪ .٢‬أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ ‪ DeleteNode‬واﻟﺘﻲ ﺗﻘﻮم ﺑﺤﺬف آﺧﺮ ﻋﻨﺼﺮ ﻣﻦ اﻟﻘﺎﺋﻤﺔ اﻟﻤﺰدوﺟﺔ‪ ٥) .‬ﻋﻼﻣﺎت( وﺣﺪة ‪٤‬‬
‫‪ .٣‬أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ ‪ InsertNode‬ﺗﻘﻮم ﺑﺎﻹﺿﺎﻓﺔ ﻋﻠﻰ ﺑﺪاﯾﺔ اﻟﻘﺎﺋﻤﺔ اﻟﻤﺰدوﺟﺔ‪ ٥) .‬ﻋﻼﻣﺎت( وﺣﺪة ‪٤‬‬
‫)‪١٣‬‬ ‫اﻟﺴﺆال اﻟﺨﺎﻣﺲ‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫‪ .١‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻓﺮﻋﯿﺎ ﺑﺎﺳﺘﺨﺪام ﻓﻜﺮة اﻟﻤﻜﺪﺳﺎت )‪ (Stacks‬ﻟﻔﺤﺺ ﻓﯿﻤﺎ إذا ﻛﺎن اﻟﻤﻜﺪس ﻓﺎرغ ‪ StackEmpty‬أم ﻻ ﻓﻲ ﺣﺎﻟﺔ‬
‫اﻟﺘﻤﺜﯿﻞ اﻟﺘﺘﺎﺑﻌﻲ‪ ٥) .‬ﻋﻼﻣﺎت( وﺣﺪة ‪٧‬‬
‫‪m‬‬
‫‪ .٢‬أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻓﺮﻋﯿﺎ ﺑﺎﺳﺘﺨﺪام ﻓﻜﺮة اﻻﺳﺘﺪﻋﺎء اﻟﺬاﺗﻲ ﻟﻄﺒﺎﻋﺔ ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺔ ]‪ numbers[10‬ﺑﺸﻜﻞ ﻋﻜﺴﻲ‪ 8) .‬ﻋﻼﻣﺎت(‬
‫وﺣﺪة ‪٨‬‬
‫‪co‬‬
‫************اﻷﺳﺌﻠﺔ اﻻﺧﺘﯿﺎرﯾﺔ ) اﺟﺐ ﻋﻦ اﺣﺪ اﻟﺴﺆاﻟﯿﻦ اﻟﺘﺎﻟﯿﯿﻦ(************‬
‫‪u.‬‬
‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺴﺎدس‪:‬‬
‫ﻋﻼﻣﺔ(‬
‫‪o‬‬
‫‪ -١‬ﻋﺮف ‪ class‬ﺑﺎﺳﻢ ‪ array‬ﯾﺤﺘﻮي ﻋﻠﻰ ﻋﻤﻠﯿﺘﯿﻦ ‪ compare‬و ‪ max‬واﻟﻤﺘﻐﯿﺮ ﻋﺒﺎرة ﻋﻦ ]‪ ٥) .int a[4‬ﻋﻼﻣﺎت( وﺣﺪة ‪٣‬‬
‫‪tq‬‬
‫‪ -٢‬أﻛﺘﺐ اﻟﻌﻤﻠﯿﺔ ‪ max‬ﺣﯿﺚ ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ أﻛﺒﺮ رﻗﻢ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ]‪ ٥) .a[4‬ﻋﻼﻣﺎت( وﺣﺪة ‪٣‬‬
‫‪ -٣‬إذا ﺗﻢ ﺗﻮرﯾﺚ اﻷﺑﻨﺎء ‪ A‬و ‪ B‬ﺧﺼﺎﺋﺺ ‪ ،array class‬أﻛﺘﺐ اﻗﺘﺮان ﺑﺎﺳ ﻢ ‪ compare‬ﯾﻘ ﻮم ﺑﻤﻘﺎرﻧ ﺔ ﻣﺤﺘﻮﯾ ﺎت اﻟﻤ ﺼﻔﻮﻓﺘﯿﻦ ﻟﻜ ﻞ‬
‫ﻣﻦ ‪ A‬و ‪ B‬ﺑﺤﯿﺚ ﯾﻄﺒﻊ رﺳﺎﻟﺔ ﺗﻘﻮل ﺑﻤﺴﺎواة أو ﻋﺪم ﻣﺴﺎواة ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺘﯿﻦ‪ ٥) .‬ﻋﻼﻣﺎت( وﺣﺪة ‪٣‬‬
‫‪.s‬‬
‫)‪١٥‬‬ ‫اﻟﺴﺆال اﻟﺴﺎﺑﻊ‪:‬‬

‫ﻋﻼﻣﺔ(‬
‫‪w‬‬
‫‪ .١‬أﻛﺘﺐ ﺧﻮارزﻣﯿﺔ اﻟﺒﺤﺚ اﻟﺜﻨﺎﺋﻲ )‪(Binary Search Algorithm‬؟ )‪ ١٠‬ﻋﻼﻣﺎت( وﺣﺪة ‪١١‬‬
‫‪w‬‬
‫‪ .٢‬إذا أﻋﻄﯿﺖ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﺣﺮف وﺗﺮﻏﺐ ﻓﻲ إدﺧﺎﻟﮭﺎ ﻓﻲ ھﯿﻜﻞ ﺷﺠﺮي ﺛﻨﺎﺋﻲ وﻓﻖ اﻟﺘﺮﺗﯿﺐ اﻟﺘﺎﻟﻲ وﻣﻦ اﻟﯿﺴﺎر إﻟﻰ اﻟﯿﻤﯿﻦ‪:‬‬
‫‪ . J,R,D,G,T,E,M,H,A,F‬أرﺳﻢ ھﺬا اﻟﮭﯿﻜﻞ اﻟﺸﺠﺮي ﺑﺤﯿﺚ ﯾﻌﻄﯿﻚ اﺳﺘﻌﺮاض اﻟﻌﻨﺎﺻﺮ وﻓﻖ اﻟﺴﯿﺎق اﻟﻮﺳﻄﻲ ﻣﺮﺗﺒﺔ ﺗﺮﺗﯿﺒﺎ‬
‫ﺗﺼﺎﻋﺪﯾﺎ‪ ٥) .‬ﻋﻼﻣﺎت( وﺣﺪة ‪٩‬‬
‫‪w‬‬
‫‪2‬‬
‫اﻧﺘﮭﺖ اﻷﺳﺌﻠﺔ‬
‫ﻣﻊ ﺗﻤﻨﯿﺎﺗﻲ ﻟﻜﻢ ﺑﺎﻟﺘﻮﻓﯿﻖ‬
‫‪m‬‬
‫‪co‬‬
‫‪o‬‬ ‫‪u.‬‬
‫‪tq‬‬
‫‪.s‬‬
‫‪w‬‬
‫‪w‬‬
‫‪w‬‬
‫‪3‬‬
‫لتحديد العنوان المطلق للعنصر ضمن مصفوفة متعددة‬
‫العبعاد‪:‬‬
‫وفق التمثيل الفقي‬ ‫‪-‬‬
‫وفق التمثيل الطولي‬ ‫‪-‬‬
‫على فرض ان المصفوفة معرفة كاليتي ‪:‬‬

‫‪a[3,4,3] of integer -< a(1..3,1..4,1..3) <-‬‬
‫]‪a[L1..H1,L2..H2,L3..H3, …..Ln..Hn‬‬
‫ويتطلب الحصول على العنوان المطلق للعنصر ]‪a[2,2,3‬‬

‫]‪-< a[i1,i2,i3‬‬
‫قيمة ال ‪ Base‬القاعدة )عنوان اول عنصر في‬
‫المصفوفة( = ‪1001‬‬
‫أول ل وقفق التمثيل القفقي تستخدم المعادلة‬
‫أدناه‪:‬‬
‫]‪= Address[element‬‬
‫‪base + size[(i1-L1)*(H2-L2+1)*(H3-L3+1 * …..‬‬
‫‪(Hn-Ln+1) + (i2-L2)(H3-L3+1)(H4-L4+1)*….((Hn-‬‬
‫)‪Ln+1‬‬
‫‪(in-Ln) ..………+‬‬
‫فعليه فان المصفوفة ‪ (a[3,4,3‬هي )‪a(1..3,1..4,1..3‬‬
‫على أساس‬
‫]‪a[L1..H1,L2..H2,L3..H3, …..Ln..Hn‬‬
‫‪L1=1 H1 = 3‬‬ ‫‪L2= 1, H2 = 4‬‬ ‫‪, L3= 1, H3=3‬‬
‫‪n= 3‬‬
‫)‪a[2,2,3‬‬ ‫والعنصر ‪i1= 2 , i2=2,i3= 3‬‬
‫فان‪:‬‬
‫)‪A[2,2,3) = 1001 + 1*[(2-1)*(4-1+1)(3-1+1) + (2-1‬‬
‫])‪((3-1+1) +(3-1‬‬
‫‪= 1001 +1*[12 + 3 + 2] = 1001 + 17 = 1018‬‬

‫ثانيلا‪ :‬وقفق التمثيل الطولي تستخدم المعادلة‬
‫أدناه‪:‬‬
‫]‪= Address[element‬‬
‫* ‪base + size[(in-Ln)*(Hn-1-Ln-1+1)*(Hn-2-Ln-2+1‬‬
‫‪…..(H1-L1+1) + (in-1-Ln-1)(Hn-2-Ln-2+1)(Hn-3-Ln-‬‬
‫)‪3+1)*….((H1-L1+1‬‬
‫‪(i1-L1) ..………+‬‬
‫فعليه فان المصفوفة ‪ (a[3,4,3‬هي )‪a(1..3,1..4,1..3‬‬
‫على أساس ]‪a[L1..H1,L2..H2,L3..H3, …..Ln..Hn‬‬
‫‪L1=1 H1 = 3‬‬ ‫‪L2= 1, H2 = 4‬‬ ‫‪, L3= 1, H3=3‬‬
‫‪n= 3‬‬
‫)‪a[2,2,3‬‬ ‫والعنصر ‪i1= 2 , i2=2,i3= 3‬‬
‫فان‪:‬‬
‫)‪A[2,2,3) = 1001 + 1*[(3-1)*(4-1+1)(3-1+1) + (2-1‬‬
‫])‪((3-1+1) +(2-1‬‬
‫‪= 1001 +1*[24 + 3 + 1] = 1001 + 28 = 1029‬‬

‫د‪ .‬أنور محمد عكاشة‬
‫عضو هيئة التدريس المتفرغ – فرع غزة‬
‫ا اارس‪........................... :‬‬ ‫ﺏ) ا( اﺡ' اﺡ ‬ ‫ا ار‪ :‬آ ا ت و اارزﻡ ت‬
‫ر اارس‪........................... :‬‬ ‫ر ار‪1289 :‬‬
‫ری‪ 8‬اﻡن‪2011/....... /....... :‬‬ ‫ﻡة اﻡن‪ :‬ن‬
‫‪< --‬ي ‪--‬‬ ‫‪.‬ﻡ‪ !-‬اس ا‪+‬ﺡ!‬
‫د ا‪10 :!"# $‬‬
‫اﻡن ا‪2/‬ﺉ‪ 3+" 0‬ا‪"1102" 04‬‬
‫‪2011/2010‬‬
‫‪? .١‬ء آ@! ا‪"-‬ﻡت ا‪"B‬ﺏ! ‪ 0@ A/‬د@ ا‪.‬ﺏ! و "? ور! ا‪.!"# $‬‬ ‫=ی=ي اارس‪:‬‬
‫‪ GH .٢‬ر ا)‪F‬ال ورﻡز ا‪.‬ﺏ! ا ! ‪ !"# I‬ا‪) ! H‬إن و‪.‬ت( "? ا‪M‬ول ا‪ 0@ N‬د@ ا‪.O‬ﺏ!‬
‫‪ GH .٣‬ر ا)‪F‬ال ‪ !"# Q‬ا ! وا‪ ?" .‬د@ ا‪.O‬ﺏ!‪.‬‬
‫) ‪Q 22‬ﻡ!(‬ ‫ا)‪F‬ال ا‪$‬ول‪:‬‬

‫أ‪ .‬ب )‪ (-‬أو )( ﺙ ‪ GH‬ا‪.O‬ﺏ! ا ! "? ا‪M‬ول ا‪$‬ول @‪ 0‬د@ ا‪.O‬ﺏ!‪:‬‬
‫‪ 0@ .١‬ا‪ "U‬اا ی=ن ا‪ 0@ WF‬ﻡ‪ GH‬واﺡ ﻡ' ﻡا‪ GH‬ا‪V‬اآة ‪.‬‬
‫‪ .٢‬م ﺥارزﻡ ! ا‪+‬ز ادﺥ‪ 0‬ﺏ ‪/‬ﺹ ا‪ !@+‬ﺏ‪Z‬ار " ' رﺉ ) '‪ :‬إی‪M‬د أ‪ / 3‬وا ال ذ‪ A‬ا‪/-‬‬
‫ﻡ‪ G‬أول ‪ 0@ /‬ا‪=M‬ء ‪ U‬ﻡ‪.‬‬
‫‪ .٣‬اآ ا ت ا‪M‬یی! ه‪ A" 0‬ااآ ا‪) 0‬ﻡ‪ 2‬ﻡ' ﺥ‪Q‬ل " ت ﻡ‪ !@-‬ﻡ) " ‪ 2‬ﻡ‪ G‬ﻡ‪ !@-‬ا‪+‬ﺹ ‪.3‬‬
‫‪ .٤‬ی‪ 'Z‬ا ‪-‬اض اﺉ! ااﺉی! ﺏ‪B‬ی! ا‪.! Z-‬‬
‫‪O .٥‬ی‪M‬د ‪a‬ل ا)")"! اﻡ=ی! ‪ Z‬دا! ‪M‬یی! ا !‪void StringLength(MyString& S, MyString T) :‬‬
‫‪ .٦‬ی‪c‬ر "‪B‬ﺏر أﺡ ﺏ ا‪.(FIFO) + +‬‬
‫‪ .٧‬إن ‪ !M‬ا‪ -‬ا‪ 4,6,1,2,*,*,- :0‬ه‪.24 0‬‬
‫‪) .٨‬م ا‪B‬اﺏ @‪ V +/ ! " 0‬ﺏاﻡ‪ f‬ا ء ا‪V‬ا‪.0‬‬
‫‪ .٩‬ی‪ h"B‬ا ‪ MW‬ة @ ! )‪ ?" (Subtree‬أي ‪=.‬ء ﻡ' ا‪ 3Z 2‬ا‪Mc‬ي‪.‬‬
‫‪ .١٠‬إذا آن د ا‪/-‬ﺹ ا‪.‬دة @‪ 0‬ا‪ jB‬ا‪ 3‬ی)وي ‪ n‬و د ااف ی)وي )‪ Q@ ،(n-1‬ی‪V2 'Z‬ا ا‪ jB‬ان‬
‫یي "? أي دورات )‪.(Cycles‬‬
‫‪ .١١‬ی‪ -‬ا‪+‬ز ا)ی‪ G‬ﻡ' أ ع أاع ا‪+‬ز ار‪ 0.‬ﻡ' ﺡ ‪ n‬ا) ! ‪ ?" o B /‬ااﺉ ا‪ Z‬ة‪.‬‬
‫) ‪Q 13‬ﻡ!(‬ ‫ا)‪F‬ال ا‪:04‬‬

‫)‪Q 6‬ﻡت(‬ ‫أ‪ .‬ﻡ‪ 34‬ا‪-‬د ا ‪= @ (-117 )10 0‬یﺉ ﺏ ام ا‪ !B/‬ا‪-‬ﺉ!‪.‬‬
‫ب‪ .‬ه‪ A/‬ا‪-‬ی ﻡ' ای ‪ p‬ا‪) 0‬م @‪ 0‬ی زﻡ' ‪ V +/‬ااﻡ‪ ،f‬اذآ ﺥ)! ﻡ‪ 2/‬ﻡ‪ G‬إ ‪B‬ء ﻡ‪ 4‬واﺡا "? إﺡى ه‪qV‬‬
‫)‪Q 7‬ﻡت(‬ ‫ای ‪.p‬‬
‫) ‪Q 9‬ﻡت(‬ ‫ا)‪F‬ال ا‪:n4‬‬

‫)‪Q 5‬ﻡت(‬ ‫أ‪ .‬أآ دا! ﺏ"‪t C++ !s‬آ ﻡ' أن ا‪ ! M‬ﺥ !‪.‬‬
‫ب‪ .‬إن " ! ا ‪-‬اض اﺉ! ااﺉی! "‪. 0@ u‬هه ' ا ‪-‬اض اﺉ! ا‪+‬دة‪ ،‬إ أن ه‪ ' @ A/‬أ ' @‪0‬‬
‫)‪Q 4‬ﻡت(‬ ‫أ "ب ا‪ ،h B‬اذآه‪.‬‬
‫) ‪Q 10‬ﻡ!(‬ ‫ا)‪F‬ال ااﺏ‪:G‬‬

‫)‪Q 5‬ﻡت(‬ ‫أ‪ .‬أآ @‪ j‬ا‪ 3M‬ا‪Q‬زﻡ! ‪/‬ء ااﺉ ا‪/4‬ﺉ !‪.‬‬
‫)‪Q 5‬ﻡت(‬ ‫ب‪ .‬أآ دا! ﺏ"‪ C++ !s‬اءة ")"! رﻡ=ی! ﺏ ام ااﺉ ا"!‪.‬‬
‫) ‪Q 7‬ﻡت(‬ ‫ا)‪F‬ال اﻡ‪:p‬‬

‫)‪Q 5‬ﻡت(‬ ‫ا‪ .‬اآ دا! ﺏ"‪ @ h" C++ !s‬إذا آن ا‪B‬ﺏر @ر‪ U‬ﺏ‪" t‬ب ااﺉ ا"!‪.‬‬
‫) ‪Q‬ﻡن(‬ ‫ب‪ .‬ﻡ? )م ا‪B‬اﺏ ا‪$‬و !‪.‬‬
‫) ‪Q 8‬ﻡت(‬ ‫ا)‪F‬ال ا)دس‪:‬‬

‫)‪Q 5‬ﻡت(‬ ‫أ‪ .‬ﺡل ا‪ -‬ا‪ 0‬ﻡ' ا‪</‬م ا‪ (Postfix) 0-‬ا? ا‪</‬ﻡ ' ا ‪ (Infix) 0B‬وا"‪:(Prefix)0‬‬
‫‪A4^B/A9^C*-‬‬
‫)‪Q 3‬ﻡت(‬ ‫ب‪ .‬أآ ا‪ GB‬ا‪M‬یي ‪ ! "-‬ا‪V‬ف "? ا‪Z‬س )‪.(Stacks‬‬
‫) ‪Q 11‬ﻡ!(‬ ‫ا)‪F‬ال ا)ﺏ‪:G‬‬

‫)‪Q 5‬ﻡت(‬ ‫أ‪ .‬ﻡ ا‪Z+‬ة ا‪ 0‬ا " ‪ 0@ 2‬آﺏ! ه‪V‬ا اﻡ‪ f‬وﻡ ه‪ ! 0‬ا‪.w s‬‬
‫>‪#include <iostream.h‬‬
‫;)‪void func(int w‬‬
‫) (‪main‬‬
‫{‬
‫;)‪func(21‬‬
‫;‪return 0‬‬ ‫}‬
‫‪1‬‬
‫)‪void func(int w‬‬
‫)‪{ if (nr > 0‬‬
‫;)‪{ func(w - 2‬‬
‫} ;‪cout<< w‬‬
‫}‬
‫)‪Q 6‬ﻡت(‬ ‫ب‪ .‬ﺏ‪/‬ءا "? ا‪ 3Z 2‬ا‪Mc‬ي ا‪ ،0‬أآ ‪ f‬ا ‪-‬اض ‪ 3Z‬ﻡ ی"‪:0‬‬
‫‪+‬‬
‫*‬
‫‪-‬‬
‫‪x‬‬
‫‪-‬‬ ‫‪/‬‬ ‫‪u‬‬
‫‪y‬‬ ‫‪z‬‬ ‫‪w‬‬ ‫‪t‬‬
‫‪ .١‬ا ‪-‬اض و@‪ h‬ا) ق ا ‪. LDR 0B‬‬

‫‪ .٢‬ا ‪-‬اض و@‪ h‬ا) ق ا"‪.DLR 0‬‬
‫‪ .٣‬ا ‪-‬اض و@‪ h‬ا) ق ا‪.LRD 0-‬‬
‫) ‪Q 10‬ﻡت(‬ ‫ا)‪F‬ال ا‪4‬ﻡ'‪:‬‬

‫إذا أ ‪ w B‬ا‪ jB‬ا‪:0‬‬
‫‪13‬‬
‫‪1‬‬ ‫‪2‬‬
‫‪15‬‬
‫‪9‬‬
‫‪20‬‬
‫‪10‬‬
‫‪4‬‬
‫‪11‬‬
‫‪14‬‬
‫‪6‬‬
‫‪18‬‬
‫‪8‬‬ ‫‪2‬‬
‫‪3‬‬
‫او‪: .‬‬
‫) ‪Q 5‬ﻡت(‬ ‫أ‪ .‬ﻡ‪ !+"Z !@+‬ا‪M‬ار‪.‬‬
‫) ‪Q 5‬ﻡت(‬ ‫ب‪ .‬ﻡ‪ !@+‬ا اات ﺏ ام ﺥارزﻡ ! @"ی ‪.Floyed Algorithm‬‬
‫أ‪ ' .‬أﺡ ا)‪F‬ا ' ا '‪:‬‬

‫)‪Q 10‬ﻡت(‬ ‫ا)‪F‬ال ا ‪:G‬‬
‫ﺏ ام ﺥارزﻡ ! ا‪+‬ز ا‪=M‬ﺉ‪ 0‬ر ‪/‬ﺹ اﺉ! ا ! ی ﻡ‪a H‬ی! ا‪:3‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬
‫‪99‬‬ ‫‪24‬‬ ‫‪89‬‬ ‫‪56‬‬ ‫‪22‬‬ ‫‪77‬‬ ‫‪42‬‬
‫)‪Q 10‬ﻡت(‬ ‫ا)‪F‬ال ا‪:W-‬‬

‫ﺏ ام ﺥارزﻡ ! ا‪ n‬ا‪/4‬ﺉ‪ 0‬و‪ xH‬ﺥ‪B‬ات ا‪ ' n‬ا‪ 0@ 8 /-‬اﺉ! ا !‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬
‫‪9‬‬ ‫‪20‬‬ ‫‪8‬‬ ‫‪2‬‬ ‫‪13‬‬ ‫‪33‬‬ ‫‪6‬‬ ‫‪23‬‬ ‫‪1‬‬ ‫‪15‬‬ ‫‪17‬‬
‫ا‪ w2‬ا‪!"# $‬‬
‫‪2‬‬
C PROGRAM FOR INSERTION
#include<stdio.h>
#include<conio.h>
void insert(int);
int delet(int);
void display(void);
int queue[3];
int rear=-1;
int front=-1;
void main()
{
int n=3;
char op;
clrscr();
do
{
printf("\nOptions");
printf("\nPress i for insertion");
printf("\nPress d for deletion");
printf("\nPress p for display");
printf("\nPress e for exit");
op=getche();
switch(op)
{
case 'i':insert(n);break;
case 'd':delet(n);break;
case 'p':display(); break;
default:printf("\nWrong operator");
}
}
while(op!='e');
getch();
}
void insert(int n)
{
int item;
if((front==0&&rear==n)||(front==rear+1))
{ printf("\nQueue over flow");
return;
}
if(front==-1)
{
front=0;
rear=0;
}
else if(rear==n)
rear=0;
else
rear=rear+1;
printf("\nEnter the item to be inserted");

scanf("%d",&item);
queue[rear]=item;
}
int delet(int n)
{
int item;
if(front==-1)
{ printf("\nQueue is empty");
return;
}
printf("\nYou have deleted %d",queue[front]);
queue[front]=0;
if(front==rear)
{
front=-1;
rear=-1;
}
else if(front==n)
front=0;
else
front=front+1;
return;
}
void display(void)
{
int i;
printf("\nDisplaying Queue\n");
for(i=0;i<3;i++)
printf("\n%d",queue[i]);
}
‫بسم هللا الرحمن‬
‫الرحيم‬
‫البرمجة بلغة ‪C++‬وتراكيب‬
‫البيانات‬
‫د ‪ .‬عميد غازي‬
‫البرمجة بلغة ‪C++‬وتراكيب‬
‫د ‪ .‬عميد غازي‬
‫الفصل األول ‪:‬‬
‫مقدمة إلى ‪..‬‬
‫لغة ‪c++‬‬
‫د ‪ .‬عميد غازي ‪.‬‬
‫أنواع لغات‬
‫البرمجة‬ ‫لغة اآللة ‪:‬‬ ‫‪‬‬
‫هي اللغة الوحيدة التي يستطيع الحاسب أن يفهمها مباشرة تتألف‬
‫من األصفار و الواحدات ‪.‬‬
‫اللغات البسيطة(لغة المج ّمع‪-‬الترميز) ‪:‬‬ ‫‪‬‬
‫هي لغة تستخدم مصطلحات قريبة من اللغة اإلنكليزية‪ ،‬و يتم تحويل البرامج من لغة‬
‫المجمع ‪Assembler .‬‬ ‫ّ‬ ‫المجمع إلى لغة اآللة بواسطة مترجم يسمى‬
‫لغات البرمجة العالية المستوى ‪:‬‬ ‫‪‬‬
‫هي اللغات التي ظهرت مع ظهور المترجمات( ‪ : Compiler‬يقوم بترجمة لغة المستوى‬
‫العالي إلى لغة اآللة) ‪ ،‬وأهم هذه اللغات ‪ :‬سي و سي بلص بلص ‪ , C++, C‬بيسك‬
‫‪ , Basic‬باسكال ‪ , pascal‬فورتران ‪ , fortran‬كوبول ‪ , Gobol‬ولغة جافا ‪. Java‬‬
‫لغات البرمجة المرئية ‪:‬‬ ‫‪‬‬
‫هي أحدث اللغات البرمجية التي تعتمد على اللغات الشيئية الموجهة ( ‪Object Oriented‬‬
‫‪ ) Languages‬والكائنات الجاهزة وأهم هذه اللغات ‪ :‬فيجوال سي بلص بلص ‪Visual c++‬‬
‫‪ ,‬فيجوال بيسك ‪ , Visual Basic‬فيجوال فوكس برو ‪ , Visual Fox Pro‬دلفي ‪. Delphi‬‬
‫البرمجة بلغة (‬
‫‪) C ++‬‬
‫لغة ‪ C++‬هي ‪:‬‬
‫لغة مشتقة من لغة ‪ ، c‬األختالف الرئيسي هو باضافة الصفوف‪.‬‬
‫‪ classes‬وبالتالي يمكن تقسيم عملية تعلم لغة الـ ‪.C++‬‬
‫إلى قسمين ‪/‬‬
‫‪ ‬يعتمد األول منها على تعلم األسلوب المهيكلل والمنهجلي لعمليلة تصلميم‬
‫البرامج ‪.‬‬
‫‪ ‬فللي حللين يسللمن التللاني بتعللليم كيفيللة اسللتخدام الصللفوف الملحقللة بهللذه‬
‫اللغة واستخدام التوابع الموجودة ضمن المكتبة المعيارية ‪. ANSI‬‬
‫البرمجة بلغة (‬ ‫مزايا لغة ‪ C++‬هي ‪:‬‬
‫‪++‬معينة‪) C.‬‬
‫هذه الدوال‬ ‫وزيع‬ ‫ت‬ ‫‪،‬تم‬ ‫الحجم ‪ : SIZE‬تحتوي على مجموعة ضخمة من الدوال جعلت منها لغة كبيرة نسبيا ً‬
‫على مجموعة من المكتبات المتخصصة ‪ ،‬كل مكتبة لها اسم معين وتحتوي على دوال‬
‫( ‪) SIN , COS , TAN…….‬‬ ‫مثال‪ -:‬المكتبة الرياضية ‪ MATH‬تحتوي على كافة الدوال الرياضية‬
‫اإلعالن الحر عن المتغيرات ‪: FREE VARIABLE DECLARATION‬أصبن من الممكن في‬
‫لغة ‪ C++‬اإلعالن الحر عن المتغيرات في أي موقع من البرنامج مما يتيح ربط المتغير بالوظيفة التي من‬
‫أجلها تم اإلعالن عنه مما يزيد من سهولة ومتابعة وفهم البرنامج‪.‬‬
‫اإلعالن عن التوابت ‪: CONSTANTS DECLARATION‬يتم استخدام الكلمة المحجوزة ‪ CONST‬لإلعالن‬
‫عن الثوابت وفيها يتم تحديد نوع الثابت وحجز ذاكرة تتناسب ونوع الثابت‪.‬‬
‫الدوال الخطية ‪ : INLINE FUNCTION‬وهي ميزه تتعلق بالدوال ذات الحجم البسيط‪ ،‬حيث يتم إدخال‬
‫سطور الدالة ضمن البرنامج الرئيسي أثناء زمن الترجمة حتى يتسنى تنفيذ البرنامج بشكل أسرع ‪.‬‬
‫مالحظة‪ //‬الدوال ذات الحجم الكبير والدوال التي تحمل حلقات تكرارية ال يتم اعتمادها على أنها خطية‪.‬‬
‫التعليقات ‪ : COMMENTS‬وهي عبارة عن جمل إيضاحية وليس لها أي تأثير على تنفيذ البرنامج وتستخدم‬
‫لتسهيل إعادة قراءة البرنامج أو تعديله من طرف المبرمج ويبدأ التعليق بالرمزين(*‪) /‬وينتهي‬
‫بالرمزين(‪) */‬سوا ًء كان التعليق لسطر واحد أو لعدة أسطر بينما الرمزين(‪)//‬يستخدمان للتعليق لسطر واحد‪.‬‬
‫‪/* THIS IS A COMMENT STATEMENT‬‬ ‫متال ‪:‬‬
‫‪*/‬‬
‫كيفية كتابة برنامج بلغة ( ‪C ++‬‬
‫)‬
‫كل الكتابات التي تلي هذه اإلشارة ) ‪ ( //‬تسمى تعليق ال يتم تنفيذه ‪:‬‬
‫‪//FirstProgram‬‬
‫) ( ‪main‬‬
‫}‬
‫هنا يتم تعريف البيانات ومن ثم يتم كتابة البرنامج‬
‫; ‪return 0‬‬
‫}‬
‫‪) C ++‬‬
‫‪ TURBO C++‬لبساطتها وسهولة تطبيق البرامج عليها‪.‬‬ ‫وسنستخدم بيئة‬
‫وللدخول إلى بيئة التربو للبحث عن الملف التنفيذي ‪ TURBO C++‬حيث‬
‫نجده‬
‫في المجلد ‪ TCWIN45 :‬وسيظهر لنا الشكل التالي ‪:‬‬
‫‪) C ++‬‬
‫ولكتابة أي برنامج يكفي أن ندخل إلى القائمة ‪ FILE‬ونختلار منهلا‬

‫األمر ‪ NEW‬ونبدأ بكتابة البرنامج ‪ .‬حيث نقوم بتنفيذه بعد كتابته‬
‫بلاألمر ‪ 0RUN :‬ملن القائملة ‪ DEBUG‬أو بالضلغط عللى ( ‪F 9‬‬
‫‪ ,)CTRL+‬ولحفللظ البرنللامج بعللد كتابتلله نللدخل إلللى القائمللة ‪FILE‬‬
‫ونختار منها األمر ‪. SAVE AS‬‬
‫متال‪ :‬طباعة نص مؤلف من سطر‬

‫‪welcome to c++‬‬
‫كيفية كتابة برنامج بلغة ( ‪C ++‬‬
‫)‬
‫كل الكتابات التي تلي هذه اإلشارة ) ‪ ( //‬تسمى تعليق ال يتم تنفيذه ‪:‬‬
‫‪//FirstProgram‬‬ ‫(بيئة تربو ‪)c++‬‬
‫) ( ‪main‬‬
‫}‬
‫; " ‪cout << " welcome to c++‬‬
‫}‬
( ‫كيفية كتابة برنامج بلغة‬
)DEV ‫سطر()بيئة‬ C ++ ‫ طباعة نص مؤلف من‬:‫مثال‬
1- //This is My First Program in C++

2- #include < iostream . h >
3- # include <stdlib.h>
4- int main( )
{
5- cout << "Welcome to C++";
6- system ("PAUSE");
7- return o;
}
‫‪) C ++‬‬
‫سالسل الهروب‬
‫‪:‬‬
‫المعنى‬ ‫سلسلة الهروب‬
‫سطر جديد أي وضع المؤشر في بداية السطر التالي‬ ‫‪\n‬‬
‫تحريك المؤشر مسافة جدولية أفقية ) ‪) tab‬‬ ‫‪\t‬‬
‫تستخدم لطباعة عالمة االقتباس‬ ‫"\‬
‫>‪# include <iostream.h‬‬
‫) ( ‪main‬‬
‫{‬
‫; " ‪Cout <<"welcome to c++ \ n‬‬
‫حرف الهروب‬
‫}‬
( ‫البرمجة بلغة‬
) C ++
‫ أكتب برنامجاً يقوم بطباعة مستطيل‬: ‫مثال‬
# include < iostream.h>
main ( )
{ cout << "**********\n" ;
cout << “* *\n";
cout << “* *\n";
cout << "**********\n";
return 0; }
‫‪) C ++‬‬
‫تعريف البيانات(المعطيات) ‪DATA DECLARATION‬‬
‫‪data‬‬
‫المتغيرات‬ ‫الثوابت‬
‫‪variables‬‬ ‫‪constants‬‬
‫عامة‬ ‫محلية‬
‫‪global‬‬ ‫‪local‬‬
‫‪ ‬عادة عند تعريف المتغير يجب أن نحدد هل هو متغير عام بمعنى أنه يمكن استخدامه في‬
‫جميع األجزاء (على مستوى البرنامج) أم هو متغير محلي بمعنى أنه يستخدم داخل الجزء‬
‫الخاص به فقط‪.‬‬
‫نميز بين المتغيرات العامة والمحلية من خالل وضع عملية التعريف داخل البرنامج‬
‫‪ ‬المتغيرات التي يتم تعريفها قبل بداية البرنامج (الدالة ‪ ) main‬تمثل متغيرات عامة‪.‬‬
‫‪ ‬المتغيرات التي يتم تعريفها داخل الدالة ‪ main‬أو داخل أي برنامج فرعي ‪ UDFs‬تعتبر‬
‫متغيرات محلية تستخدم فقط داخل الجزء المعرفة فيه‪.‬‬
‫‪) C ++‬‬
‫المتحوالت (المتغيرات) ‪VARIABLES‬‬
‫تعريف المتغيرات‪ :‬المتغيرات هي أسماء تحجز مواقع في الذاكرة‬
‫لحفظ البيانات داخلها‪.‬‬
‫كل اسم من أسماء المتحوالت متل ‪ x1, x2 , x3 , ….‬يتم وضعه‬

‫في الذاكرة ويعرف باسم ‪ name‬ونمط ‪ type‬وحجم ‪ size‬وقيمة‬
‫‪ . value‬وبالتالي فإن المتحول ‪ x1‬يملك االسم ‪ x1‬والنمط ‪x1 int‬‬
‫والحجم ‪5 4‬‬
‫بايت والقيمة هي حسب القيمة المقروءة ‪.‬‬
‫‪10‬‬ ‫‪x2‬‬
‫‪15‬‬ ‫‪x3‬‬
‫مواضع المتحوالت في الذاكرة‬

‫مع ذكر االسم والقيمة‬
‫‪) C ++‬‬
‫أنواع المتحوالت ‪:‬‬
‫‪, short int , long int‬‬ ‫المتحوالت الصحيحة‬ ‫‪‬‬

‫‪int‬‬
‫‪float , double , long double‬‬ ‫المتحوالت الحقيقة‬ ‫‪‬‬
‫المنطقي‬ ‫المتحول‬ ‫‪‬‬

‫‪Boolean‬‬
‫‪char‬‬ ‫المتحول المحرفي‬ ‫‪‬‬
) C ++
: ‫يبين الجدول التالي أنواع المتحوالت ومجاالتها وحجمها‬
‫نوع المتحول‬ ‫الحجم‬ ‫المجال‬

int 4 bytes -2147483648 to 2147483647
short int 2 bytes -32768 to 32767
Long int 4 bytes -2147483648 to 2147483647
char 1 byte -128 to 127
float 4 bytes -38+E3.45 to 38-E3.4
double 8 bytes -308+E1.7 to 308-E1.7
long double 8 bytes -308+E1.7 to 308-E1.7
bool 1 byte True or false

‫‪) C ++‬‬
‫اإلعالن عن المتغيرات ‪DECLARATION OF VARIABLES‬‬
‫قبل استخدام أي متغير في لغة ‪ C++‬يجب اإلعالن عنه أوال وذلك بتحديد اسمه ونوعه‪.‬‬
‫الصيغة العامة لإلعالن عن المتغيرات ‪:‬‬

‫‪Data type‬‬ ‫; ‪variable name‬‬
‫نوع المتغير‬ ‫اسم المتغير‬
‫مثال‪: 1‬‬
‫;‪int a‬‬
‫; ‪float mynumber‬‬
‫; ‪double b‬‬
‫;‪int a,b,c‬‬ ‫أما إذا أردت اإلعالن عن عدة متغيرات من نوع واحد‬
‫وهو مكافئ لإلعالن التالي ‪:‬‬
‫;‪int a‬‬
‫;‪int b‬‬
‫;‪int c‬‬
‫‪) C ++‬‬
‫التوابت ‪: constants‬‬
‫الثوابت هي مواقع لحفظ البيانات كالمتغيرات لكن المتغير يمكن تبديل قيمته‬
‫على عكس الثابت الذي يحافظ على قيمته األساسية‪.‬‬
‫وبالتالي يمكن القول على أنها عبارة عن متغيرات تحمل قيم ثابتة طيلة زمن‬
‫تنفيذ البرنامج‬
‫ويتم اإلعالن عن الثوابت باستخدام الكلمة المحجوزة ‪const‬‬
‫الصيغة العامة لإلعالن عن الثوابت تأخذ شكلين ‪:‬‬
‫‪1- data type const‬‬ ‫; ‪const _name= value‬‬
‫‪2- const‬‬ ‫‪data type‬‬ ‫; ‪const _name= value‬‬
‫مثال ‪:‬‬
‫‪1- float const‬‬ ‫;‪pi=3.14‬‬
‫‪2- int‬‬ ‫‪const‬‬ ‫;‪max= 100‬‬
‫أو‬
‫‪1- const‬‬ ‫‪float‬‬ ‫;‪pi=3.14‬‬
‫‪2- const‬‬ ‫‪int‬‬ ‫;‪max= 100‬‬
‫‪): C‬‬ ‫‪++‬‬
‫‪Basic Input / Output Functions‬‬ ‫أوامر اإلخراج واإلدخال األساسية‬
‫وهي عبارة عن الدوال المتضمنة في المكتبة ‪iostream‬‬
‫أمر اإلخراج ‪: cout‬‬
‫'' >>’‘‬ ‫يستخدم لطباعة المخرجات على الشاشة مع المؤثر‬
‫الصيغة العامة لألمر ‪ cout‬تأخذ ثالث أشكال ‪:‬‬
‫; “‪cout <<“ output sentence‬‬ ‫لطباعة جملة إخراج على الشاشة‬ ‫‪‬‬
‫;"‪cout<<"hello‬‬ ‫مثال‪:‬‬
‫;‪cout <<var_name‬‬ ‫لطباعة قيمة متغير على الشاشة‬ ‫‪‬‬
‫; ‪cout <<x‬‬ ‫; ‪int x‬‬ ‫مثال‪:‬‬

‫لطباعة نص وقيمة معاً حيث يفصل بينهما مؤثر اإلدخال(>>) ;‪cout <<“ message“ <<value‬‬ ‫‪‬‬
‫مثال‪:‬‬
‫;‪int x=7‬‬
‫;‪cout <<"x="<<x‬‬
‫‪): C‬‬ ‫‪++‬‬
‫‪Basic Input / Output Functions‬‬ ‫أوامر اإلخراج واإلدخال األساسية‬
‫أمر اإلدخال ‪: cin‬‬
‫''<< ''‬ ‫يستخدم لقراءة البيانات عن طريق لوحة المفاتيح مع المؤثر‬
‫الصيغة العامة لألمر ‪: cin‬‬
‫;‪cin>>var_name‬‬
‫;‪cin>>v1>>v2>………….>>vn‬‬
‫لقراءة حرف من لوحة المفاتيح‬ ‫أمثله‪:‬‬
‫;‪char a‬‬
‫;‪cin>>a‬‬
‫لقراءة قيمة صحيحة‬
‫; ‪int age‬‬
‫;‪cin>>age‬‬
‫لقراءة قيمة صحيحة وقيمة حقيقية‬
‫;‪int x‬‬
‫;‪float y‬‬
‫;‪cin>>x>>y‬‬
‫‪) C ++‬‬
‫العمليات(المؤترات)‬
‫الحسابية ‪:‬‬
‫طريقة التعبير حسب لغة ‪c++‬‬ ‫الرمز الحسابي‬ ‫اسم العملية‬
‫‪x1 + x2‬‬ ‫‪+‬‬ ‫الجمع‬
‫‪x1 –x2‬‬ ‫‪-‬‬ ‫الطرح‬
‫‪x1 * x2‬‬ ‫*‬ ‫الضرب‬
‫‪x1 / x2‬‬ ‫‪/‬‬ ‫القسمة‬
‫‪x1 % x2‬‬ ‫‪%‬‬ ‫باقي القسمة الصحيحة‬
‫مالحظللة ‪ :‬ومللن الجللدير بالللذكر أن لغللة ‪ C++‬تفللرب بللين الحللروف األبجديللة الصللغيرة‬
‫‪ SYSTEM , SYSTEM, SYSTEM‬تعاملل كأسلماء‬ ‫والكبيرة ؛ فمتالً األسلماء ‪:‬‬
‫مختلفة عن بعضها البعض‬
‫‪) C ++‬‬
‫برنامج جمع عددين صحيحين‬
‫>‪# include < iostream.h‬‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int x1 , x2, x3‬‬ ‫تعريف المتحوالت ‪//‬‬
‫;" =‪cout <<“x1‬‬ ‫تعليمة الطباعة ‪//‬‬
‫; ‪cin >> x1‬‬ ‫تعليمة قراءة متحول ‪//‬‬
‫;"= ‪cout << " x2‬‬
‫; ‪cin >> x2‬‬
‫‪ */‬المتحول الجديد ‪ x3‬إجراء عملية الجمع واإلسناد إلى *‪x3 = x1 + x2 ; /‬‬
‫; ”‪cout << “x3=" <<x3<<“\n‬‬ ‫تعليمة الطباعة المتعددة ‪//‬‬
‫} ; ‪return 0‬‬
‫تمرين ‪:‬على نمط المتال السابق أكتب برنامج إليجاد العمليات‬

‫الحسابية من جمع وطرح وضرب وقسمة ‪0‬‬
‫‪) C ++‬‬
‫تمرين ‪:‬‬
‫على نمط المتال السابق أكتب برنامج‬

‫إليجاد العمليات الحسابية من جمع وطرح‬
‫وضرب وقسمة ‪0‬‬
‫‪) C ++‬‬
‫تمارين ‪:‬‬
‫تمرين‪ : 1‬إيجاد مساحة ومحيط المستطيل ؟‬
‫تمرين‪ : 2‬إيجاد مساحة ومحيط الدائرة ؟‬
‫تمرين‪ : 3‬إدخال تالتة أعداد مختلفة وإيجاد المتوسط‬
‫الحسابي والمجموع ؟‬
‫‪) C ++‬‬
‫حل المتال ‪ : 1‬إيجاد مساحة ومحيط المستطيل ؟‬
‫)( ‪main‬‬
‫{‬
‫; ‪int a, b,x,m‬‬
‫;‪ a=";cin>>a‬أدخل طول المستطيل “<<‪cout‬‬
‫;‪ b=";cin>>b‬أدخل عرض المستطيل “<<‪cout‬‬
‫;‪x=a*b‬‬
‫)‪m=2*(a+b‬‬
‫;‪ x= " <<x‬مساحة المستطيل“<< ‪cout‬‬
‫;‪ m= " <<m‬محيط المستطيل“<< ‪cout‬‬
‫} ; ‪return 0‬‬
‫‪) C ++‬‬
‫حل المتال ‪ : 2‬إيجاد مساحة ومحيط الدائرة ؟‬
‫)( ‪main‬‬
‫{‬
‫تعريف متحول حقيقي وإسناد قيمة له‪float p=3.14; //‬‬
‫;‪float r,x,m‬‬
‫; ‪ r=“ ;cin>>r‬أدخل نصف قطر الدائرة “<<‪cout‬‬
‫; ‪x=p*r*r‬‬
‫; ‪m=2*p*r‬‬
‫;‪ x= “ <<x‬مساحة المستطيل“<< ‪cout‬‬
‫;‪ m= “ <<m‬محيط المستطيل“<< ‪cout‬‬
‫} ; ‪return 0‬‬
) C ++
‫ إدخال تالتة أعداد مختلفة وإيجاد المتوسط‬: 3 ‫حل المتال‬
‫الحسابي والمجموع ؟‬
#include <iostream.h>
main ()
{
float a,b,c;
cout << " enter a =" ; cin >> a ;
cout << " enter b = " ; cin >> b ;
cout << " enter c = " ; cin >> c ;
cout << " sum is : " << a+b+c << " \ n" ;
cout << average is : " << ( a+b+c)/3 <<" \n";
return 0 ; }
‫الفصل الثاني‬
‫المؤترات‬
‫‪OPERATORS‬‬
‫البرمجة بلغة ( ‪C++‬‬
‫)‬

‫‪) C ++‬‬
‫المؤثر ‪ :‬هو عبارة عن رمز رياضي يقوم بإجراء عملية‬
‫معينة على معامالته والمعامل هو القيمة التي يجري‬
‫عليها المؤثر العملية‪.‬‬
‫أنواع المؤترات في لغة ‪: C++‬‬

‫المؤثرات الحسابية ‪:‬‬ ‫‪‬‬
‫المؤثرات العالئقية(مؤثرات المقارنة)‬ ‫‪‬‬

‫‪) C ++‬‬ ‫‪ ‬المؤثرات الحسابية ‪:‬‬
‫أولوية تنفيذ المؤثرات الحسابية‪:‬‬
‫أولية التنفيذ‬ ‫العملية‬ ‫رمز العملية‬
‫تحسب أوالً‪ ،‬وإذا كانت األقواس متداخلة‬ ‫األقواس‬ ‫()‬

‫فإن األقواس الداخلية تحسب أوالً ثم التي‬
‫تليها‬
‫تحسب ثانياً‪ ،‬إذا تعددت العمليات فإنه يتم‬ ‫الضرب والقسمة‬ ‫* ‪% ، / ،‬‬
‫احتسابها من اليسار إلى اليمين‬ ‫وباقي القسمة‬
‫تحسب أخيراً‪ ،‬إذا تعددت العمليات فإنه‬ ‫الجمع والطرح‬ ‫‪- ، +‬‬
‫يتم احتسابها من اليسار إلى اليمين‬
) C ++
C++ ‫بعض العمليات الحسابية وما يقابلها بلغة‬
C++ ‫بلغة‬ ً ‫جبريا‬
m=(a+b+c+d)/4 abcd
m
4
d
m=a+b+c+d/4 m  abc
4
w
m=a*b+w/x-y m  ab   y
x
bc a
m=a+(b+c)/8+5*d-(a/b) ma  5d 
8 b
) C ++
: ‫ ما هو مخرج البرنامج التالي‬:‫مثال‬
# include < iostream.h >
int main()
{
int p,q,r,x ;
p=2; q=6;
r=p + q / p;
x=( p + q ) / p;
cout<<"r = "<<r<<"\n x = "<<x<<"\n";
return 0; }
‫‪) C ++‬‬
‫على نمط المثال السابق ‪:‬‬

‫ما هي نتيجة (خرج)العمليات الحسابية التالية‪:‬‬
‫‪y=2*5/2+6-12/3‬‬
‫‪z=(5-6+8/2)+6*9/3-2‬‬
‫‪w=10-8%3*2+9‬‬
‫‪) C ++‬‬
‫‪‬المؤثرات العالئقية(مؤثرات المقارنة)‬
‫‪: RELATIONAL OPERATORS‬‬
‫مؤتر المقارنة‬ ‫معنى المؤتر‬ ‫متال في لغة ‪C++‬‬
‫==‬ ‫يساوي‬ ‫‪x == y‬‬
‫!=‬ ‫ال يساوي‬ ‫‪x != y‬‬
‫>‬ ‫اكبر من‬ ‫‪x > y‬‬
‫<‬ ‫أصغر من‬ ‫‪x < y‬‬

‫=>‬ ‫اكبر من أو يساوي‬ ‫‪x >= y‬‬
‫=<‬ ‫اصغر من أو يساوي‬ ‫‪x <= y‬‬
‫‪) C ++‬‬ ‫مثال‪:‬‬
‫افرض أن المتغيرين ‪ I‬و‪ J‬من النوع الصحيح ‪ ،‬وحدد‬
‫لهما القيمتين ‪ -3 ,5‬على التوالي و منه نستنتج ‪:‬‬
‫التعبير‬ ‫القيمة‬
‫‪I != J‬‬ ‫‪TRUE‬‬

‫‪J*2==I*2‬‬ ‫‪FALSE‬‬
‫‪I–J<I+J‬‬ ‫‪FALSE‬‬
‫‪I–3==J+5‬‬ ‫‪TRUE‬‬
‫‪J<I>I+J‬‬ ‫‪TRUE‬‬
‫‪) C ++‬‬
‫عمليات اإلسناد والمقارنة‪:‬‬
‫الشكل الموافق‬
‫معنى الكتابة‬ ‫مثال‬ ‫الشكل الجبري‬
‫حسب ‪++c‬‬
‫‪ x‬تساوي‪y‬‬ ‫‪x == y‬‬ ‫==‬ ‫=‬
‫‪ x‬ال تساوي‪y‬‬ ‫‪x != y‬‬ ‫=!‬ ‫≠‬
‫‪ x‬أصغر من‪y‬‬ ‫‪x<y‬‬ ‫>‬ ‫>‬
‫‪ x‬أكبر من‪y‬‬ ‫‪x >y‬‬ ‫<‬ ‫<‬
‫‪ x‬أكبر أو يساوي ‪y‬‬ ‫‪x <= y‬‬ ‫=>‬ ‫≥‬
‫‪ x‬أصغر أو يساوي ‪y‬‬ ‫‪x >= y‬‬ ‫=<‬ ‫≤‬
‫لربط‪) C‬‬
‫أكثر‬ ‫‪‬المؤترات المنطقية ‪ :‬وهي تستخدم‪++‬‬
‫من تعبير منطقي بسيط مع بعضها البعض و هي‬
‫‪:‬‬
‫االسم بالعربي‬ ‫الرموز‬ ‫األدوات‬
‫و‬ ‫&&‬ ‫‪and‬‬
‫أو‬ ‫||‬ ‫‪or‬‬
‫النفي‬ ‫!‬ ‫‪not‬‬
‫وأولوية تنفيذها من اليسار إلى اليمين كما يلي‪:‬‬
‫‪NOT‬‬ ‫‪AND‬‬ ‫‪OR‬‬

) C ++
: ‫جدول الصواب والخطأ للمؤثرات المنطقية‬
X Y X && Y X || Y !X
True True True True False
True False False True False
False True False True True

False False False False True
C ++ ( ‫البرمجة بلغة‬
) : ‫ما هو ناتج التعبيرات التالية‬ :‫مثال‬
((5==5)&&(3>6)) - .1
True && False

False
((5==5)||(3>6)) .2
True || False
True
F && F || F || F && F .3
F && F || F || F && F
F || F || F
F || F
F
‫البرمجة بلغة ( ‪C ++‬‬
‫)‬ ‫‪ ‬المؤثر الشرطي (? ) ‪CONDITIONAL OPERATOR‬‬
‫يستخدم الختبار شرط معين ويرجع قيمة إذا‬

‫تحقق الشرط ويرجع قيمة أخرى إذا لم‬
‫يتحقق الشرط ‪.‬‬
‫والصيغة العامة له هي ‪:‬‬
‫‪(condition) ? result1 : result2‬‬
‫إذن المؤثر الشرطي يقبل ثالث معامالت هي‬
‫‪ .1‬الشرط المنطقي )‪(condition‬‬
‫‪ .2‬القيمة الراجعة إذا تحقق الشرط ‪result1‬‬
‫‪ .3‬القيمة الراجعة إذا لم يتحقق الشرط ‪result2‬‬
‫مثال‪:1‬برنامج إليجاد القيمة األكبر من بين قيمتين )‬
‫باستخدام المؤثر الشرطي‬
‫) ( ‪int main‬‬
‫{‬
‫;‪int a,b,c‬‬
‫;‪a=2‬‬
‫;‪b=7‬‬
‫;‪c=(a>b)?a:b‬‬
‫;‪cout<<"max = "<<c‬‬
‫} ; ‪return o‬‬
‫مثال‪ -:2‬عدل البرنامج السابق إلدخال ثالثة قيم و )‬
‫إيجاد القيمة األكبر‬
‫) ( ‪int main‬‬
‫{‬
‫;‪int a,b,c,d,e‬‬
‫;‪cin>>a>>b>>c‬‬
‫;‪d=(a>b)?a:b‬‬
‫;‪e=(c>d)?c:d‬‬
‫;‪cout<<"max = "<<e‬‬
‫} ;‪return o‬‬
‫الفصل الثالث‬
‫بنى التحكم‬
‫‪Control Structures‬‬

‫‪) C ++‬‬
‫بنى التحكم ‪: CONTROL STRUCTURES‬‬
‫‪ .1‬البنى الشرطية ‪:‬‬

‫ولها الشكل العام التالي ‪:‬‬ ‫‪ o‬أ ‪ -‬بنية األختيار ‪: if‬‬
‫; تعليمات ) شروط ( ‪if‬‬
‫‪) C ++‬‬
‫متال‪ :1‬إذا كان عالمة الطالب أكبر أو يساوي القيمة ‪ 60‬درجة‬

‫فيطبع كلمة ”‪"passed‬‬
‫;"‪if ( x > = 60 ) cout <<"passed‬‬
‫متال‪ :2‬أكتب برنامجا ً يطلب من المستخدم إدخال عددين صحيحين‬

‫‪ .‬ثم يقارن بينهما ؟‬
) C ++
: 2 ‫حل المتال‬
#include <iostream.h>
main ()
{
int a, b;
cout<<“ a=";cin>>a;
cout<<“ b=";cin>>b;
if ( a > b ) cout <<a<< " >" <<b;
if ( a < b ) cout <<a<<" <“<<b ;
if ( a = = b ) cout <<a<<“=" <<b;
return 0 ; }
‫‪) C ++‬‬
‫‪ .1‬البنى الشرطية ‪:‬‬

‫‪ o‬بنية االختيار ‪ : if / else‬ولها الشكل العام التالي ‪:‬‬
‫) شروط( ‪if‬‬
‫;تعليمات ‪1‬‬
‫‪else‬‬
‫; تعليمات ‪2‬‬
‫‪) C ++‬‬
‫متال‪:1‬‬
‫إذا كان عالمة الطالب أكبر أو يساوي القيمة ‪ 60‬درجة‬
‫فيطبع كلمة ناجن "‪"PASSED‬وإال فهي تطبع الكلمة راسب‬

‫"‪"FAILED‬‬
) C ++
if ( x > = 60 )
cout << " passed " ;
else
cout << "failed" ;
‫‪) C ++‬‬
‫أكتب برنامجا ً يقرأ عددا ً صحيحا ً تم يحدد و يطبع فيما‬
‫إذا كان هذا العدد زوجيا ً أم فرديا ً‬
) C ++
main ()
{
int a ;
cout <<“ a ="; cin>>a;
if ( a % 2 == 0)
cout << " ‫ زوجي‬not odd" ;
else
cout << “ ‫ فردي‬odd" ;
return 0 ; }
‫‪) C ++‬‬
‫البنى الشرطية ‪:‬‬ ‫‪.1‬‬
‫‪ o‬ب ‪ -‬البنى الشرطية المتعددة ‪ : if / else‬ولها الشكل العام‬

‫التالي ‪:‬‬
‫) شروط ‪if ( 1‬‬
‫) شروط ‪else if ( 2‬‬
‫) شروط ‪else if ( 3‬‬
‫‪else‬‬
‫‪) C ++‬‬
‫ادخل عالمة اإلمتحان من ‪ 100‬فيتم طباعة الحرف‬
‫المقابل لهذه العالمة ‪:‬‬
) C ++
if ( (grad >= 90)&&(grad)<=100)
cout << "A" ;
else if ( (grad >= 80)&&(grad)<90)
cout << "B" ;
cout << "C" ;
cout << "D" ;
cout << "H" ;
else
cout << "error" ;
‫‪) C ++‬‬
‫مالحظة ‪:‬‬
‫عادة تضع تعليمة واحدة في جسم البنية االختيارية ‪IF‬‬
‫ولكن إذا أردنا وضع عدة تعليمات يجب أن نقوم بوضعها‬
‫داخل قوسين كبيرين ‪ ( { } ) .‬نسمى مجموعة التعليمات‬
‫المحتواه ضمن زوج من األقواس الكبيرة بالتعليمية المركبة‬
‫‪COMPOUND STATEMENT .‬‬
) C ++
: ‫متال‬
if ( (grad >= 90)&&(grad)<=100)
if (grad > = 60 )
cout << " passed" ;
else
{
cout << " failed " ;
cout << " you must take this course again" ;
}
‫عندها يقوم البرنامج بتنفيذ‬60 ‫ أصغر من‬grad ‫في هذه الحالة إذا كانت قيمة‬
: ‫ ويطبع ما يلي‬else ‫التعليمتين الموجودتين في الجزء‬
failed
you must take this course again
‫‪) C ++‬‬
‫مجموعة من األمتلة‬
‫أكتب برنامج يأخذ كدخل عددين صحيحين من لوحة‬
‫المفاتين ويفحص فيما إذا كان التاني قاسم لألول ‪.‬‬
) C ++
# include<iostream.h>
main ( )
{
int a , b ;
cout<<"enter a=";cin>>a;
cout<<"enter b=;cin>>b;
if ( (b! = 0) && (a % b = = 0) )
cout << a << " is divisible by " <<b ;
else
cout <<a<<" is not divisible by " << b ;
return 0 ;
}
‫‪) C ++‬‬
‫متال‪: 2‬‬
‫أكتب برنامج يأخذ كدخل تالث أعداد صحيحة تم يطبع‬
‫أصغر هذه األعداد ‪.‬‬
) C ++ : 2 ‫حل المتال‬
main ()
{
int a , b, c ;
cout << " a= "; cin >> a;
cout << "b= "; cin >> b;
cout << " c= "; cin >> c;
if (( b > a)&&(c > a) )
cout << " min is" << a ;
else if (( a > b)&&(c > b))
cout << " min is " << b ;
else
cout << " min is " << c ;
return 0; }
‫‪) C ++‬‬
‫تمارين ‪:‬‬
‫تمرين‪ :1‬وإيجاد قيمة ‪y= (x-2)/x : y‬‬
‫تمرين‪ :2‬وإيجاد قيمة ‪y=x/(x-3 ) : y‬‬
‫تمرين‪ :3‬حل المعادلة من الدرجة األولى ‪a X + b = 0 :‬‬
‫مناقشا جميع الحاالت الممكنة لــ ‪0a,b‬‬
‫تمرين‪ :4‬حل معادلة من الدرجة التانية‪:‬‬
‫‪aX2 +bX+c=0‬‬
‫‪) C ++‬‬
‫‪ .2‬البنى التكرارية ‪:‬‬

‫أ – البنية التكرارية ‪ : while‬ولها الشكل العام التالي ‪:‬‬ ‫‪o‬‬
‫) شروط ‪while ( 1‬‬

‫{‬
‫}‬
‫‪) C ++‬‬
‫متال‪: 1‬‬
‫أكتب أكتب برنامج لطباعة األعداد من ‪ 1-10‬بشكل عمود‬
‫واحد ‪.‬‬
) C ++
main ()
{
int i=1 ;
while ( i <=10)
{
cout << i << "\n" ;
i = i +1 ;
}
return 0 ;
}
‫‪) C ++‬‬
‫متال‪: 2‬‬
‫يفرض لدينا عالمات مذاكرة قام بها طالب صف مؤلف من‬
‫عشرة طالب والمطلوب حساب معدل عالمات طالب الصف‬
‫في هذه المذاكرة ‪.‬‬
) C ++
main ()
{
float mark , sum ;
int i = 1;
sum = 0;
while ( i < = 10 )
{
cout<<"enter the mark="; cin>>mark;
sum = sum + mark ;
i = i +1 ;
}
cout<<"average is : "<<sum/10 ;
return 0 ;
}
‫‪) C ++‬‬
‫مالحظات ‪:‬‬
‫إن عدم وضع تعليمة أو فعل جسم البنية ‪ WHILE‬يسبب عدم تحقق الشرط‬ ‫‪.1‬‬
‫المرافق لها وينتج عن ذلك عدم إنتهاء التكرار ‪.‬‬
‫تسبب كتابة الكلمة ‪ WHILE‬مع حرف كبير في البداية خطأ وذك على اعتبار أن‬ ‫‪.2‬‬
‫لغة ‪ C++‬حساسة لحالة الحروف تحتوي كافة الكلمات المفتاحية الخاصة بلغة‬
‫‪ ++C‬مثل ‪ .. ،IF , WHILE‬وغيرها على شكل حروف صغيرة ‪.‬‬
‫إن أي متحول ال يعطي قيمة ابتدائية يمكن أن يكون له قيمة ما ال يعرف عنها شيء‬ ‫‪.3‬‬
‫مخزنة مسبقا ً في موضع الذاكرة المخصص لهذا المتحول ‪ ،‬وبالتالي إن عدم إعطاء‬
‫متحول حساب مجموع مثل ‪ SUM‬أو عداد مثل ‪ I‬سوف يؤدي إلى الحصول على‬
‫نتائج قد تكون خاطئة ‪.‬‬
‫‪) C ++‬‬

‫ولها الشكل العام التالي ‪:‬‬ ‫‪ o‬أ – البنية التكرارية ‪: do /while‬‬
‫) شروط ‪do ( 1‬‬

‫{‬
‫;تعليمات‪1‬‬
‫;تعليمات‪2‬‬
‫}‬
‫( شروط ) ‪While‬‬
‫‪) C ++‬‬
‫متال ‪: 1‬‬
‫نفس المتال السابق ـ أكتب برنامج لطباعة األعداد من ‪ 1-10‬بشكل‬
‫عمود واحد ولكن باستخدام ‪DO / WHILE :‬‬
) C ++
# include <iostream.h>
main()
{
int i =1;
do {
cout <<i<<"\n";
i=i+1;
} while ( i <=10);
return 0;
}
‫‪) C ++‬‬

‫أ – البنية التكرارية ‪ : for‬ولها الشكل العام التالي ‪:‬‬ ‫‪o‬‬
‫) ‪for ( exp 1; exp 2; exp 3‬‬

‫{‬
‫; تعليمة‪1‬‬
‫; تعليمة‪2‬‬
‫}‬
‫‪) C ++‬‬
‫متال ‪: 1‬‬
‫أكتب برنامج لحساب مجموع جميع األعداد الصحيحة‬
‫من ‪ 2‬إلى ‪. 100‬‬
) C ++
man ( )
{
int sum = 0 ;
for ( int i = 2 ; i < = 100 ; i = i +1)
sum = sum + i ;
cout << " sum is " << sum ;
return 0 ;
}
‫‪) C ++‬‬
‫متال ‪: 2‬‬
‫أكتب برنامج يلخص نتائج امتحان ملادة ملا لعشلرة طلالب‬
‫وذلك بعد أن أعطيت قائمة بأسماء الطلالب ومقابلل كلل‬
‫اسم تم وضلع القيملة ‪ 1‬إذا كلان الطاللب نلاجن والقيملة‬
‫‪0‬إذا كان الطالب راسب في االمتحان ‪.‬‬
) C ++
main ( ) {
int r , p, f ;
p=0;f=0;
for ( int i = 1 ; i < = 10 ; i ++ )
{
cout << " enter result : "; cin >> r ;
if ( r = = 1 )
p = p+1 ;
else
f=f+ 1 ;
}
cout << " passed : " <<p <<"\n" ;
cout << " failed : ' << f << "\n" ;
return 0 ; }
‫‪) C ++‬‬
‫عمليات اإلسناد ‪:‬‬
‫يتوفر في لغة ‪ ++C‬عدداً في من عمليات اإلسناد‬
‫المختصرة التي هي تعبير على عملية اإلسناد‬
‫نفسها‪ ،‬فعلى سبيل المثال يمكن اختصار التعليمية‬
‫التالية ‪:‬‬
‫;‪c=c+3‬‬
‫لتصبح بالشكل التالي‪:‬‬
‫;‪c+=3‬‬
‫حيث نسمي العملية ‪=+‬بعملية اإلسناد والجمع‬
‫‪addition assignment operator‬‬
‫وبين الجدول التالي عمليات اإلسناد الحسابية مع أمثلة‬
‫وشروح لها ‪.‬‬
‫‪) C ++‬‬
‫عمليات اإلسناد ‪:‬‬
‫الشرح‬ ‫مثال‬ ‫عملية اإلسناد‬

‫‪c=c+10‬‬ ‫‪c+=10‬‬ ‫=‪+‬‬
‫‪c=c-10‬‬ ‫‪c-=10‬‬ ‫=‪-‬‬
‫‪c=c*10‬‬ ‫‪c*=10‬‬ ‫=*‬
‫‪c=c/10‬‬ ‫‪c/=10‬‬ ‫=‪/‬‬
‫‪c=c%10‬‬ ‫‪c%=10‬‬ ‫=‪%‬‬
‫‪) C ++‬‬
‫عمليات الزيادة بواحد واإلنقاص بواحد ‪:‬‬
‫يتوفر أيضاً في لغة ‪ ++c‬عملية الزيادة بواحد األحادية )‪(++‬‬
‫وعملية اإلنقاص بواحد األحادية )‪ (--‬كما بالجدول التالي ‪:‬‬
‫الشرح‬ ‫مثال‬ ‫التسمية‬ ‫العملية‬
‫زيادة قيمة ‪ a‬بواحد ثم استخدام القيمة‬ ‫عملية الزيادة بواحد أمامية ‪++ a‬‬ ‫‪++‬‬
‫الجديدة‬
‫زيادة قيمة ‪ a‬بواحد بعد استخدام القيمة‬ ‫‪a++‬‬ ‫عملية الزيادة بواحد خلفية‬ ‫‪++‬‬
‫القديمة‬
‫إنقاص قيمة ‪ b‬بواحد ثم استخدام القيمة‬ ‫‪--b‬‬ ‫عملية إنقاص بواحد أمامية‬ ‫‪--‬‬
‫الجديدة‬
‫إنقاص قيمة ‪ b‬بواحد بعد استخدام القيمة‬ ‫‪b--‬‬ ‫عملية إنقاص بواحد خلفية‬ ‫‪--‬‬
‫القديمة‬
) C ++
: ‫مثال توضيحي‬
main () {
int c ;
c = 3;
cout << c << "\n" ;
cout << c ++ <<"\n" ;
cout << c << " \n" ;
cout << “***************” << " \n" ;
c = 3;
cout << c << "\n" ;
cout <<++ c <<"\n" ;
cout << c << " \n" ;
return 0; }
‫‪) C ++‬‬
‫وتكون نتائج هذا البرنامج هي ‪:‬‬
‫‪3‬‬
‫‪3‬‬
‫‪4‬‬
‫***************‬
‫‪3‬‬
‫‪4‬‬
‫‪4‬‬
‫‪) C ++‬‬
‫‪ o‬ج – البنية االختيار المتعدد ‪ : switch‬ولها الشكل العام التالي ‪:‬‬
‫) شروط( ‪switch‬‬
‫{‬
‫; تعليمة‪ : 1‬تابت‪case 1‬‬
‫‪.‬‬
‫‪.‬‬
‫; تعليمة ‪ : n‬تابت ‪case n‬‬
‫; تعليمة ‪default : 0‬‬
‫}‬
‫‪) C ++‬‬
‫متال ‪: 1‬‬
‫أكتللب برنللامج إلعطللاء اسللم اليللوم مللن أيللام األسللبوع عنللد‬
‫إعطاء رقمه ‪.‬‬
)# include
C ++< iostream.h>
main () {
int c ;
cout << "enter number : " ;
cin >> c ;
switch (c ) {
case 1 : { cout << " saturday " ; break ; }
case 2 : { cout << " sunday " ; break ; }
case 3 : { cout << " monday " ; break ; }
case 4 : { cout << " tuesday " ; break ; }
case 5 : { cout << " wednesday " ; break ; }
case 6 : { cout << " thursday " ; break ; }
case 7 : { cout << " friday " ; break ; }
default : { cout << " that number is out of range " ; }
}
return 0 ; }
‫‪) C ++‬‬
‫متال ‪: 2‬‬
‫أكتللب برنللامج يقلللوم بقللراءة عللددين وملللن تللم يعطللي نلللاج‬
‫جمعها وطرحهما وضربهما مستخدما ً لعرض ذلك شاشلة‬
‫خيارات ‪.‬‬
) C ++
main ( )
{
int n , x, y ;
cout << "1: ‫; " جمع العددين‬ cout <<"\n";
cout << "2 : ‫ ; " طرح العددين‬cout <<"\n";
cout <<3: ‫; "ضرب العددين‬ cout <<"\n";
cout << "******************" ; cout <<"\n";
cout << " ‫ ; " أدخل العدد األول‬cin >>x; cout <<"\n";
cout << " ‫ ; " أدخل العدد الثاني‬cin >> y ; cout <<"\n";
cout << "‫ ; " أدخل رقم الخيار‬cin >> n ; cout << "\n";
while ( n!=0) ‫تا بع المثال‬
) C ++
{
switch ( n )
{
case 1:
{ cout << x+y ; break ; }
case 2:
{ cout << x-y ; break ; }
case 3 :
( cout << x*y; break; }
default :
{ cout << " ‫; "الرجاء إدخال أحد أرقام الخيارات المتاحة‬
cin>>n;}
}
}
return 0; }
‫‪) C ++‬‬
‫متال ‪: 3‬‬
‫أكتب برنامج لقراءة تالث أعداد ‪ A, B, C‬تم التحقق‬
‫هل تصلن هذه األضالع ألن تكون أضالع متلث أم ال‬
‫‪ ،‬وبمعنى آخر هل يمكن أن نجد متلث أطوال أضالعه‬
‫هي ‪A, B, C .‬‬
‫‪) C ++‬‬
‫حل المتال ‪: 3‬‬
‫>‪# include < iostream.h‬‬
‫>‪# include < math.h‬‬
‫الملف الرأسي الحاوي على جميع التوابع الرياضية وتم‪//‬‬
‫)‪// int abs (int‬‬ ‫استخدامه من أجل التابع‬
‫) ( ‪main‬‬
‫{‬
‫; ‪int a , b, c‬‬
‫; ‪cout << " a : " ; cin >> a‬‬
‫; ‪cout << " b : " ; cin >> b‬‬
‫; ‪cout << " c : " ; cin >> c‬‬
‫تا بع المثال‬
‫)‪( n!=0‬‬
) C ++
if ((a+b>c) && (abs(a-b)<c)&&(b+c>a)&&(abs(b-c)<a) &&(a+c>b) && (abs (a-c)<b))

cout << " triangle " ;
else
cout << " not triangle " ;
return 0;
}
‫‪) C ++‬‬
‫متال ‪: 4‬‬
‫أكتب برنامج لحساب ! ‪N‬‬
) C ++
main ( ) {
Int n ;
double fact = 1 ;
cout << " enter value n: " ; cin >> n;
if ( n = = 0 )
cout << " n! = 1;
else
{
for ( int i = 1 ; i < = n ; i ++) // i++ ‫ هي نفس‬i=i+1
fact=fact * i ;
cout << " n ! = " << fact ;
}
return 0 ; }
‫‪) C ++‬‬
‫متال ‪( : 5‬برنامج إيجاد قواسم عدد ‪) X‬‬

‫الحل ‪ :‬إذا فرضنا أن العدد ‪ 30 = X‬فإنا نختبر األعداد التي قبل ‪X‬بحيث إذا‬
‫كان باقي القسمة عليها يساوي الصفر عندئذ يكون العدد قاسما للعدد ‪X‬‬
) C ++
# include < iostream . h >

main ()
{
int x ;
cout << " enter number : " ; cin >> x ;
for ( int i = 1 ; i < =x ; i ++)
if ( x % i = = 0 )
cout << i << " \n";
return 0 ;
}
‫‪) C ++‬‬
‫متال ‪: 6‬‬
‫(برنامج يقوم بقراءة عدد ما ‪ X‬ومن تم يحدد هل هذا العدد أولي أم ال )‬
‫ال يوجد في لغة الـ ‪ C++‬نمط بولياني لذلك ننشئ نمط من خالل النمط‬
‫التعدادي ‪ENUM.‬‬
‫لحل هذه المسألة يلزمنا متحول اختبار ‪F‬من نوع ‪BOOLEAN‬ففي‬
‫البداية نسند القيمة ‪ FALSE‬إلى هذا المتحول أي نفرض أن العدد ليس‬
‫أولي ‪ ،‬ومن ثم نبحث هل هناك عدد يقسم ‪ X‬وفي حال وجوده نسند لـ ‪F‬‬
‫القيمة ‪ TRUE .‬وفي النهاية نختبر قيمة المتحول ‪F‬وأعتمادا ً عليه نحدد‬
) C ++
# include < iosteam.h >
enum boolean {true, false }; // ‫التصريح عن نمط تعدادي‬
main ( ) {
boolean f = false ;
int x ;
cout <<' enter number: " ; cin >> x ;
for ( int i = 2 ; i <x ; i ++)
if ( x % i = = 0 )
f = true ;
if ( f = = false )
cout << " the x number is primary " ;
else
cout << " the x numbe is not primary " ;
return 0 ; }
‫‪) C ++‬‬
‫متال ‪: 7‬‬
‫أكتب برنامج لحساب الحدود العشرة األولى لهذه السلسة ‪:‬‬
‫‪1 1 1 1‬‬
‫‪z  1      .....................................‬‬
‫‪1 2 3 4‬‬
) C ++

# include < math.h>
main ( )
{
int n ;
float z = 1;
cout << " enter n: ' ; cin >> n;
for ( int i = 1 ; i <n ; i ++ )
if ( i % 2 = = 0 )
‫‪) C ++‬‬
‫حل المتال ‪: 7‬‬
‫; )‪z+= pow(i , -1‬‬ ‫تابع الرفع لقوة ويوجد في الملف ‪// math‬‬
‫‪else‬‬
‫; ) ‪z-=pow (i , -1‬‬
‫; ‪cout << " z = " << z‬‬
‫}‬
‫‪) C ++‬‬
‫متال ‪: 8‬‬
‫برنامج أكتب برنامج إليجاد القاسم المشترك األعظم لعددين وذلك‬
‫باستخدام طريقة إقليدس التي تتلخص كما يلي ‪ :‬أقوم بطرح العدد‬
‫األصللغر مللن العللدد األكبللر وأجعللل حاصللل الطللرح مكللان األكبللر حتللى‬
‫تصبن‬
‫القيمتين متساويتين فتكون قيمة التساوي هذه هي القاسم المشترك‬
‫‪20‬‬ ‫‪15‬‬
‫األعظم ‪GCD .‬‬
‫‪5‬‬ ‫‪15‬‬ ‫مثال ‪ :‬العددين ‪ 15‬و ‪20‬‬
‫‪5‬‬ ‫‪10‬‬
‫‪5‬‬ ‫‪5‬‬
) C ++
#include < iostream.h>
main ( ) {
int x , y ;
cout << "enter x : " ; cin >> x ;
cout << " enter y : " ; cin >> y;
while ( x! = y )
{
if ( x > y )
x-=y;
else
y-=x;
}
cout << " the gcd is " << x ;
return 0 ; }
‫‪) C ++‬‬
‫متال ‪: 9‬‬
‫أكتب برنلامج لقلراءة ‪ N‬علدد تلم حسلاب مجملوع هلذه األعلداد ومتوسلطها‬
‫وأكبر وأصغر عدد فيها ‪:‬‬
‫مالحظة ‪ :‬دائما ً لحساب أكبر أو أصغر عدد من بين مجموعلة أعلداد ‪ ،‬نفلرض‬
‫أن العلدد األول هللو الكبيلر تللم نختبلر بللاقي األعلداد وكلمللا ظهلر عللدد أكب لر‬
‫جديد نجعله هلو العلدد األكبلر ‪ ،‬وهكلذا حتلى تنتهلي مجموعلة األعلداد ‪) .‬‬
‫بالنسبة للعدد األكبر )‬
) C ++
main ( ) {
int n , x , sum , max , min ;
cout << " enter n : " ; cin >> n;
cout << " enter the first number : " ; cin >> x ;
sum = x ; min = x ; max = x ;
for ( int i = 2 ; i < = n ; i ++)
{
cout << " enter number : " ; cin >> x ;
sum = sum+x ;
if ( x > max ) max = x ;
if ( x < min ) min = x ;
}
) C ++
}
cout << " sum is " << sum << "\n" ;
cout << " avg is " << ( float ) sum /n << "\n" ;
cout << " max is " << max << " \n" ;
cout << " min is " << min << "\n" ;
return 0 ; }
‫‪) C ++‬‬
‫متال ‪: 10‬‬
‫أكتب برنامج لقراءة عدد ما والتحقق فيما إذا كان عدم تام أم ال ‪.‬‬
‫الحل ‪:‬‬
‫نقول عن عدد ما أنه عدد تام إذا كان مجموع قواسم هذا العدد (ما عدا‬
‫العدد نفسه ) يساوي العدد نفسه ‪.‬‬
‫متال ‪ :‬العدد ‪ 6‬هو عدد تام ألن مجموع قواسم العدد ‪ 6‬تساوي‬
‫= )‪(06‬‬
‫)‪( 1+2+3=6‬‬
) C ++
# include <iostream.h>
main ( ) {
int x ;
int sum = 0 ;
cin>> x ;
for ( int i = 1 ; i < x ; i ++)
if ( x % i = = 0 )
sum + = i ;
if ( sum = = x )
cout << " perfect " ;
else
cout << " not perfect " ;
return 0 ; }
‫‪) C ++‬‬
‫متال ‪: 11‬‬
‫أكتب برنامج إليجاد جميع األعداد التامة ضمن مجال ]‪[N..1‬‬
) C ++
main ( ) {
int n , sum = 0 ;
cin>>n ;
for ( int i = 1 ; i <=n ; i ++ )
{
for ( int j = 1 ; j < i ; j++)
if ( i % j = = 0 )
sum + = j ;
if ( sum = = i )
cout << " " <<i << endl;
sum = 0 ;
}
return 0; }
‫‪) C ++‬‬
‫متال ‪: 12‬‬
‫أكتب برنامج إليجاد المضاعف المشترك األصغر لعددين ‪:‬‬
) C ++
main ( )
{
int x , y ;
cout << " x = " ; cin >> x;
cout << " y = " ; cin >> y ;
if ( x > = y)
{
for ( int j = x ; j < x ; j++)
if ( j % x = = 0 ) && ( j % y = = 0 )
{ cout <<j ; break ; }
}
) C ++
else
{
for ( int j = y ; j < x *y; j++)
if (( j% x = = 0) && ( j % y = = 0 ))
{ cout << " " << j ; break ; }
}
return 0 ;
}
‫‪) C ++‬‬
‫متال ‪: 13‬‬
‫أكتب أكتب برنامج لقراءة عددين والتحقق فيما إذا كانا عددين‬
‫صديقين أم ال ‪.‬‬
‫الحل ‪ :‬نقول عن عددين أنهما صديقين إذا كان مجموع قواسم العدد األول (‬
‫ما عدا العدد نفسه ) يساوي العدد التاني والعكس بالعكس ‪.‬‬
) C ++
# include<iostream.h>
main ( ) {
int x , y , i ;
int sum 1 = 0 , sum 2=0
cout <<"x="; cin>>x;
cout <<" y=" ; cin >> y;
for ( i = 1 ; i < x ; i ++ )
if ( x % i = = 0 )
sum 1 + = i ;
for ( i = 1 ; i < y ; i ++)
if ( y % i = = 0 )
sum 2 + = i ;
if ( sum 1 = = y && sum 2 = = x )
cout <<x<<" friend " <<y;
else
cout << x << " not friend " << y;
reterun 0 ; }
‫‪) C ++‬‬ ‫المصفوفات‬
‫المصفوفة هي عبارة عن مجموعة من خانات الذاكرة المتتالية‬
‫التي لها نفس االسم ونفس النمط‪.‬‬
‫والشكل التالي يمثل مصفوفة من اإلعداد الصححيحة التحي أسحمها ‪A‬‬
‫وهي تتضمن أربعة عناصر ‪.‬‬
‫اسم المصفوفة ) لجميع العناصر نفس االسم ( ‪A‬‬
‫‪A[0] =5‬‬
‫‪A[1] =13‬‬
‫‪A[2] =-15‬‬
‫‪A[3]= 78‬‬
‫رقم موضع العنصر من عناصر المصفوفة‬

‫التصريح عن المصفوفات ‪) C ++ :‬‬
‫المصفوفات ذات البعد الواحد ‪.:‬‬
‫الشكل العام التالي‪:‬‬
‫] عدد عناصر المصفوفة [ اسم المصفوفة نمط معطيات المصفوفة‬
‫]‪int A [5‬‬ ‫مثال ً ‪:‬‬
‫]‪........، char y [100] ، float x [100‬‬
)‫مصفوفة‬
C ++ ‫أكتب برنامج يقوم بطباعة عناصر‬
# include < iostream.h >
main()
}
int a[5]={10,2,12,30,67} ;
for (int i =0; i<5 ;i++)
cout <<"a["<<i<<" ]= "<<a[i]<<"\ n ";
return 0;
{
‫‪) C ++‬‬ ‫مالحظات ‪:‬‬
‫‪1‬ـ يسبب التصريح التالي‬
‫;}‪int[5] ={1,2,34,56,24,1‬‬
‫خطاً قوا عديا ألننا أعطينا ستة قيم لمصفوفة‬
‫مؤلفة من خمس عناصر فقط ‪.‬‬
‫‪ 2‬ـ يسبب التصريح التالي ‪:‬‬
‫;}‪int n[5]={1,2,9,5‬‬
‫إعطاء قيمة الصفر للعنصر الخامس من قبل المترجم‬
‫‪.‬‬
) C ++
.‫ اكتب برنامج لطباعة عناصر مصفوفة‬:‫مثال‬
# include< iostream.h>
main( ) {
const int arrasize = 10 ;
int a [arrasize];
for (int i=0 ;i<arrasize ; i++)
{
a[i]=2+2*i;
cout<<a[i]<<"\n";
}
return 0; }
) C ++
.‫ اكتب برنامج لطباعة عناصر مصفوفة‬:‫مثال‬
# include< iostream.h>
main( ) {
const int arrasize = 10 ;
int a [arrasize];
for (int i=0 ;i<arrasize ; i++)
{
a[i]=2+2*i;
cout<<a[i]<<"\n";
}
return 0; }
)‫ثم‬C‫واحد‬
++‫صف ذو بعد‬ ‫ اكتب برنامج لقراءة‬:‫مثال‬
. ‫طباعته على الشا شة‬
#include iostream.h
#include iomanip.h
main ( ) {
const int size =5
int a[size ]
for ( int i = 0 ; i  size ; i++ )
Cin>>a[i] 
for ( int i = 0 ; i  size ; i++ )
Cout<<''a[''i'']=''a[i] setw(5)
return 0 }
‫‪++‬ثم‪) C‬‬
‫مثال‪ :‬اكتب برنامج لقراءة قيم صف ذو بعد واحد‬
‫احسب مجموع ومتوسط عناصر هذا الصف باإلضافة إلى‬
‫اكبر واصغر عنصر‪.‬‬
‫‪#inlude iostream.h‬‬
‫{ ) ( ‪main‬‬
‫‪const int size =3‬‬
‫) ‪for ( int I = 0 :  size : i++‬‬
‫‪{ cout ''a[''i'']=“ ‬‬
‫‪cina[i]‬‬
‫}‬
‫‪int sum= 0,max =a[0],min=a[0]‬‬
‫)‪for(i=0isizei++‬‬
) C ++
: ‫تابع الحل‬
{ sum+=a[i]
if(maxa[i]) max=a[i]
if(mina[i]) min=a[i]
}
cout''sum is:''sum endl
coutaverage is: '' sum/size  endI
cout ''max is:''maxendl
cout''min is :''min endl
retum 0 }
) ‫ثم‬ ++ ‫اكتب برنامج لقراءة قيم مصفوفة ذات‬:‫مثال‬
C ‫بعدين‬
‫أطبع هذه القيم حسب الشكل الرياضي المتعارف علية‬
#inlude iostream.h
#inlude iomanip.h
main ( )
const int size 1=3
const int size 2=4
int a[size1][size2]
for(int i=0 isize1i++)
for(int j =0jsize2j++)
{ cout ''a[''i''][''j'']=''
cina[i][j] }
) C ++
: ‫تابع الحل‬
for(int i=0 isize1i++)

{
for(int j=0 jsize2 j++)
cout  setw(5) a[i][j]
coutend1
}
return 0
}
‫جامعة القدس المفتوحة‬
‫منطقة الخليل التعليمية‬
‫تركيب البيانات وتصميم الخوارزميات‬
‫‪1289‬‬
‫الوحدة السادسة‬
‫الطوابير‬
‫د‪ .‬رائد موسى عمر القواسمه‬

‫االقسام‬
‫مفاهيم ومصطلحات‬
‫الطوابير واستخداماتها وطريقة تمثيلها‬
‫تنفيذ العمليات على الطوابير‬
‫الطوابير الدائرية وصيغ أخرى للطوابير‬
‫مفاهيم ومصطلحات اساسية‬
‫القوائم المتصله ال تلبي جميع االحتياجات‬

‫الطابور تركيب خطي يسير على مبدأ اضافة العناصر الجديدة الى‬
‫نهاية القائمة وحذف العناصر من بدايتها ‪FIFO‬‬
‫‪Delete‬‬
‫‪Add‬‬
‫والطابور له عدة تطبيقات أغلبها له عالقة بأولوية المعالجة‪.‬‬
‫والدوال الرئيسية للطابور هي ‪:‬‬
‫‪ Add‬إلدخال عنصر في الطابور في نهاية الطابور‬
‫‪ Delete‬إلخراج عنصر من الطابور من بداية الطابور‬
‫والبعض يفضل إستخدام دوال فرعية أخرى مثل‪:‬‬
‫‪ IsEmpty‬وتستخدم للكشف على الطابور هل هو خالي أم ال‪.‬‬
‫وللطابور مؤشرين أحدهما لمقدمة الطابور ويسمى ‪ Front‬ويستخدم‬
‫الغراض الحذف واألخر للمؤخرة ويسمى ‪ Rear‬ويستخدم الغراض‬
‫االضافة‪.‬‬
‫تمثيل الطابور‬
‫هناك طريقتان لتمثيل الطوابير‬

‫التمثيل التتابعي (مصفوفة احادية البعد مع وجود متغيرين احدهما يشير الى البداية‬
‫واالخر يشير الى النهاية)‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪1‬‬ ‫‪K‬‬ ‫‪R‬‬ ‫‪I‬‬ ‫‪B‬‬ ‫‪y‬‬ ‫‪5‬‬

‫‪Front‬‬ ‫‪rear‬‬
‫تابع التمثيل التتابعي‬
Typedef const int myMaxQue;
myMaxQue MaxSize=30;
class MyQueue
{
Private:
int data [MaxSize];
Int FRONT,REAR;
Public:
……………….
};
‫التمثيل باستخدام القوائم المتصلة ‪:‬‬
‫‪ ‬ويقوم هذا النوع على استخدام المؤشرات ويسمح بتخزين الطابور‬
‫على شكل قائمة متصلة مفردة ومن الناحية البرمجية ال يختلف‬
‫تمثيل الطابور عن القوائم المتصلة المفردة اال في وجود ‪FRONT‬‬
‫‪& REAR‬‬
‫تابع‬
Class Qptr
{Public :
Int value;
Qptr* next;
};
Class MyQueue
{ public :
int size;
Qptr* FRONT;
Qptr* REAR;
…….
};
‫العمليات على الطوابير‬
‫انشاء الطابور‬
‫وتستخدم هذه الدالة لتهيئة الطابور لالستخدام ألول مرة‬
‫)‪Void QueueCreate(MyQueue& Q‬‬
‫مع االخذ بعين االعتبار قضية تمثيل الطابور من خالل مصفوفة او قائمة‬
‫فحص فيما اذا كان الطابور ممتلئا ”مصفوفات“‬
‫وهي دالة بولينية ترجع القيمة ‪ true‬اذا كان ممتلئ او ‪ false‬عكس ذلك‬
‫)‪Bool QueueFull(MyQueue Q‬‬
‫التحقق فيما اذ كان الطابور فارغا‬
‫ويكون في حالة ان ‪FRONT=0‬و‪REAR=0‬‬
‫عندما تتساوي عمليتي االضافة والحذف فان الطابور يصل الي مرحلى‬
‫يكون فيه خاليا‬
‫تابع‪..‬‬
‫عملية االضافة الى الطابور‬

‫وهي دالة تقوم باالضافة الى الطابور شريطة ان ال يكون الطابور‬
‫ممتلئا‬
‫;)‪Void EnQueue(MyQueue& Q, int element‬‬
‫وتتم في اتجاه واحد فقط وهو من نهاية الطابور مع مراعات اننا يمكن‬
‫ان نضيف وليس هناك متسعا او ان الطابور خالي من القيم أو انه‬
‫اليوجد متسع لالضافة في النهاية مع وجود متسع في البداية وهذا‬
‫يدفعنا الى اعادة تنظيم الطابور او انه يوجد امكانية لالضافة في‬
‫النهاية وهذا هو الطبيعي‬
‫العمليات على الطابور ‪...‬تابع‬
‫عملية الحذف من الطابور ‪Dequeue‬‬

‫وتتم الحذف في اتجاه واحد هو المقدمة ويمكن ان يكون الحذف في‬
‫الحاالت التالية‪ :‬الطابور خالي أو ليس هناك اال عنصرا واحدا أو اننا‬
‫نحذف مع وجود عناصر قيمتين او اكثر‬
‫تنفيذ العمليات على الطوابير‬
QueueCreate ‫انشاء الطابور‬

Front=Rear=0 ‫في حالة المصفوفات تكون قيمة‬
void MyQueue::QueueCreate(MyQueue& Q)
{Q.Front= 0;
Q.Rear=0;
}
Front=Rear=Null ‫اما في حالة القوائم المتصلة فان قيمة‬
void MyQueue::QueueCreate()
{Q.Front= Null;
Q.Rear=Null;
}
‫فحص فيما اذا كان الطابور ممتلئا‬
‫يتحقق ذلك عندما تكون جميع مواقع المصفوفة مستخدمة أي‬
‫‪Rear= MaxSize & Front=1‬‬
‫)‪Bool MyQueue::QueueFull(MyQueue Q‬‬
‫)‪{if(Q.Front==1 && Rear=MaxSize‬‬
‫;‪return Truu‬‬
‫‪else‬‬
‫;‪return false‬‬
‫}‬
‫في حالة لقوائم المتصلة يعتمد حجم الطابور على حجم الذاكرة‬
QueueEmpty ‫فحص فيما اذا كان الطابور فارغا‬
Rear=0 ‫ و‬Front=0 ‫يكون في حالة التمثيل التتابعي عندما تكون‬
Bool myQueue::QueueEmpty(MyQueue Q)
{if (Q.front==0 && Q.Rear==0)
return true
else return false }
Front=Rear=Null ‫اما في حالة القوائم فتكون قيمتي‬
Bool myQueue::QueueEmpty()
{if (Q.front==Null&& Q.Rear==Null)
return true
else return false }
‫الطوابير الدائرية‬
‫قد ال يكون تمثيل الطوابير كقائمة متصلة مجديا وخاصة انه يضطرنا‬
‫الى االزاحة او اعادة تنظيم القائمة والطابور الدائري يحل هذه‬
‫المشكلة‬
‫االضافة في الطوابير الدائرية‬
‫تتم االضافة في ضوء التالي‬

‫‪ ‬الطابور ممتلئ وبذلك ليس هناك امكانية لالضافة‬
‫‪ ‬الطابور فارغ وبذلك يكون العنصر المضاف هو العنصر الوحيد‬
‫‪ ‬الطابور لم يعد يسمح باالضافة الى النهاية وبذلك نتجه الى البداية‬
‫الطابور في وضعه الطبيعي وتتم االضافة في المكان المناسب‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪3‬‬ ‫‪A‬‬ ‫‪D‬‬ ‫‪E‬‬ ‫‪5‬‬

‫‪Front‬‬ ‫‪rear‬‬
‫صف الطابور بعد إجراء كل من العماليات التالية‪:‬‬

‫إلى الطابور‪C.‬إضافة الرمز‬
‫حذف رمزين من الطابور‪.‬‬
‫إلى الطابور‪X,Y,Z.‬إضافة الرموز‬
‫حذف رمزين من الطابور‪.‬‬
‫إلى الطابور‪Q.‬إضافة الرمز‬
‫إلى الطابور ‪ C‬إضافة الرمز‬ ‫إلى الطابور الفرع ‪ X,Y,Z 3‬إضافة الرموز‬
‫الفرع ‪1‬‬
‫‪C‬‬ ‫‪X‬‬
‫حذف رمزين من الطابور‬ ‫‪6‬‬ ‫‪7‬‬

‫‪E‬‬
‫‪5‬‬ ‫‪Y‬‬
‫‪1‬‬
‫‪4‬‬
‫‪2‬‬
‫‪D‬‬
‫‪3‬‬ ‫‪Z‬‬
‫‪A‬‬ ‫‪Q‬‬
‫حذف رمزين من الطابور‬
‫شكرا إلنتباهكم والى اللقاء‬
‫بالتوفيق في االمتحان النصفي‬
‫جامعة القدس المفتوحة‬
‫منطقة الخليل التعليمية‬
‫تركيب البيانات وتصميم الخوارزميات‬
‫‪1289‬‬
‫الوحدة الرابعة‬
‫القوائم‬

‫الوحدة الرابعة ‪ :‬القوائم‬
‫القائمة كتركيبة تجريدية‬ ‫•‬

‫تمثيل القوائم وتنفيذ العمليات‬ ‫•‬
‫انواع اخرى من القوائم‬ ‫•‬
‫المصفوفات الثنائية والمتعددة االبعاد‬ ‫•‬
‫ما هي ‪Linked list‬‬
‫• هي باختصار شديد عبارة عن قائمة من البيانات مرتبطة مع‬
‫بعضها البعض وغير محدودة الحجم‪ .‬أي انك ال تحتاج‬
‫للمعرفة ما عدد البيانات المراد إدخالها إلى القائمة‬
‫أهمية ‪Linked list‬‬
‫• البد أنك استخدمت المصفوفات في العديد من برامجك‬
‫وتجاربك‪ ,‬وكلما تعرف مصفوفة تحتاج للوضع حدود‬
‫المصفوفة ‪.‬‬
‫ولكن‪ ,‬ماذا لو احتجت أو احتاج مستخدم البرنامج أن يضيف‬

‫عدد من البيانات يزيد عن حجم المصفوفة ؟ !!‪.‬‬
‫• ولكن باستخدامك ‪ linked list‬سوف يزيل عنك هم هذه‬
‫المشكلة وتدخل البيانات كما يحلو لك‬
Single Linked List :‫الصيغة العامة للـ‬
• struct My_List_Name
{
// My Data : int, float, char, ... ect
// This is the pointer to next node

struct My_List_Name *next;
};
‫وهذا سوف نستخدمه للتعامل مع القائمة من خالل الدالة‬ ‫•‬
‫الرئيسية في البرنامج‪.‬وهذا الشكل مثال على كيفية تخزين‬
‫العناصر في الذاكرة و الربط بينها ‪:‬‬
‫بعض العمليات في‪Single linked list:‬‬
‫• هنا سوف نتطرق إلى بعض العمليات المستخدمة في ‪Single‬‬
‫‪ linked list ,‬وهي عبارة عن دوال‪ .‬أهم نقطة هنا أن تفهم‬
‫هذه العمليات (الدوال) لكي تستطيع أن تعدلها بما يناسب‬
‫مشاريعك‪.‬‬
‫إضافة عناصر إلى القائمة‪:-‬‬
‫• عند إضافة عنصر ‪ ,‬نتبع آالتي‪:‬‬
‫أوال ‪ :‬نضع بيانات التركيب‬
‫ثنايا ‪ :‬إذا كان هناك عنصر آخر نشئ تركيب جديد في الذاكرة‬
‫بواسطة كلمة ‪ new‬ونسند عنوان ذلك التركيب إلى المؤشر‬
‫‪ next‬في العنصر الحالي‪.‬‬
‫ثالثا ‪ :‬إما إذا كان العنصر الحالي آخر عنصر في القائمة‪ ,‬نسند‬
‫للمؤشر ‪ next‬قيمة ‪NULL‬‬
• // Create List nodes
‫مثال على االضافة‬
void createlist(node *p)
{
int data;
for( ; ; )
{
cout<<"Enter Number or zero to stop: ";
cin>>data;
if (data == 0)
{
p->next = NULL;
break;
}
else
{
p->num = data;
p->next = new node;
p = p->next;
}
}
}
‫{ •‬
‫;‪p->num = data‬‬
‫;‪p->next = new node‬‬
‫;‪p = p->next‬‬
‫}‬
‫;‪p->num = data‬‬
‫نسند العدد المدخل (‪ ) data‬للعضو ‪ . num‬الحظ أننا استخدمنا المعامل السهم (‪ )>-‬بدال من ( ‪ ) .‬ألننا نتعامل‬ ‫•‬
‫مع مؤشر للتركيب وليس متغير أو كائن من التركيب ‪.‬‬
‫;‪• p->next = new node‬‬
‫• وبعد ذلك ‪ ,‬أنشأنا تركيب جديد في الذاكرة )‪ (new node‬و أسندنا عنوانه في‬
‫الذاكرة إلى المؤشر ‪ next .‬اآلن أصبح‬
‫لدينا عنصر مرتبط مع األخر بواسطة المؤشر ‪next .‬‬
‫اآلن نريد أن ننتقإللى العنصر الجديد لكي يتم إضافة مدخالته‪ ,‬نقوم بعملية التحرك‬
‫هكذا‪:‬‬
‫;‪• p = p->next‬‬
‫• هنا يتحرك مؤشر التركيب إلى العنصر التالي وذلك بإسناد عنوان العنصر الجديد‬
‫للمؤشر ‪ p‬الذي تم تخزينه في المؤشر ‪. next‬الحظ أن العنصر الجديد فارغ أي ال‬
‫لم يدخله له أي بيانات أو عنوان عنصر آخر‪ .‬اآلن المؤشر ‪ p‬واقف في آخر‬
‫عنصر تم إنشاءه (العنصر الفارغ‬
‫{ •‬
‫;‪p->next = NULL‬‬
‫;‪break‬‬
‫}‬
‫• هنا نسند للمؤشر ‪ next‬التابع للعنصر األخير (الفارغ) قيمة ‪ NULL‬أي انه اآلن ال‬
‫يحتوي على أي عنوان وهذا للداللة على أن هذا العنصر آخر عنصر في القائمة ‪.‬‬
‫سوف ترى فيما بعد أهميه هذه الخطوة‪ .‬ومن ثم نخرج من ‪ for loop‬و الدالة ‪.‬‬
• void main()
{
cout<<"Welcome you in Linked List lesson";
cout<<"\nPart 1: Single linked list:";
// defined pointer for structer my_list
// that value is the address of first node
node *mynodes = new node;
// create nodes in mynodes list
cout<<"\nCreate nodes in list";
createlist(mynodes);
getchr();
}
‫عرض عناصر القائمة‬
‫• اآلن سوف نقوم بعرض عناصر القائمة ‪ ,‬وهي أن نقوم‬
‫المرور على كل عنصر و طباعته بياناته‪ .‬تتم العملية كالتالي ‪:‬‬
‫أوال ‪ :‬نتحقق من العنصر هل هو آخر عنصر في القائمة أما‬
‫ال‪.‬‬
‫ثانيا ‪ :‬إذا كان العنصر ليس العنصر األخير نعرض البيانات‬
‫ونتحرك إلى العنصر الذي بعده‪.‬‬
‫ثالثا ‪ :‬إذا كان العنصر هو العنصر األخير نتوقف ‪.‬‬
• // Display all List
void display(node *p)
{
while(p->next != NULL)
{
cout<<p->num<<endl;
p = p->next;
}
}
:‫• اآلن في الدالة الرئيسية للبرنامج‬

• // Display nodes
cout<<"\nDisplay all nodes in list:\n";
display(mynodes)
‫بشكل عام‬
‫• في الحقيقة في عملية العرض أو تعداد أو البحث و ‪ ...‬الخ ‪ ,‬يجب علينا المرور‬
‫على جميع عناصر القائمة ‪ ,‬و أسلوب المرور على جميع العناصر هكذا‪:‬‬
‫‪while (p->next != NULL‬‬

‫{‬
‫‪// do what you want‬‬
‫‪// move to the next node‬‬

‫;‪p = p->next‬‬
‫}‬
‫تعداد عدد عناصر القائمة‬
‫مثل أي عملية تعداد آخرى ‪ ,‬أي نعرف عداد ومن ثم يزيد بمقدار واحد‪ .‬تتم العملية التعداد‬ ‫•‬
‫كالتالي ‪:‬‬
‫أوال ‪ :‬نتحقق من العنصر هل هو آخر عنصر في القائمة أما ال‪.‬‬
‫ثانيا ‪ :‬إذا كان العنصر ليس العنصر األخير نزيد العداد بمقدار واحد‪.‬‬
‫ثالثا ‪ :‬إذا كان العنصر هو العنصر األخير نتوقف ‪:.‬‬
‫‪• // count nodes‬‬
‫)‪int countlist(node *p‬‬
‫{‬
‫;‪int count = 0‬‬
‫)‪while(p->next !=NULL‬‬
‫{‬
‫;‪count++‬‬
‫;‪p = p->next‬‬
‫}‬
‫;‪return count‬‬
‫}‬
‫هذه الدالة تعيد قيمة من النوع ‪ integer‬و تستقبل (كالعادة) وسيط من النوع مؤشر إلى‬ ‫•‬
‫التركيب ‪. my_list‬‬
‫اآلن في الدالة الرئيسية للبرنامج‬
• // count the number of all nodes
int nodescount = countlist(mynodes);
cout<<"\nThe number of nodes in list is:
"<<nodescount;
•
‫بحث عن عنصر في القائمة‪:‬‬
‫• في هذه العملية نقوم في البحث عن عنصر من عناصر القائمة و تمم العملية كالتالي‬
‫‪:‬‬
‫أوال ‪ :‬نتحقق من العنصر هل هو آخر عنصر في القائمة أما ال‪.‬‬
‫ثانيا ‪ :‬إذا كان العنصر ليس العنصر األخير نتحقق من بيانات العنصر و بيانات‬
‫البحث‬
‫ثالثا ‪ :‬إذا كان بيانات العنصر مطابقة للبيانات البحث‪ ,‬نتوقف‬
‫رابع ‪ :‬إذا كان بيانات العنصر غير مطابقة للبيانات البحث‪ ,‬نتحرك للعنصر التالي‪.‬‬
‫خامسا ‪ :‬إذا كان العنصر هو العنصر األخير نتوقف‬
• // search for node
node *search(node *p)
{
int n;
cout<<"Enter number to search for it: ";
cin>>n;
while(p->next !=NULL )
{
if(n == p->num)
{
return p;
}
else
{
p = p->next;
}
}
return NULL;
}
‫ وتعيد عنوان في الذاكرة‬my_list ‫هذه الدالة من النوع مؤشر للتركيب‬ •
‫إلى دالة الرئيسية للبرنامج‬
• // Search for node in list
node *searchnode; // to take the address from result of search function.
searchnode = search(mynodes); // making search
if(searchnode != NULL) // check if find it or not.

{
cout<<"\nWe find it in list";
}
else
{
cout<<"\nCannot find it in list.";
}
‫إضافة في أول القائمة‬
‫• اآلن نريد إضافة عنصر جديد في أول القائمة أي أن يكون‬
‫العنصر األول‪ .‬وهذه العملية كالتالي ‪:‬‬
‫أوال ‪ :‬نقوم بإنشاء تركيب (عنصر) جديد و إضافة بياناته‪.‬‬
‫ثانيا ‪ :‬ثم نربط التركيب مع أول عنصر في القائمة‬
‫ثالثا ‪ :‬نسند للمؤشر القائمة عنوان التركيب الجديد‪.‬‬
‫اآلن نطبق هذه العملية على تركيب ‪: my_list‬‬

‫كود‬
• // Insert at beging of list
node *insertatbeging(node *p)
{
node *newnode = new node;
cout<<"\nENter number";
cin>> newnode->num;
newnode->next = p;
return newnode;
}
‫في البرنامج الرئيسي‬
// Insert new node in beging of list
mynodes = insertatbeging(mynodes);
‫إضافة عنصر في مكان محدد في القائمة ‪:‬‬
‫لقد شاهدنا كيفية اإلضافة في بداية القائمة ‪ ,‬اآلن سوف نرى كيفية إضافة عنصر جديد يتم تحديد مكانه من قبل‬ ‫•‬
‫المستخدم ‪,‬أي إذا كانت لدينا هذه العناصر ‪:‬‬
‫‪4– 3– 2– 1‬‬
‫واردنا إضافة عنصر جديد ولنقل (‪ ) 5‬في الموقع هو العنصر (‪ ) 3‬سوف يتم إضافة (‪ ) 5‬بعد (‪ ) 3‬لكي تشكل‬
‫هذه القائمة ‪:‬‬
‫‪4– 5– 3– 2– 1‬‬
‫وتتم العملية كالتالي ‪:‬‬

‫أوال ‪ :‬إدخال موقع للعنصر الجديد‬
‫ثانيا ‪ :‬التحقق من وجود الموقع في القائمة أم ال‬
‫ثالثا ‪ :‬إذا كان الموقع موجود ‪ ,‬ننشئ عنصر جديد ونضع بياناته‬
‫رابع ‪ :‬نربط الموقع مع العنصر الجديد و نربط العنصر الجديد مع العنصر الذي كان بعد الموقع‬
• // inserat at location
void insertatloc(node *p)
{
int n,loc;
node *locadd, *newnode, *temp;
cout<<"\nEnter location: ";
cin>>loc;
locadd = NULL;
while(p->next !=NULL)
{
if(p->num == loc)
{
locadd = p;
break;
}
p = p->next;
}
if(locadd == NULL)
{
cout<<"\nCannot find the location";
}
else
{
cout<<"\nEnter new number: ";
cin>>n;
newnode = new node;
newnode->num = n;
temp = locadd->next;
locadd->next = newnode;
newnode->next = temp;
}
}
‫;‪• int n,loc‬‬
‫• هنا عرفنا المتغيرين من النوع ‪ integer ,‬المتغير ‪ n‬نستخدمه فيما بعد لقراءة‬
‫الرقم الجديد‪ ,‬أما ‪ loc‬فهو للقراءة الموقع الذي يريد إضافة العنصر الجديد‬
‫‪ C++‬كود‬
‫;‪• node *locadd, *newnode, *temp‬‬
‫• هنا عرفنا ثالث مؤشرات للتركيب ‪ my_list ,‬المؤشر ‪ locadd‬سوف يحتوي‬
‫على عنوان الموقع ‪ ,‬و ‪ newnode‬و ‪ temp‬ستخدم فيما بعد‪.‬‬
‫;" ‪• cout<<"\nEnter location:‬‬
‫;‪cin>>loc‬‬
‫;‪locadd = NULL‬‬
‫• نقرأ الموقع المرغوب ومن ثم نسند ‪ NULL‬للمؤشر ‪locadd‬‬

‫وذلك لتحقق من الموقع‪.‬‬
‫)‪• while(p->next !=NULL‬‬
‫{‬
‫)‪if(p->num == loc‬‬
‫{‬
‫;‪locadd = p‬‬
‫;‪break‬‬
‫}‬
‫;‪p = p->next‬‬
‫}‬
‫• اآلن ندخل في تكرار للمرور على جميع العناصر ‪ ,‬نتحقق من الموقع المدخل هل‬
‫هو موجود أما ال ‪ ,‬إذا كان الموقع صحيح نسند عنوان الموقع إلى المؤشر‬
‫‪ locadd‬ومن ثم نخرج من التكرار‪ ,‬إذا لم يتحقق الشرط نتحرك للعنصر التالي‪.‬‬
‫)‪• if(locadd == NULL‬‬
‫{‬
‫;"‪cout<<"\nCannot find the location‬‬
‫}‬
‫هذه الجملة الشرطية تحقق في إذا تم إيجاد الموقع في القائمة أما ال ‪ ,‬إذا لم يتم إيجاده سوف تكون قيمة‬ ‫•‬
‫‪locadd‬‬
‫كما هي قبل دخوله التكرار وهي ‪ NULL‬ونعرض للمستخدم بأن الموقع المدخل غير صحيح‪.‬‬
‫‪• else‬‬
‫{‬
‫;" ‪cout<<"\nEnter new number:‬‬
‫;‪cin>>n‬‬
‫;‪newnode = new node‬‬
‫;‪newnode->num = n‬‬
‫;‪temp = locadd->next‬‬
‫;‪locadd->next = newnode‬‬
‫;‪newnode->next = temp‬‬
‫}‬
‫إذا كان الموقع صحيحا سوف نشئ عنصر جديد ووضع بياناته كما هو الوضع في األسطر األربع أولى‪ .‬وبعد‬ ‫•‬
‫ذلك نقوم‬
‫بعملية أبدالية في العناوين‪:‬‬
‫‪ 1 -‬نقوم بإسناد قيمة المؤشر ‪ next‬للموقع للمؤشر ‪ temp‬للحفاظ عليه مؤقتا‪.‬‬
‫‪ 2 -‬بعد ذلك نسند للمؤشر ‪ next‬للموقع بعنوان العنصر الجديد ‪.‬‬
‫‪ 3 -‬وبعد ذلك نسند للمؤشر ‪ next‬للعنصر الجديد قيمة المؤشر ‪ temp‬والتي هي عنوان العنصر الذي كان‬
‫التالي بعد الموقع ليكون العنصر التالي بعد العنصر الجديد‬
•
• ‫نضيف في الدالة الرئيسية للبرنامج‬
// insert node in location

insertatloc(mynodes);
‫حذف عنصر من القائمة‬
‫• بعد ما تطرقنا من عمليات اإلضافة‪ ,‬سوف نتكلم اآلن عن كيفية حذف عنصر محدد من القائمة‪.‬‬
‫والعملية كالتالي ‪:‬‬
‫أوال ‪ :‬تحديد العنصر المراد حذفه‪.‬‬

‫ثانيا ‪ :‬التحقق من وجود العنصر في القائمة‬
‫ثالثا ‪ :‬إذا كان العنصر موجود‪ ,‬التحقق هل هو أول عنصر في القائمة أم ال‪.‬‬
‫رابعا ‪ :‬إذا كان العنصر هو األول ‪ ,‬نقوم بإسناد للمؤشر القائمة بعنوان العنصر الثاني في القائمة‪.‬‬
‫خامسا ‪ :‬إذا كان العنصر ليس هو األول ‪ ,‬نقوم ربط العنصر السابق له مع العنصر الذي بعده‪ ,‬ومن‬
‫ثم حذفه‬
• // remove node
node *remove(node *p)
{
int n;
node *temp, *s;
s = p;
cout<<"\nEnter to delete it: ";
in>>n;
while(p->next != NULL)
{
if(p->num == n)
{
if(p == s)
{
return p->next;
}
else
{
temp->next = p->next;
delete p;
return s;
}
}
temp = p;
p = p->next;
}
return s;
}
‫• كما تالحظ أن الدالة مثل دالة اإلضافة في أول القائمة من ناحية النوع الدالة و‬
‫الوسائط‪ .‬في السطر األول كالعادة تعريف متغير لقراء الرقم من المستخدم‪ .‬و‬
‫السطر التالي قمنا بتعريف مؤشرين وهما ‪ s‬و ‪. temp‬‬
‫;‪• s = p‬‬
‫• هنا أسندنا للمؤشر ‪ s‬قيمة المؤشر ‪ p‬والتي هي اآلن عنوان أول عنصر في‬
‫القائمة‪.‬‬
‫اآلن بعد قراءة القيمة المراد حذفها من القائمة و الدخول إلى تكرار المرور‬
‫على جميع العناصر‬
‫)‪if(p->num == n‬‬
‫• هذه الجملة الشرطية للتحقق هل القيمة المدخلة هي قيمة العنصر الحالي‪.‬‬
‫•‬
‫)‪if(p == s‬‬
‫{‬
‫;‪return p->next‬‬
‫}‬
‫•‬
‫إذا كان العنصر الحالي هو المراد حذفه‪ ,‬هذه الجملة الشرطية تتحقق هل هذا العنصر هو‬
‫العنصر األول من القائمة أم ال‬
‫(تذكر أننا وضعنا عنوان العنصر األول للمؤشر ‪ s‬قبل قليل) ‪ .‬إذا كان صحيحا ‪ ,‬نعيد‬
‫عنوان العنصر الثاني للمؤشر القائمة المستدعي للدالة‪.‬‬
‫‪• else‬‬
‫{‬
‫;‪temp->next = p->next‬‬
‫;‪delete p‬‬
‫;‪return s‬‬
‫}‬
‫إذا كان العنصر ليس هو العنصر األول‪ ,‬سوف نسند للمؤشر ‪ next‬التابع للعنصر السابق‬ ‫•‬
‫الذي يحمل عنوانه المؤشر‬
‫( ‪ temp‬سترى كيف تم اسندنا للمؤشر ‪ temp‬عنوان العنصر السابق للعنصر الحالي بعد‬
‫قليل)‪ .‬بعد ذلك نحذف العنصر‬
‫الحالي بواسطة الكلمة المحجوزة ‪ delete‬التي تحذفه من الذاكر ه‪ .‬وأخيرا نعيد عنوان‬
‫العنصر األول للمؤشر القائمة‬
‫المحدثة (أي بعد تم عملية الحذف‪).‬‬
‫;‪• temp = p‬‬
‫;‪p = p->next‬‬
‫• إذا لم يكن العنصر الحالي هو العنصر الذي نريد حذفه ‪,‬نسند للمؤشر ‪temp‬‬
‫عنوان العنصر الحالي ليكون في الدورة‬
‫القادمة من التكرار العنصر السابق (كما رأيت سابقا)‪ .‬وبعد ذلك نتحرك إلى‬
‫العنصر التالي‪.‬‬
‫;‪• return s‬‬

‫• إذا لم نجد العنصر في القائمة سوف نعيد عنوان العنصر األول و كأن لم يحدث‬
‫شيئا‬
‫وهذا الشكل يوضح العملية‪:‬‬
‫• نضيف في الدالة الرئيسية في البرنامج‪:‬‬
‫‪• //Delete node from list‬‬

‫;)‪mynodes = remove(mynodes‬‬
Double Linked List
‫الصيغة العامة‬ •
: ‫ ولكن بإضافة سطر واحد فقط‬Single linked list ‫الصيغة العامة هي مثل‬
•
struct My_List_Name
{
//My Data : int, float, char, ... ect
//This is the pointer to next node
struct My_List_Name *next;
// This is the pointer to previous node
struct My_List_Name *previous;
;}
‫ أي مثل‬, ‫كما تشاهد هو أن السطر الجديد عبارة عن مؤشر آخر يشير إلى نفس نوع التركيب‬ •
.‫ و لكن فقط وظيفته هو اإلشارة إلى العنصر السابق‬next ‫المؤشر‬
‫ نفس التركيب الذي طبقنا عليه‬: ‫مثال‬
• single linked list (my_list)
‫‪• struct my_list‬‬
‫{‬
‫;‪int num‬‬
‫;‪struct my_list *next‬‬
‫;‪struct my_list *previous‬‬
‫;}‬
‫وهذا المؤشر الجديد يعطي للـ ‪ double linked list‬مزيدا من المرونة عند التعامل مع مجموعة من البيانات‬ ‫•‬
‫المرتبطة فيما بينهما ‪ .‬لقد كانت ‪ single linke list‬تتحرك فقط نحو أمام‪ ,‬ولكن هنا يمكننا التحرك إلى أمام‬
‫و إلى الخلف إيضا‪.‬‬
‫كما أن المؤشر ‪ next‬يدل على آخر عنصر اذا كان قيمته ‪ NULL,‬فكذلك هنا ‪ previous‬اذا كانت قيمته‬
‫‪NULL‬فأنه يدل على أن العنصر هو أول عنصر في القائمة‪.‬‬
‫العمليات على القوائم الثنائية‬
‫• بناء القوائم الثنائية‬
‫• القائمة تبدأ خالية ويستدل على خلوها من خالل قيمة المؤشرات‬
‫الخارجية ثم نبدا باضافة العناصر اليها‬
‫• ;‪Nextnode->info = element‬‬
‫• ;‪Nextnode->forw=null‬‬
‫• ;‪Nextnode->backw=null‬‬
‫• ;‪*list=*nextnode‬‬
‫• ;‪*last=*nextnode‬‬
‫• كما تالحظ فان عملية البناء هي عملية اضافة الى اخر القائمة‬
‫ويمكن ان تتم عملية االضافة الى البداية‬
‫العمليات على القوائم الثنائية‪.....‬تابع‬
‫استعراض القوائم الثنائية‬ ‫•‬
‫– لوجود مؤشرين احداهما يشير الى العنصر السابق واآلخر الى العنصر الالحق فاننا بامكاننا استعراض‬
‫القائمة باتجاهين من االمام الى الخلف او العكس‬
‫اضافة عناصر جديدة الى القائمة‬ ‫•‬
‫– اضافة بين عنصرين‬
‫– اضافة الى بداية القائمة‬
‫– اضافة الى نهاية القائمة‬
‫حذف عناصر من القائمة الثنائية‬ ‫•‬
‫– حذف من البداية‬
‫– حذف من الوسط‬
‫– حذف من النهاية‬
‫• السلسلة الدائرية ‪Circular Linked Lists‬‬
‫• وهي السلسلة التي يكون مؤشر أخر خلية يشير الى‬
‫بدايتها‪(.‬كما هو موضح بالرسم)‪.‬‬
‫‪Head‬‬
‫‪‬‬
‫‪Omar‬‬ ‫‪‬‬ ‫‪Ali‬‬ ‫‪‬‬ ‫‪Ahmed‬‬ ‫‪‬‬ ‫‪Salem‬‬ ‫‪‬‬

‫العمليات على القوائم الدائرية‬
‫بناء القوائم الدائرية‬ ‫•‬
‫– وتنطوي هذه العملية على خطوتين االولى تكوين الرأس واالخرى اضافة العناصر الفعلية ال‬
‫القائمة المبدئية‬
‫استعراض القوائم الدائرية‬ ‫•‬
‫• عملية االستعراض شبيهة بالقوائم المفردة اال اننا سنبدأ بالعنصر االول بعد الرأس وننتهي عند‬
‫الرأس وليس عند نهاية القائمة‬
‫اضافة عنصر جديد الى القائمة الدائرية‬ ‫•‬
‫– هنا نشغل انفسنا فيما اذا كانت القائمة خالية ام ال حيث ان القائمة الدائرية على االقل سيكون فيها‬
‫راس وعليه نحن بحاجة الى تحديد موقع االضافة‬
‫حذف العناصر من القوائم الدائرية‬ ‫•‬
‫– حذف عنصر من القائمة الدائرية يترتب عليه تعديل على سلسة المؤشرات اال اذا كان العنصر‬
‫المراد حذفه هو العنصر الوحيد وبذلك يؤشر الراس على نفسه‬
‫المصفوفات الثنائية والمتعددة االبعاد‬
‫من بين المسائل المهمة التي تبرز عند التعامل مع المصفوفات الثنائية والمتعددة تحديد طريقة‬ ‫•‬
‫تمثيلها في الذاكرة وبالتالي تحديد العناوين المطلقة للعناصر وهنا ننوه ان هذه ليست مهمة‬
‫المبرمج ولكنها مهمة لغة البرمجة ونشير هنا ان هناك اسلوبين لتحديد ذلك‪:‬‬
‫– تمثيل افقي‬
‫– تمثيل طولي‬
‫لتحديد العنوان المطلق للعنصر نحتاج الى‬ ‫•‬
‫– العنوان المطلق للعنصر االول في الذاكرة ‪Base‬‬
‫– عدد المواضع التخزينية التي يحتلها العنصر الواحد‬
‫– البعد الطولي للعنصر المعني بالنسبة لالساس‬
‫الجداول الشتيتة ‪Sparse matrices‬‬
‫في بعض المصفوفات قد ال نحتاج الى ان كل عنصر في المصفوفة يحتوي على قيمة محددة والتي تستلزم‬ ‫•‬
‫وجود القيمة صفر‬
‫نأخذ مثال المصفوفة ذات الجدول المثلثي السفلي‬ ‫•‬
‫– نعيد تمثيلها في الذاكرة على شكل مصفوفة احادية‬
‫– وهنا يبرز سؤال كيف سنحدد عنوان العنصر وبنفس الوقت نحافظ على التصور المنطقي للجدول‬
‫الشتيت؟‬
‫• هناك طريقتين األولى حسابية من خال المعادلة )‪A[I,j] = I(i-1)/2+j‬‬
‫• او عن طرق الكشاف‬
‫)‪• =row access value +(column subscript -1‬‬
‫‪+ (2-1)= 8‬مثال ‪• A[4,2]= 7‬‬
‫• شكرا لكم والى اللقاء الوحدة الخامسة‬
‫• السالسل الرمزية ‪Strings‬‬

‫تركيب البيانات وتصميم‬
‫الخوارزميات‬
‫‪1289‬‬
‫الوحدة الثالثة‬

‫الوحدة الثانية ‪ :‬التراكيب التجريدية‬
‫تصميم التراكيب التجريدية وتنفيذها‬ ‫‪‬‬
‫المجموعات باعتبارها تركيبة بيانات تجريدية‬ ‫‪‬‬
‫استخدام التراكيب التجريدية‬ ‫‪‬‬
‫التراكيب التجريدية‬
‫‪ ‬هناك خطوات لتصميم وتمثيل التراكيب االتجريدية يجب‬
‫االلتزام بها وعدم تجاوزها لضمان تنفيذها بأفضل طريقة‬
‫ممكنة وحتى يتحقق الهدف المرجو منها‬
‫– المرحلة االولى التعريف ‪ :‬أي ان نعرف مواصفاتها قبل التفكير‬
‫بالتفاصيل‬
‫– المرحلة الثانية مرحلة التمثيل نحدد تفاصيل التمثيل المناسبة‬
‫كاستخدام المصفوفات او القوائم المتصلة‬
‫‪ ‬العوامل التي يجب االخذ بها لتعريف تركيبة البيانات (التصور‬
‫المنطقي)‬
‫– ان نعطي وصفا للعناصر المكونة لتركيبة البيانات‬
‫– ان نعطي وصفا للعالقة بين هذه العناصر‬
‫– ان نعطي وصفا للعمليات التي نرغب بتنفيذها على تركيبة البيانات‬
‫‪The‬‬ ‫المجموعات باعتبارها تركيبة بيانات تجريدية‬
‫‪Set Abstract Data Type‬‬
‫‪ ‬في هذا الجزء سيتم عرض مثاال توضيحيا لكيفية انشاء تركيبة‬
‫بيانات تجريدية لتمثيل المجموعات سيتم تسميتها (‪)setType‬‬
‫وكيفية استخدامها في برنامج تطبيقي‬
‫‪ ‬تعريف المجموعة‬
‫المجموعة هي عدد من االشياء غير المكررة المأخوذة من مدى‬
‫(‪ )Universe‬محدد من االشياء وال يشترط الترتيب‬
‫العمليات التي تنفذ على المجموعات‬
‫‪ ‬انشاء المجموعة ‪SetCreate‬‬
‫تنشأ المجموعة فارغة خالية من العناصر (‪)Empty Set‬‬
‫ويجب استخدام هذه التعليمة قبل استخدام المجموعة ألول مرة‬
‫ونحتاج في مرحلة التعريف الى كتابة ترويسة الدالة فقط التي‬
‫ستنفذ العملية‬
‫;)‪SetCreate (SetType& S‬‬
‫اإلنتماء الي المجموعة ‪IsElementof‬‬
‫‪ ‬نعني باالنتماء كون العنصر الذي يتم البحث عنه منتميا الى‬
‫المجموعة ام ال فمثال العنصر ‪ E‬ال بد ان يكون من مدى‬
‫المجموعة التي من نفس نوع األشياء المسموح لها باإلنتماء‬
‫الى المجموعة‬
‫‪ ‬كما ان نتيجة العملية تكون منطقية اما ‪ TRUE‬اذا كان‬
‫العنصر منتميا الى المجموعة او ‪ FALSE‬اذا كان العنصر‬
‫غير منتمي الى المجموعة أي ان الدالة بولينية ‪Boolean‬‬
‫‪ function‬وعليه تكون الترويسة‬
‫‪‬‬ ‫;)‪Bool IsElementOf(setType S, E‬‬

‫تعيين المجموعات ‪SetAssign‬‬
‫‪ ‬تعين هذه العملية قيمة المجموعة ‪ S‬الى مجموعة أخرى ‪ T‬أي‬
‫تجعلهما متساويتان‬
‫‪‬‬ ‫;)‪Void SetAssign(setType S, setType& T‬‬

‫التأكد من ان المجموعة خالية ‪SetEmpty‬‬
‫‪ ‬وهي عملية نستخدمها اذا اردنا فحص مجموعة ‪ E‬هل هي‬
‫خالية ام ال وعليه فان هذه الدالة ال بد ان تكون دالة بولينية‬
‫‪ Boolean Function‬النها ستعيد القيمة ‪ true‬في حالة‬
‫ان المجموعة خالية وستعيد القيمة ‪ false‬اذا لم تكن المجموعة‬
‫خالية‬
‫‪‬‬ ‫;)‪Bool SetEmpty(setType S‬‬

‫التأكد من مساواة المجموعات ‪SetEqual‬‬
‫‪ ‬تستخدم لفحص فيما اذا كانت المجموعتان ‪ S,T‬متساويتان‬
‫وعليه سيتم استخدام دالة بولينية ‪boolean Function‬‬
‫‪‬‬ ‫;)‪Bool SetEqual(SetType S, setType T‬‬

‫فحص المجموعات الجزئية ‪SubSetOF‬‬
‫‪ ‬وتستخدم فيما اذا كانت المجموعة ‪ S‬مجموعة جزئية من‬
‫المجموعة ‪ T‬وهذا يتطلب استخدام ايضا دالة بولينية‬
‫‪boolean function‬‬
‫‪‬‬ ‫;)‪bool SubSetOf(setType S, setType T‬‬

‫اتحاد المجموعات ‪Union‬‬
‫‪ ‬وتستخدم إليجاد المجموعة ‪ T‬وهي مساوية إلتحاد‬
‫المجموعتين ‪S,R‬‬
‫‪‬‬ ‫‪Void Union (setType S, setType R, setType‬‬

‫;)‪T‬‬
‫تقاطع المجموعات ‪Intersection‬‬
‫‪ ‬وتستخدم هذه العملية إليجاد المجموعة ‪ T‬وهي مكونة من‬
‫العناصر الموجودة في كل من المجموعتين ‪S,R‬‬
‫‪‬‬ ‫‪Void Intersection(setType S, setType R,‬‬

‫;)‪setType T‬‬
‫فرق المجموعات ‪Difference‬‬
‫‪ ‬وتستخدم هذه العملية إليجاد المجموعة ‪ T‬المكونة من العناصر‬
‫الموجودة في المجموعة ‪ R‬وليست موجودة في المجموعة ‪S‬‬
‫‪‬‬ ‫‪Void Difference(setType S, setType R,‬‬

‫;)‪setType T‬‬
‫اضافة عنصر الى المجموعة ‪AddElement‬‬
‫‪ ‬تستخدم هذه العملية إلضافة العنصر ‪ U‬من المدى ‪universe‬‬
‫الى المجموعة ‪S‬‬
‫‪‬‬ ‫;)‪Void AddElement(setType& S, int U‬‬

‫ازالة عنصر من المجموعة‬
‫‪RemoveElement‬‬
‫‪ ‬وتستخدم إلزالة العنصر ‪ U‬من المجموعة ‪S‬‬
‫‪‬‬ ‫;)‪Void RemoveElement(setType& S, int U‬‬

‫طباعة عناصر المجموعة ‪SetDisplay‬‬
‫‪ ‬وتقوم هذه الدالة بعرض العناصر المنتمية الى المجموعة على‬
‫الشاشة‬
‫‪‬‬ ‫;)‪Void SetDisplay(setType S‬‬

‫مالحظات عامة‬
‫‪ ‬ان المعلومات السابقة تمثل تعريف تركيبة بيانات المجموعة‬
‫‪ SetType‬في كل ما يلزم معرفته تقريبا إلستخدامها بفعالية‬
‫بدون الحاجة الي معرفة تفاصيل التمثيل والتنفيذ‬
‫‪ ‬المستخدم ليس بحاجة الى معرفة تفاصل عمل المجموعة لكن‬
‫هو بحاجة الى تعريف مدى المجموعة‬
‫تنفيذ المجموعات باعتبارها تركيبة بيانات تجريدية‬
‫‪SetType‬‬
‫‪ ‬نبحث في كيفية تمثيل المجموعة وكيفية كتابة الدوال المنفذه‬
‫للعمليات المعرفة أعاله‬
‫‪ ‬كما ان المجموعة ‪ set‬معرفة اصال كنوع من انواع البيانات‬
‫في لغة البرمجة ‪ c++‬لكننا سنتجاهل ذلك‬
‫‪ ‬سنفترض ان مدى المجموعة هنا هو نوع من انواع البيانات‬
‫الترتيبية والتى نقصد بها ان لكل عنصر في المجموعة عنصر‬
‫سابق ‪ Predecessor‬وعنصر الحق ‪ Successor‬باستثناء‬
‫اول عنصر وآخر عنصرا مثال (االعداد الصحيحة والحروف‬
‫لكن االعداد الحقيقية ال تمثل بيانات ترتيبية)‬
SetCreate ‫انشاء المجموعة‬
false ‫ ينشئ التعريف مجموعة خالية لذلك سيتم تخزين قيمة‬
‫في كل موقع من مواقع المصفوفة‬
 Void setType :: SetCreate(setType& S)
{for(int I =firstValue;i<= lastValue;i++)
S.set[i]=false;
}// end SetCreate
SetAssign ‫تعيين المجموعات‬
S ‫ مساويا للمجموعة‬T ‫ تجعل هذه العملية قيمة المجموعة‬
 Void setType:: SetAssign(setType S,

setType& T)
{
for(int i= firstValue;i<=lastValue;I++)
T.set[i] =S.set[i];
} // end setAssign
‫التأكد من ان المجموعة خالية ‪SetEmpty‬‬
‫‪ ‬تكون المجموعة خالية اذا كانت كل القيم المخزنة في‬
‫المصفوفة هي ‪ false‬واال فانها ال تكون خالية وعليه يجب ان‬
‫تعيد الدالة قيمة ‪false‬‬
‫‪‬‬ ‫)‪Bool setType::SetEmpty(setType S‬‬

‫{‬
‫)‪for ) int I = firstValue;i<LastValue;i++‬‬
‫)‪if(S.set[i]= =true‬‬
SetEqual ‫التأكد من مساواة المجموعات‬
‫ متساويتان‬S,T ‫ تستخدم لفحص فيما اذا كانت المجموعتان‬
boolean Function ‫وعليه سيتم استخدام دالة بولينية‬
 Bool setType::SetEqual(SetType S, setType

T)
{
for(int i=firstValue;i<= LastValue;i++)
if (S.set[i]!=T.set[i])
return false;
‫فحص المجموعات الجزئية ‪SubSetOF‬‬
‫‪ ‬تكون المجموعة ‪ S‬مجموعة جزئية في ‪ T‬اذا كان كل موقع‬
‫في ‪ S‬يحتوي على القيمة ‪ true‬وكان الموقع المقابل نفسه في‬
‫المصفوفة الممثلة للمجموعة ‪ T‬يحتوي على ‪true‬‬
‫‪ bool setType::SubSetOf(setType S, setType‬‬
‫)‪T‬‬
‫{‬
‫)‪for(int i=firstValue;i<= LastValue;i++‬‬
‫)]‪if (S.set[i] && !T.set[i‬‬
Union ‫اتحاد المجموعات‬
‫ علينا‬S,R ‫ التي تمثل إتحاد المجموعتين‬T ‫ إليجاد المجموعة‬
‫ او المجموعة‬R ‫ان نضع بها كل عنصر موجود في المجموعة‬
S
 Void setType:Union (setType S, setType R,

setType& T)
{
T.set[i]=R.set[i] || S.set[i];
Intersection ‫تقاطع المجموعات‬
‫ وهي مكونة من‬T ‫ وتستخدم هذه العملية إليجاد المجموعة‬
S,R ‫العناصر الموجودة في كل من المجموعتين‬
 Void setType::Intersection(setType S, setType R,

setType& T)
{
T.set[i]=R.set[i] && S.set[i];
}//end intersection
‫فرق المجموعات ‪Difference‬‬
‫‪ ‬وتستخدم هذه العملية إليجاد المجموعة ‪ T‬المكونة من العناصر‬
‫الموجودة في المجموعة ‪ R‬وليست موجودة في المجموعة ‪S‬‬
‫بمعنى طرح المجموعتين‬
‫‪‬‬ ‫‪Void setType:: Difference(setType S,‬‬

‫;)‪setType R, setType& T‬‬
‫{‬
‫)‪for(int i=firstValue;i<= LastValue;i++‬‬
‫;]‪T.set[i]=R.set[i] && !S.set[i‬‬
‫اضافة عنصر الى المجموعة ‪AddElement‬‬
‫‪ ‬تستخدم هذه العملية إلضافة العنصر ‪ U‬من المدى ‪universe‬‬
‫الى المجموعة ‪S‬‬
‫‪‬‬ ‫‪Void setType:: AddElement(setType& S, int‬‬

‫)‪U‬‬
‫;‪{ S.set[U]=true‬‬
‫}‬
‫ازالة عنصر من المجموعة‬
RemoveElement
S ‫ من المجموعة‬U ‫ وتستخدم إلزالة العنصر‬
Void setType:: RemoveElement(setType&

S, int U)
{ S.set[U]=false;
}
SetDisplay ‫طباعة عناصر المجموعة‬
‫ وتقوم هذه الدالة بعرض العناصر المنتمية الى المجموعة على‬
‫الشاشة‬
 Void setType ::SetDisplay(setType S)

{
cout<<S.set[i]<< “ “;
}//setDisplay
‫استخدام التراكيب التجريدية‬
‫هذا الجزء سيتم تطبيق وتنفيذ تراكيب يبانية من خالل برنامج‬ ‫‪‬‬
‫يقرأ سطر من االحرف ثم يحدد حروف العلة بحالتيها ‪upper‬‬
‫‪& Lower‬‬
‫خالصة‬
‫‪ ‬التراكيب التجريدية هي تلك التراكيب التي نستخدمها من خالل‬
‫عمليات معرفة مسبقا عليها دون الحاجة الى معرفة تفاصيل‬
‫تمثيل وتنفيذ تلك التراكيب والعمليات‬
‫‪ ‬فوائد استخدام التراكيب التجريدية‬
‫عند اضطرارنا الى تغير طريقة التمثيل وتنفيذ التراكيب التجريدية‬ ‫–‬
‫لن نضطر الى تغيير البرامج التطبيقية التي نستخدمها‬
‫تصبح عملية كتابة البرامج التطبيقية ايسر وتتطلب جهدا اقل ووقتا‬ ‫–‬
‫اقصر‬
‫االستخدام المتكرر للبرامج الرعية في برامج اخرى‬ ‫–‬
‫تسهيل عمل فريق البرمجة وخاصة في البرامج الكبيرة‬ ‫–‬
‫‪‬شكرا إلنتباهكم والى اللقاء‪..........‬‬
‫آ ات – اة او‬
‫ ات‪ :‬ه ! ا

و ا
ا
ت ا
وا اث ا
‬
‫اط ات‪ :‬ﺏ ﺏ‪ – #$‬ﺏ آ‬
‫اآ ا‪ :‬ی( ﺏ(( ﺵ( ا

(‪ (+ ( (( ! ,‬ا
((ت ا
(
( ﺕ)(( ‪(2‬ص ووﺝ(د اﺱ((‪0‬ب ‪(2‬ص
‪(+0‬ل ا
((‪,‬‬
‫ا
‪ +‬ا
دی ﺱاء ‪:2‬ل ‪ 0‬ا
‪89‬ی او اﺱ ﺝع‬
‫"ات ا!! آ ا‪:‬‬

‫‪ .١‬ی ا
@ آ ? ‪ ,0‬ة‬
‫‪C .٢‬ی ﺕ) ا
‪ +‬ﺕ‪ DE‬ﺵة ‪C ,0‬ی ا
‪+‬ل ا
‪ ,‬ا
? ا
ا او ا
@ ا
آ‪ B‬ا
آ‬
‫آ ات‪ :‬ی ا
‪ ,‬ا
‪#‬ق واﺱ
‪ B‬ا
‪ 0 9‬ا
ی ‪ (
:2‬ﺕﺝ ( ا
(?ر ا
‪(0
(#‬ت آ ( یاه( ا
(‪ G‬ا
(‪,‬‬
‫ﺕ ‪ L‬ﺱ‪ K B‬ذاآة ا
‪I‬ﺱب‬
‫ه)ا ا(ع & ‪ $%‬ه‪:‬‬
‫‪ .١‬ا
!‪ B‬ا
)ي‪ :‬ی ول اﺱ‪ Q‬ا
‪ #‬وا
ی‪ P‬ا
ﺕم ‪ 0 0‬ﺕآ‪ B‬ا
ت وﺕ‪ (0I‬آ(ءة ا
اآ(‪ B‬ا
( (‬
‫‪ W‬ا
‪ $‬ا
ﺕ‪ 0 I‬ا
‪S‬اآة وا
‪ 8‬ا
‪S‬ي ی‪ TUV $‬ﺕ‪ S‬ا
‪9‬ارزت ا
‪ +9‬ﺏ‬
‫‪ .٢‬ا
!‪ B‬ا
‪ :(#‬ی (ول اﺱ(‪ Q‬ا
‪ (0‬وا
!( ی!(د ا
‪ (U:‬ا
) ( ﺏ( ا
‪ (+‬ا
‪ 0
(0 9‬اآ(‪ B‬ا
( وای!(د‬
‫ا
‪ $‬ا
ﺱ
‪+0‬ل ا
‪ ,‬ه‪ XS‬ا
‪+‬‬
‫ی‪"+ 4‬ی‪ $‬ا‪2‬اد ا‪ 0 ..‬ذاآة ا‪!.‬ب ﺏ!‪+‬ام‪ .١ :‬ا

‪#‬ی ا
‪ .٢ YL‬ا
‪#‬ی ا
ی‬
‫أ ا‪ Z‬اد ا
‪ :I‬ﺏ
‪ #‬ا
‪ . Y‬ا
‪ Y‬ة‪89
) :‬ی ا‪ Z‬اد ذات ا
ا
ة ‪ @P K‬ﺕ‪89‬ی وا ‪ ،‬وهك أی_ د‪.(_ U‬‬
‫‪7‬ق ‪ 85‬ا‪ 49‬ا‪: 9:‬‬

‫‪ YD 2 .١‬وا ة‪ .٢ .‬ا
‪ @P‬ا
‪89‬ی ﺏ‪ .٣ .word T0‬ﺏی‪ b‬وا ا
‪.word @P‬‬
‫* ا
‪ $‬ا
ی‪ 0 I‬ا
‪E‬ﺵ ‪ K‬ا
‪S‬اآة أ‪ U‬ا
‪ $‬ا
ﺕ‪ 0 I‬ا
‪.‬‬
‫ا
‪E‬ﺵ ‪ ،@P :K‬أو ?‪.@P d‬‬
‫ا
‪ .١ :‬ان ‪ .e0#‬أو ‪ .٢‬ان ‪.$‬‬
‫أ!; اﺥر ﺏ‪ $‬ااآ ا ‪:‬‬

‫‪ ! .١‬ا
ت ا
?‪ 0‬ﺏ
‪.0‬‬
‫‪ .٢‬ﺕار ا
‪ I‬وث وا
‪#‬ی ا
ﺱ ‪ $‬ﺏ‪.‬‬
‫‪ C .٣‬ا
ت )‪D‬ت أو ﺕ‪.(V‬‬
‫‪ $ .٤‬ا
‪S‬اآة
‪89 0‬ی‪.‬‬
‫‪ .٥‬ا
‪ bU‬ا
‪:‬زم ﺱ ﺝع أ ا
‪.+‬‬
‫‪ .٦‬ى ﺱ
أو ‪+‬ﺏ ﺕﺝ ا
آ‪.B‬‬
‫?‪ $‬ه‪:‬ك ‪2‬ا‪+ 8‬ذ ‪A‬ار اﺥر‪:‬‬

‫‪ .١‬أن ی‪ Q‬ا
‪U:‬ت ا
‪ I‬ﺏ ا
ت وا
ا‪.@U‬‬
‫‪ .٢‬ﺏ‪ #$‬ﺏ رﺝ آ‪ + K‬آءة ‪ !
K‬ا
ت و‪ bU‬ا
‪I‬ﺝ‪.‬‬
‫ا‪ CD‬ااآ او ا‪:‬ذج ا ‪:‬‬

‫‪ .١‬ا
?‪K‬ت ‪ .٢‬ا
ا‪ Y‬ا
?‪0‬‬
‫ا‪G‬ت ا ‪F‬ي او ‪ 2 4‬ااآ ا ‪:‬‬

‫‪ .١‬اﺱ ?ء "ا
‪ WI‬ا
ت" ‪ .٢‬اﺱ اض "اﺱ اض ?ا ﺏ ا‪ ,(0 (2‬ا
(ا
و
! ( " ‪ .٣‬ا
(ز ‪ .٤‬ا
( ‪G‬‬
‫‪ .٥‬ا‪ KP‬وا
‪SI‬ف ‪ .٦‬ا
‪ I‬ی‪W‬‬
‫ا‪FH‬ة‪ :‬أ ا‪Z‬ﺱ ﺏ‪ V+p‬ا

‪ +‬وﺏ‪ o‬ﺏ ‪C‬ی‪0 e‬ت )ا
أس( ‪ ,0r
? D‬و ‪ 0‬ا
ﺏ‪.o‬‬
‫آ ات – اة ا‪5‬‬
‫ا‪9‬ی; ا ‪+I‬م ‪9‬ر ﺏ‪ $‬ا‪+‬ارزت‪:‬‬
‫‪ .١‬ار و‪ bU‬ا
‪I‬ﺱب ا
‪:‬زم
‪S‬ه‪.‬‬
‫‪ $ .٢‬ذاآة ا
‪I‬ﺱب ا
ﺕ‪ I‬ج إ
ا
‪9‬ارز‪.‬‬
‫‪ .٣‬و‪P‬ح ا
‪9‬ارز وﺏ‪. C$‬‬
‫‪ U‬ﺕ رض‪0 ..‬ل وﺱ‪ C B$) o‬ا
)وف(‪.‬‬
‫‪2‬ا‪ 8‬ی‪ C2 G‬و‪ LA‬ا‪ )K:‬ا‪ :99.‬ا‪G‬ا‪ 8‬ا ‪A 8GF‬س ا‪ LA‬ا‪ )K: 99.‬اا‪ !: N O‬دا‪9 M‬ر‬
‫ا‪+‬ارزت‪:‬‬
‫‪ .١‬ﺱ ا
‪I‬ﺱب )‪.($ U:‬‬
‫‪ .٢‬آ ا
ت )‪C U:‬دی(‪.‬‬
‫‪ .٣‬ا أ‪2‬ى
‪ U:‬ﺏ
‪ V
:S‬ا
! ا
‪ 9‬رة‪ ،‬وا
‪ ،G‬و ار ‪2‬ﺕ‪.T‬‬
‫‪ 8.‬ا‪+‬ارز ‪ :‬دراﺱ ا
‪9‬ارز وا
ف ‪ ,0‬ى آ‪ W Y‬و‪ bU‬ا
‪ S‬ا
‪:‬زم وذاآة ا
‪I‬ﺱب ا
‪:‬ز‬
‫ﺕ‪ 0I‬ا
‪9‬ارز ی‪:D S2‬ث ت او ﺱریهت‪:‬‬
‫‪ .١‬ا
‪
I‬ا‪ :best case _K‬ه ا
‪
I‬ا
ﺕ‪ I‬ج ا
‪ ,‬ﺕ‪ S‬ا‪ U‬د ا
‪#9‬ات‬
‫‪ .٢‬ا
‪
I‬اﺱأ ‪ :worst case‬ه ا
‪
I‬ا
ﺕ‪ I‬ج ‪ K‬ا
‪9‬ارز ا
‪ ,‬ﺕ‪ S‬اآ د ا
‪#9‬ات‬
‫‪ .٣‬ا
‪
I‬ا
ﺱ‪ :average case ,#‬ه ا
‪
I‬ا
ﺕ ‪ B0#‬ﺕ‪ S‬د ل ا
‪#9‬ات‬
‫‪9‬ی; ‪ :)K:‬ا
‪ 8‬ا
‪L‬ﺏ‪ ،b‬ا
‪ 8‬ا
‪ ،#9‬ا
‪ 8‬ا
‪v0‬ری ‪ ،‬ا
‪ 8‬ا
د ا
‪ I‬ود‪ ،‬ا
‪ 8‬ا‪Z‬ﺱ‪.‬‬
‫ﺥارزت ا‪K‬ز‪:‬‬

‫‪2 .١‬ارز ا
ز ا
‪2 :‬ارز ﺏ‪ #$‬ﺕم ﺏ ر آ ?ی !وری ‪ K‬ا
?‪ K‬واﺱ ا
اذا وﺝ ان‬
‫ا
? اول ا‪ V+‬ا
‪S‬ي ی‪ ،T0‬ان ا
‪#9‬ة ا
‪I‬ﺝ او اآ‪ L‬ﺕارا ‪ K‬ه‪ XS‬ا
‪9‬ارز ه ‪ 0‬ا
ر ‪ if‬و د‬
‫ﺕاره ه ا
! ع‬
‫ ‪ :0‬ا
ﺕ‪ B‬ا
ز

‪.K? +‬‬
‫‪ K‬ا
‪
I‬ا‪ :_KZ‬إذا آ‪ b‬ا
?‪ K‬ﺕ )
ﺕ!ي أي ‪ 0‬ﺕ ی(‪.‬‬
‫‪ K‬ا
‪
I‬ا‪Z‬ﺱأ‪ :‬ﺕن ا
?‪ K‬ﺕ ﺕ? ی ‪n^2‬‬
‫‪2 .٢‬ارز ا
ز ا ‪ :Y‬ﺕ ا
‪9‬ارز ‪ ,0‬ﺕﺕ‪ + B‬ا
?‪ K‬ﺏ ار ‪ 0‬ای!د ا‪ K ? U‬ا
!‪8‬ء ‪v‬‬
‫ا
ﺕ‪ B‬ا
?‪ K‬واﺱ ال ذ
‪ w‬ا
? @ اول ? ا
!‪8‬ء ‪ v‬ا
ﺕ‪ K B‬ا‪ W _K‬اﺱ ال‬
‫ ‪ :0‬ا
ﺕ‪ B‬ا
? ي
‪.K? +‬‬
‫‪ K‬ا
‪
I‬ا‪ :_KZ‬إذا آ‪ b‬ا
?‪ K‬ﺕ ‪ n‬ة‬
‫‪ K‬ا
‪
I‬ا‪Z‬ﺱأ‪ :‬ﺕن ا
?‪ K‬ﺕ ﺕز
‪ n‬ة‬
‫‪2 .٣‬ارز ا
ز اد‪ :
2‬ﺕ ا
‪9‬ارز ‪ ,0‬ﺕﺕ‪ B‬ا
‪ +‬اﺏ اءا ا
? ا
‪ L‬ﺏد‪2‬ل آ ? ‪ K‬ا
ن‬
‫ا
?‪ $ xI‬ا
‪ ,‬ﺝ @ ا
‪ +‬ا
ﺱ‪ e‬ﺕﺕ او اد‪
2‬‬
‫‪2 $‬ب ا‪K‬ز ا‪ 29K‬وا‪ M9‬ان آ ﺱف ﺕ!ي ‪ Q‬ا
د ا
رت ﺏ‪ yV‬ا
) ا
‪
I‬اﺏ ا‪K? 0
Y‬‬
‫ ‪
,‬آ‪ b‬ﺕ‬
‫ﺏ اد‪ K
2‬ﺕ‪ ): @# $‬ان ا
‪9‬ارز ﺕ او ﺵ‪ T‬ﺕ ا‪ :+‬وﺕ‪ K S‬ﺕ‪ w0‬ا
‪
I‬د ا‪ U‬ا
رت‬
‫اة ا‪55‬‬
‫ااآ ا‪F‬یی ‪ :‬ه ﺕاآ‪ B‬ا
ت ا
ﺕ‪ @# $‬اﺱ ‪ 9‬ا ‪:2‬ل ‪0‬ت ‪ ,0 K‬ﺵ دوال ‪ ,0‬ه‪ XS‬ا
اآ‪B‬‬
‫ دون ا
‪I‬ﺝ ا
‪ ,‬ﺕ‪ +‬ﺕ ‪ L‬ه‪ XS‬ا
اآ‪B‬‬
‫‪0‬ا‪ M‬ا‪ Q 8G‬ااآ ا‪F‬یی )ﺏ‪"G‬ل ‪ $2‬ا‪K‬ﺹ‪ 8‬ااﺥ (‪.‬‬
‫‪ .١‬ا
آ‪ ,0 8‬ا
‪
p$‬ذاﺕ دون ا‪V‬ل ﺏ
‪ v +‬ا
_وری
‪ ..
p$ 0‬ا
‪ G‬أآ‪ L‬إ ﺝ و‪0K‬‬
‫وا
‪ G‬أ‪ U‬ﺕ ا وأی‪ 0
$‬ﺏ وا
وا
ی‪.‬‬
‫‪
K .٢‬ﺕ‪ V‬ﺕ ‪ L‬وﺕ‪ S‬ا
آ ا

ﺕ ‪ V‬ا
ا‪ G‬ا
‪ #‬ا
ى )‪Z‬ن ا
‪0‬ت ‪ ،K‬واﺱ ء ‪.(T$‬‬
‫‪ .٣‬اﺱ ‪ 9‬ام ا
ر
‪0‬ا‪ G‬دون ا
‪I‬ﺝ إ
‪ ,‬آ ﺏ ة أ‪2‬ى )ا‪? 2‬ر ا
‪ bU‬وزیدة ا
‪ L‬ﺏ(‪.‬‬
‫‪ .٤‬ﺕ‪K $‬ق ا
? وا
!‪ ) .‬ة‪ ،‬ا‪ ،K‬ی‪ $‬ﺏ_ ﺏ_ ‪ 0L ..‬و‪S‬ة ﺏ‪#‬ی وا ة(‪.‬‬
‫‪G‬ی‪ W‬آ ات ه‪:‬ك ﺙ‪Y‬ﺙ ‪2‬ا‪:8‬‬
‫‪ .١‬أن ‪ #‬و‪ +0
+‬ا

آ ا
ت‪.‬‬
‫‪ .٢‬أن ‪ #‬و‪U:0
+‬ت ﺏ‪.‬‬
‫‪ .٣‬أن ‪ #‬و‪0 0
+‬ت ا
‪ Bv‬ﺏ ‪S‬ه ‪ ,0‬ا
آ ا
‪.‬‬
‫اة ا‪I‬د! ‪ :‬ااﺏ‬

‫اﺏر‪ :‬ﺕآ‪ #2 B‬ی‪ ,0 $‬أ ا‪ KP‬ا
‪ +‬ا
! ی ة ا
‪ ,‬ی ا
‪ Y‬و‪S‬ف ا
‪ ( +‬ﺏ( ای ‪ w
S(
،‬ی(ر
‪(#0‬ﺏر ﺏﺱ(‬
‫‪ fifo‬أي یﺕ او ی‪ 9‬م او‪ K ،‬ﺵ اﺵل ا
ا‪ Y‬ﺕ‪8 0‬م ﺏ ا ‪ I‬د ‪0 K‬ت ا‪ KP‬وا
‪SI‬ف‬
‫ی?‪ B‬اه م ا
‪#‬ﺏر ‪ ,0‬آ ﺕ‪89‬ی ا
ت ‪ K‬ا
آ‪ B‬ا
وآ ا
‪+‬ل ا
‬
‫ﺏای اﺏر ‪ front‬ی ‪ TK‬ا

‪SI‬ف او ا
‪V‬ء ‪C ،‬ی اﺏر ‪ Rear‬ی ‪ TK‬ا‪KP‬‬
‫ا
‪(#‬ﺏر
((‪D Q‬ﺏ (( ‪ ((K‬ا
‪((#‬ل ﺏ(( ی ((ز ﺏ
‪I‬آ(( وا
‪I‬ی(( وا
‪8‬ی(دة وا
((?ن وا
(( ﺕ((م ‪ ,((0 o((K‬ا‪ K((P‬وا
‪S((I‬ف ((@ اﺱ(( د‬
‫ا
‪ #‬وار ا‪2‬ى‬
‫ا‪I‬ت ا ی‪ 4I‬ﺏ‪ C‬اﺏر و‪A &GF‬درا ‪. 2‬آة اا‪ QA‬ا‪ :GK‬ﺥ‪:ZM‬‬
‫‪ .١‬ی ﺕ‪8‬وی ا
‪#‬ﺏر ا
ء ‪ K‬ﺏء‪ X‬ﺏ
ﺱ‪ 0‬ا
ﺱ
‪:‬ﺵرة ا
‪ T ,‬وا
‪ ,‬ی ‪0 $
T‬ت ا‪ KP‬وا
‪SI‬ف‬
‫‪ .٢‬ی ‪$‬وى د ات ا
‪SI‬ف @ د ا
ا
_‪ K‬ا
‪ ,‬ا
‪#‬ﺏر ‪K‬ن ا
‪#‬ﺏر ی? ا
‪ ,‬و‪ @P‬ی?‪
2 T x‬ا
‬
‫‪ .٣‬ان ا
ا
ة ا
ی‪ x $‬ﺏ
‪+‬ل ا
و
! ‪ K‬ا
‪#‬ﺏر ه ا
او
‪ ,‬و
ی ا
‪(+‬ل ا
(‪ ,‬ا
‪ (+‬ا‪(2‬ى‬
‫ ﺏ اﺱ ﺝع ‪ U‬ا
? اول و
! ‪T‬‬
‫‪ .٤‬ان ! ا
‪#‬ﺏر ‪ w
S
V‬ی?‪ d‬ﺏ
ی‬
‫‪ .٥‬ا
‪+‬ل ا
‪ ,‬ا
‪ K +‬ا
‪#‬ﺏر ین ﺵة
‪ w
S‬ﺕ‪V $‬ق و‪ U‬آا و‪ I‬ود ﺏ ا
‪#‬ﺏر وی ‪T‬‬
‫ا‪H‬آ‪ 8‬ا ‪ 82 4[:‬اﺏر‪:‬‬

‫• ‪ K‬ل ا
?‪K‬ت ‪ 0‬ﺕ ی ! ا
‪#‬ﺏر ‪ K‬ی? ا
‪#‬ﺏر ا
‪
,‬ا
(‪ ( yY‬ی(‪E‬دي ا
(‪ ,‬ﺕ‪ b(UE d(U‬و
!(‪ B‬ه(‪XS‬‬
‫ا
(‪ 0‬ی ( ا
(م ﺏ ( ی ا
‪ (!I‬ا
‪(#0
@((U‬ﺏر وﺏ
(
!(‪ (K $( 8‬ا
((‪S‬اآة ﺕ ﺱ(‪ @( B‬درﺝ( ( ا
‪(#‬ﺏر وه((‪XS‬‬
‫ا
‪ 0‬اه ‪
K‬ا
ا‪ Y‬ا
?‪0‬‬
‫• ‪ K‬ل ا
ا‪ Y‬ا
?‪K 0‬ن ! ا
‪#‬ﺏر ی ‪ ! ,0‬ا
‪S‬اآة وی ا
‪#‬ﺏر ‪ ( (z0‬ﺕ( ا
‪ (K new (0‬ﺕ(‬
‫‪ @U‬ﺝ ی ی_ ‪ T‬ا
‪ ,‬ﺏ‪ + U‬ا
‪#‬ﺏر‬
‫‪9‬ی ‪ 4F‬اﺏر ی‪2 2 G‬ا‪:8‬‬

‫‪ .١‬ل ا‪ .٢ KP‬ل ا
‪SI‬ف ‪ .٣‬ا
‪ 8‬ا
‪:‬زم ﺝاء ا

! او ﺕ ی ا
‪ " 9‬ا
‪SI‬ف "‬
‫‪ : [Y‬ﺕ ‪ L‬ا

‪#‬ﺏر ﺏﺱ ‪ 9‬ام ا
ا‪ Y‬ا
?‪ TK 0‬ی‪ K 8!I‬ا
(‪S‬اآة ا ( دا ( ا
ا‪$( @(P‬وی
( د ا
( ا
( ی( ‪(0‬‬
‫ا
‪#‬ﺏر ‪ )I
K‬وه ﺏ‪ w
S‬اس ‪ I
C‬ا
‪#‬ﺏر و!‪ T‬ا
‪0‬‬
‫‪ : [Y‬ا
‪ o‬ا

‪ +‬ا
‪#‬ﺏر ‪ K‬ا
?‪K‬ت ﺕن ‪ Int‬ﺏ ی ﺕ‪ I‬ی ا
‪ o‬ا
( ‪ (K‬ا
(ا‪ Y‬ا
(?‪ 0‬ا( ‪ int‬او ‪char‬‬
‫او ‪ v‬ذ
‪w‬‬
‫ا‪G‬ت ا‪ 2 +I‬ااﺏ‪:‬‬

‫‪ .١‬اء ‪C‬ﺏر‪
K :‬ا
?‪K‬ت ‪K‬ن ‪ front=-1‬و‪ Rear=-1‬ﺏ ‪ K‬ا
ا‪K Y‬ن ‪ front=null‬و‪Rear=null‬‬
‫‪ {((IK .٢‬اذا آ((ن ا
‪((#‬ﺏر ‪ ((
((K :((z0‬ا
((?‪K‬ت ‪((K‬ن ‪ front=0‬و‪ Rear=maxsize-1‬و‪ ((
((K‬ا
((ا‪ (( Y‬ﺕ((‬
‫ا
‪ K new 0‬ﺕ ‪ @U‬ﺝ ی ‬
‫‪ .٣‬ا
‪ eI‬اذا آن ا
‪#‬ﺏر ‪K‬ر‪
Q :v‬اء ا
‪#‬ﺏر و
ﺏ ﺏ ا
ط‬
‫او(ع ا ی ﺏ‪ C‬اﺏر ‪ 0‬ا!‪+‬ام ا‪0K‬ت‪:‬‬
‫‪ Q
.١‬هك ‪ KP @$‬أي ‪ +‬ﺝ ی ة وی‪ d+‬ﺏ‪ T‬و‪ +‬ا
‪ ,‬و‪ @P‬ا
‪yY‬‬
‫‪ .٢‬ان ا
‪#‬ﺏر ‪2‬ل ا
‬
‫‪ Q((
.٣‬ه((ك ((‪ K((P @$‬أي ‪ ((+‬ا
((‪ ,‬ی(( ا
((?‪ K‬ا ان ه((ك ((ن ‪ ((K‬ﺏ(( ای
((‪ w
S‬ﺏ(( (( ا((دة ﺕ)(( ‪((0‬‬
‫ا
‪89‬ی ‪:2‬ل ازا ا
ا
ﺝدة ا
‪ ,‬ﺏ ای( ا
(?‪ K‬وﺏ
(
ﺕ‪I‬ی( ا(آ ا
(‪
V‬ا
(‪ ,‬ی( ا
(?‪ K‬ﺏ( ل (‬
‫او
‪Rear=maxsize-1‬‬
‫‪ .٤‬هك ! ‪ U KP‬ﺝ ی ة ا
‪ ,‬ا
‪#‬ﺏر ‪ K‬ا
ﺱ‪ " B‬ا
‪ @P‬ا دي "‬
‫او(ع ا ی ﺏ‪ C‬اﺏر ‪ 0‬ا!‪+‬ام ا‪9‬ا‪ 4M‬ا ‪:‬‬

‫ا ان ین ا
‪#‬ﺏر ‪ K
2‬ن ا
‪E‬ﺵات ‪ front‬و‪ NULL U Rear‬او ان هك ‪ K‬ا
‪#‬ﺏر ?ا وا ا او اآ‪L‬‬
‫او(ع ا‪).‬ف ‪ $‬ااﺏ‪:‬‬
‫‪ .١‬ا
‪#‬ﺏر ‪2‬ل ‪
.٢‬ی ?ا وا ا ‪ K‬ا
‪#‬ﺏر أي ‪ front=Rear‬وین ‪ @U ,0‬ا
?‬
‫‪ .٢‬ا
‪ @P‬ا دي ﺏﺝد ‪ U‬او اآ‪ L‬وا
ی ی ‪front ,0‬‬
‫اﺏر اا‪M‬ي‪ :‬ﺕ?ر ‪#0

#‬ﺏر یم ‪ ,0‬ا
) ا
‪ ,‬ا
‪#‬ﺏر ‪
K‬ا‪ KP‬وا
‪SI‬ف ‪ ,0‬ا(‪ T‬ی( ‪ (0 (0‬ی (?‬
‫او
ﺏ‪2‬ه‬
‫‪7‬ﺏر اوی ‪ :‬ع ا
‪#‬اﺏ یم ‪ ,0‬ا‪ KP‬ا
‪ +‬ا
! ی ة ا
‪ ,‬ا
‪(#‬ﺏر ‪ (K‬ا
(ن ا
ﺱ(‪ B‬و‪
(K‬رﺝ( او
ی( و
(‪(K Q‬‬
‫ا‪ 2‬ا
‪#‬ﺏر آ ه ا
د‬
‫اﺏر ا"دوج‪ :‬ع ااع ا
‪#‬اﺏ ی‪ x $‬ﺏ‪ KP‬وا
‪SI‬ف ‪ K‬آ‪ :‬اﺕ!ه و
‪ w
S‬ه ا‪U‬ب ا
‪ ,‬ا
س ‪ T‬ا
‪ ,‬ا
‪#‬ﺏر‬
‫آ ات – اة ا‪I‬ﺏ‪G‬‬
‫ا?س‪ :‬ه ﺕآ‪ B‬ﺏ رة ‪ YU‬ا
‪ 89‬ﺏﺱ‪0‬ب اﺱ
‪ B‬ﺕ ‪ L‬ا
ا‪ Y‬ا
‪S‬ي ی‪I‬آ ا
(‪0$‬ك ا
(ا‪ U‬وی (‬
‫و‪ eK‬ا یﺕ او ی‪V‬در او أي ان ا‪ U 2‬ﺕ_ف ا
‪ ,‬ا
س ه اول ‪ U‬ﺕ‪SI‬ف ‪T‬‬
‫ﺥ‪ ZM‬ا?!ت‪:‬‬
‫‪ .١‬ی ‪ $‬ﺏ
ی وا
‪I‬آ ﺏ
‪8‬یدة وا
?ن‬
‫‪ .٢‬ا ا
‪+‬ل ا
ﺵ
‪ I T‬ود ﺏ? وا وه ‪ U‬ا
س‬
‫‪ .٣‬اذا ﺕ‪$‬وت ‪0‬ت ا‪ KP‬وا
‪SI‬ف ‪K‬ن ا
س ی? ا
‪ ,‬و‪ @P‬ی?‪
2 TK x‬ا
‬
‫‪ T C .٤‬ﺕ‪80 $‬م وﺝد اآ‪E L‬ﺵ وا
‪:‬ﺵرة ا
‪TOP T ,‬‬
‫اة ا‪:5‬‬
‫ا!‪2‬ء ا)ا‪ :‬ی ان ﺕ ا
ا
‪ ,0‬اﺱ ء ذاﺕ ﺏ د ‪ I‬د ا
ات ‪ W‬ی ﺏ ه ای‪I‬د ﺕ‪ G‬ا
ا
‬
‫ا"ای ا ‪ $‬ا^وري ‪0‬ه ‪ 8.‬ا‪ I‬ﺏ!‪2‬ء ا)ا‪:‬‬
‫‪ .١‬ﺕ‪
K‬اﺱس او اآ‪ L‬ی ‪ 0 B0#‬اﺱ ءا ذاﺕ‬
‫‪ K .٢‬آ ة ی‪ K , $‬ا
‪ G‬ا
اﺱ ءا ذاﺕ ی‪
,0 , $‬اﺏ‪ o$‬ا
‪
I‬ا‪0+‬‬
‫‪+I‬م ا?!ت ‪ 0 K‬ﺕ‪ S‬ﺏا‪ G‬اﺱ ء ا

‪S‬اﺕ و
‪89
w
S‬ی ر‪ U‬ا
! ‪ 0‬ا
ی!‪ B‬ا
دة ا
ا (ء ( ﺕ(‪ S‬ﺝ ‪(0‬‬
‫اﺱ ء ا‪ KP‬ا
‪ U ,‬ا
‪V‬ات وا
ا ا
‪ +9‬ﺏ
‪ G‬ا
‪, $‬‬
‫اة ا!‪G‬‬
‫ا‪C‬آ‪ 8‬ا‪FH‬ی ‪ :‬ﺕآ‪ B‬ه
! ت ا
ت ﺏ‪ WI‬ین ‪ $( ,(0‬ى ‪ (K‬ا
‪ ( ! $(0$‬وا( ة ﺕ( ‪ ,‬ا
!(‪S‬ر ‪root‬‬
‫ا ﺏ ا
! ت ‪ ! eLK‬ا‪2‬ى ذات ‪ $‬ى ا‪ ,0‬وﺕﺕ‪ o‬ﺏ‪ T‬ﺏاﺱ‪E #‬ﺵات ا
ﺏ‪o‬‬
‫ا‪C‬آ‪ 8‬ا‪FH‬ی ا‪ : M:5‬ع ا

آ ا
!ی ﺏ‪ WI‬ی‪8‬ی د اﺏء ي ا
‪ +‬اﺏ( ا‪ ( K (D‬ان ﺕ(ن ‪(
2‬‬
‫او ﺕ‪ I‬ي ‪ ? ,0‬ﺝ‪S‬ري وا او ا‪D‬‬
‫‪: [Y‬‬
‫‪ -‬ا
آ ا
!ی ﺕ ا
اآ‪ B‬ا
‪ #2 V‬وﺕ‪ L
$‬ا
ت @ ﺏ_ ﺏ ه‬
‫‪ -‬ی ن ا
ا
!ي ‪ Node +‬وی‪ I‬ي آ( (? ‪ ,(0‬ﺝ(‪ W( Y8‬ی‪( I‬ي ا
!(‪8‬ء اول ‪ ( ( ! ,(0‬ا
(ت‬
‫ا
ﺕ?‪ d‬آ او اآ‪ L‬ا ا
!‪8‬ء ا
‪ L‬ی‪ I‬ي ‪ ,0‬ﺏ‪ y‬ا
‪0‬ت ا
ﺕ‪ I‬د ‪ U:‬ا
‪ +‬ﺏ_‬
‫‪ -‬ﺕ ا
آ ا
!ی ااع اآ‪ L‬و و‪U‬ة وی اﺱ ‪ 9‬ا ‪! K‬ت ی ة‬
‫‪ -‬ی ﺕﺕ‪ B‬ا
‪ K +‬ا
ا
!ي ا
‪$‬ر ا
‪ ,‬ا
ﺏ‪ WI‬ﺕن ا
‪ ,(0 +‬ی(‪$‬ر ا
!(‪S‬ر دا‪ ( Y‬ا‪( ( U W( ( (U‬‬
‫ا
‪ +‬ا
ﺝدة ‪ ,0‬ا
‬
‫‪ -‬ی ا
ا
!ي ﺏ
ﺵ!ي ا‪ 2‬اذا آن
‪ Q‬ا
آ‪
, B‬آ‪ b‬ا
ت ا
ﺝدة ‪ K‬ا
‪ +‬ة‬
‫‪`! -‬ت ‪ 85‬ا‪C‬آ‪ 8‬ا‪FH‬ی ﺏ!‪+‬ام ا‪0K‬ت ه م اﺱ ‪:V‬ل ا
‪S‬اآة ‪ ,0‬ا
ﺝ‪ T‬ا‪ L‬وآ‪K w
S‬ن ( ا‪ K(P‬ا
‪ (+‬او‬
‫(‪ KS‬اذ ‪ ( (
v‬ی ‪ B(0#‬ازا( ا
‪ ( (L‬ا
‪ $( ,(0 ()KI 0
(+‬یت ه(‪ XS‬ا
‪ (+‬و‪ ,(0‬ا
‪ (U:‬ا
! ی( ة ﺏ( ا
‪@(( (+‬‬
‫ﺏ_ ا
‪y‬‬
‫‪7‬ق ا!‪G‬اض ا‪C‬آ‪ 8‬ا‪FH‬ی ا‪: M:5‬‬

‫‪ " :LDR "Inorder" .١‬اﺱ اض ا
ﺱ‪ :" #‬ا
‪I‬ك ﺏﺕ!‪ X‬اﺏ ای‪ C D $‬ا
ت ‪ D‬ا
‪I‬ك ﺏﺕ!‪ X‬اﺏ ای ‬
‫‪" :LRD "Postorder" .٢‬اﺱ اض ا
"‪ :‬ا
‪I‬ك ﺏﺕ!‪ X‬اﺏ ای‪ D $‬ﺏﺕ!‪ X‬اﺏ ای ‪ C D‬ا
ت‬
‫‪" :DLR "Preorder" .٣‬اﺱ اض ا
‪ C :"0‬ا
ت ‪ D‬ا
‪I‬ك ﺏﺕ!‪ X‬اﺏ ای‪ D $‬ﺏﺕ!‪ X‬اﺏ ای ‬
‫ااع ا‪C‬آ‪ 8‬ا‪FH‬ی ا‪ M:5‬وﺥ‪ ZM‬آ‪ 8‬ع‪:‬‬

‫‪ .١‬ا
آ ا
!ی ا
‪ YL‬ا
‪ :0‬ﺕ‪ I‬ي ‪ TK‬ﺝ @ ا
‪ $‬یت ‪ K‬ا
‪ ,0‬اآ د ا
‪ +‬ا
‪ $‬ح ﺏ(‪ T‬وآ(‪w
S‬‬
‫‪K‬ن ا
‪ ,0 +‬ا
‪ $‬ى ا‪ 2‬ﺕ) ا‪ ,?U‬ا
‪$‬ر ا
‪ ,‬ا‪ ,?U‬ا
‬
‫‪ .٢‬ا
آ ا
!ی ا
‪ YL‬ا
ا‪ :Y‬ﺕن ا
‪ TK +‬ا‪ Y‬و ﺕ‪ @_(9‬ي ﺕﺕ(‪ B‬وی( ‪ ( G‬ذ
(‪ w‬ان ا
( ا
(!ي ‬
‫ین از ‪ W‬ا
‪e‬‬
‫‪ .٣‬ا
آ(( ا
((!ی ا
‪ ((YL‬ا
از((‪ :‬ﺕ((ن ‪ T((K‬ﺝ ((@ ا
‪ ,((0 ((+‬ا
((‪ $‬ى ((‪ T$‬آ (( ان (( د اﺏ((ء ا
‪ (( e((L‬أي ((‬
‫ا
‪ +‬ا ان ین ا‪D‬ن او ﺵء‬
‫‪ .٤‬ا
آ ا
!ی ا
‪ YL‬ا
ة‪ :‬ع ا
آ ا
!ی ا
‪ 0‬ی ‪ 8‬ﺏ(ن ا
( ا
‪ (K (89‬ا
(?ی ا
‪S(0‬ی ی (‪:L‬ن اﺏ(‬
‫ا
? ‪ K‬ذ
‪ w‬ا
‪ @U‬اذا آن
‪S‬ا ا
? اﺏء و
‪ w
S‬ﺕن ا
ا
‪ K 89‬ا
!‪S‬ر اآ ا
‪ K‬ا
ا
!ي ا
‬
‫اة ا‪DG‬ة‬
‫‪ :82‬ا
آ ا
!ی ﺕ ‪ +2‬ا
‪##9‬ت
‪ L‬ﺏ‪ y‬ا
‪U:‬ت ا
ﺏ ا
ت‬
‫ج‪ :‬ﺕ ز ا
‪##9‬ت ﺏ‪ 0‬ا
د ا
و‪ 0 P‬ر( (@ ا
آ( ا
(!ی (‪ ( W‬ا
( ان ی‪E‬ﺵ( أي (? ‪ ,(0‬أي (?‬
‫ا‪ U: w
S
K 2‬اب واﺏ ‪ v‬ﺝدة ‪ K‬ا
‪##9‬ت‬
‫ا‪+‬ت‪ :‬ع ا
اآ‪ B‬ا
ﺏ‪ WI‬ی ن ا
‪ ! o#9‬ا
ط او ا
ؤوس و! ا
‪I‬اف‬
‫ی?ن ا‪:$M"% $ b+‬‬

‫‪ ! .١‬ا
‪ +‬ی‪ 0 e0#‬رؤوﺱ وﺕ‪ 8‬ﺏـ ‪V‬‬
‫‪ ! .٢‬ا
‪(I‬اف وﺕ(ﺏ‪ o‬آ( ‪ (K‬ﺏ(?ی وﺕ (‪ 8‬آ( ‪ ( (K‬ه(‪ XS‬ا
‪(I‬اف ﺏ(‪8‬وج (‪ (+ ( 8‬ا
! ( ‪V‬‬
‫ور‪8‬ه ه ‪E‬‬
‫ااع ا‪+‬ت‪:‬‬
‫‪ .١‬ا
‪ v o#9‬ا
!‪ :T‬ﺏ‪ WI‬ین ذو ‪C‬ی‪ e‬ﺏﺕ!ه‬
‫‪ .٢‬ا
‪ o#9‬ا
!‪ :T‬اﺕ!‪ X‬وا ‬
‫‪C‬ق ﺕ ‪ L‬ا
‪##9‬ت‪:‬‬
‫‪ .١‬ﺕ ‪ 0L‬ﺏﺱ ‪ 9‬ام ‪E‬ﺵات ا
ﺏ‪ " o‬ا
ا‪ Y‬ا
?‪ W :" 0‬یﺕ‪ o‬ا
? @ د ‪ I v‬ود ا
‪ +‬ا‪2‬ى‬
‫‪ .٢‬ﺕ ‪ (0L‬ﺏﺱ(( ‪ 9‬ام ((?‪ K‬ا
!((ار‪ :‬اذا آ((ن ( د ا
‪ ((+‬ا
ﺝ((دة ‪ ((K‬ا
‪(K n o((#9‬ن ((?‪ K‬ا
!((ار ه(( ((?‪ K‬ذات‬
‫ﺏ ی وآ ﺏ ی‪ I‬ي ‪ ,0‬د ‪ n‬ا
ا‪@U‬‬
‫‪ K? : [Y‬ا
!ار ﺕ‪ I‬ي دا‪ ,0 Y‬ا
?ی ‪٠‬و‪ ١‬و
‪S‬ا ا
‪ B$‬ی‪ K? 0 e0#‬ﺏ
او ?‪YD K‬‬
‫ا‪ : ?H‬ه ‪ K
o#9‬ا‪ U TK‬دی ﺝ ﺕ ‪ L‬وزن ﺕ‪ w0‬ا
‪KI‬‬
‫ا‪ 8?C‬ا‪FH‬ي ا‪ :QI‬ه ﺵ!ي ی ‪ G‬ا

‪ o#9‬ا
? ﺏ ازا
ا
‪I‬اف ا
ﺕ دورات ‪ K‬ا
‪o#9‬‬
‫ا‪C‬آ‪ 8‬ا‪.H‬ی ع ﺥص ‪ $‬ا‪+‬ت " ﺏی‪:‬‬

‫‪ .١‬ا
ا
!ي ? ‪ .٢‬ﺕﺝ ﺏ‪ T‬أي دورات‬
‫ا‪9‬ت ا‪+ G‬ت‪:‬‬

‫‪ .١‬ﺕ‪ 0I‬ا
وا‪ Y‬ا
ﺏ‪ .٢ Y‬ای!د ا‪ ?U‬ا
ات ‪ .٣‬ﺕ‪ o#9‬ا
ری@ ‪! .٤‬ل ا
‪V0‬یت ‪! .٥‬ل ‪ 0‬اﺝ ع‬
‫اة ا‪.‬دی ‪H2‬‬

‫ا‪K‬ز‪ :‬ﺕﺕ‪ ! B‬ا
‪ +‬و‪ eK‬ﺕﺕ‪ B‬ﺕز
او ﺕ? ي‬
‫ا‪ ! {IK 0 :e.‬ا
‪ K
+‬اذا آ‪ U b‬ﺝدة ‪ P‬ه‪ XS‬ا
! ( ام وی( ذ
(‪ w‬ﺏ ر( ا
‪(+‬‬
‫@ ح ا
‪bU‬‬
‫ ‪2‬ت ا‪K‬ز وا‪ e.‬ان ‪H:‬ء ﺥارز ‪f MY‬ﺙ ‪ 2‬اﺥره ‪ $ 2F‬ا‪G‬ا‪ 8‬ه‪:‬‬
‫‪ .١‬ا
‪ bU‬ا
‪S‬ي ی‪ I‬ﺝ‪ T‬ا
‪
G‬ﺏ ﺏ‪ G‬ی‪ S‬ا
‪9‬ارز ﺏ‪ V0‬ﺏ! ‬
‫‪ .٢‬ا
ة ا
ی‪ UV $‬ﺕ‪ S‬ا
‪G‬‬
‫‪ $ .٣‬ا
‪S‬اآة ا
ی‪ I‬ﺝ ﺕ‪ S‬ا
‪9‬ارز‬
‫‪2 .٤‬اص ا
ت ‪ L‬ده و‬
‫ه‪:‬ك ‪0‬ا‪ M‬آ ‪K‬ز ‪ :C:‬ا

‪ $‬ة ‪ K‬ا!ز ‪0‬ت ا
‪ WI‬ﺏ

آ ان ا
ت ا
وزة ا‪0
_K‬ض ‪ ,0‬ا
‪ 9 $‬م‬
‫‪C‬ق ا
ز‪:‬‬
‫‪ .١‬ا
ز ا
ا‪ :02‬ی‪ 9 $‬م اذا ا اﺱ ب ﺝ @ ﺱ!‪:‬ت ا
‪ K d0‬ذاآة ا
‪I‬ﺱب ا
ا‪ 02‬ا
‪$‬ی ‪ W‬ی‪ $‬ی(ن‬
‫ د ا
‪:!$‬ت ی اﺱ ﺏ‪ K T‬ذاآة ا
‪I‬ﺱب ‪ K‬ا
‪T$ bU‬‬
‫‪ .٢‬ا
ز ا
‪9‬رﺝ‪
K :‬وﺝد د آ ﺝ ا ا
(‪:!$‬ت ‪ (K‬ا
‪ d(0‬ا
(اد ‪(K‬ز‪ X‬ی( اﺱ( ﺏﺱ(‪ oY‬ا
‪8(9‬ی ا
(‪ $‬ة‬
‫و ‪ TUC‬ا
ز ﺏ
‪G‬‬
‫ااع ا‪K‬ز ااﺥ‪:‬‬
‫‪ .١‬ا
ز ا
!‪ .٢ Y8‬ا
ز ا
‪$‬ی@ ‪ .٣‬ا
ز ا
‬
‫" ا‪FH‬ة ا‪ M:5‬ا‪9‬ة ﺏ‪+‬اص ا " "ات "‪:‬‬
‫‪ .١‬ی!‪ B‬ان ﺕن ا
!ة ‪ YD‬آ‪ 0‬أي ان د ا
‪ K +‬ا
‪ $‬ى ‪ I‬ی‪$‬وي ‪ I^٢‬ﺏﺱ ‪L‬ء ا‪ $ 2‬ى‬
‫‪ .٢‬ی!‪ B‬ان ﺕن ا
ا
‪ K 89‬آ ‪ @U‬ا‪ @U‬ا
!ة ا
‪ YL‬ا
‪ 0‬ا‪ V+‬ا
ا
‪ (K 89‬ا
‪ @(U‬ا
(‪S‬ي ی(‬
‫اه
‪S‬ا ا
‪$ @U‬وی
‬
‫ااع ‪7‬ق ا‪:e.‬‬

‫‪ .١‬ا
‪ WI‬ا
ﺏ‪ :‬ﺕ ‪C‬ق ا
‪ WI‬ا‪ U‬آءة واآ‪ L‬ﺱ
دون أي ا ر
‪ 0‬ﺕ‪B‬‬
‫‪ .٢‬ا
‪ WI‬ا
‪ :YL‬ی ‪ + ,0‬ﺕ‬
‫‪ .٣‬ا
‪ WI‬ا
س‪:
+ :‬ﺱ ‪ 9‬ام @ ا
‪0‬ت ا
ﺕ‪89‬ن ‪ ,0‬اﺝ‪8‬ة ا
‪89‬ی ا
‪ $‬ة ا‪ Y‬ا
‪+‬ل وه ی ‪$( B(0#‬‬
‫ا‪ KP‬ا
‪S‬اآة ﺕ ‪ @$‬ا
‪ ,‬ا
‪E‬ﺵات ا‪ KP‬ا
‪ ,‬ا
ﺕ‪x‬‬
‫"ات ا‪ e.‬ا‪:M:5‬‬

‫‪ .١‬ﺏ‪ .٢ o$‬ی‪ 9 $‬م @ ا
‪ +‬ا
ﺕ‬
‫‪2 %‬ة ‪7‬ق ‪ e.‬ا‪CK‬س ‪ $2 W+‬ﺏ‪ 0 C^G‬آ‪ 4[: K‬ا‪CK‬رس و‪:C:‬‬
‫‪ .١‬ا
‪ WI‬ا
س ا
ﺏ ‪ .٢‬ا
ﺱ ﺏﺱ ‪ 9‬ام ا
آ ا
!ی ا
‪ .٣ YL‬ا
آ ا
!ی ع ‪B‬‬
‫‪7 G‬ی‪ 9‬ا‪ e.‬ا‪CK‬س اﺏ‪ 2 G‬ا‪G‬ا‪ 8‬ا ‪:‬‬

‫‪ .١‬د ‪ $‬یت اد
ا
‪0 $‬‬
‫‪ .٢‬ة ا ظ ﺏ‪ XS‬اد
‪ K‬ذاآة ا
‪I‬ﺱب‬
‫‪ U: .٣‬ا
ت @ ‪:‬ت ا
و! ا
‪$‬رات و! اﺱ‪#‬ات‬
‫‪0‬ا‪ M‬ا‪ !CK‬ﺏ!‪+‬ام ا‪C‬آ‪ 8‬ا‪FH‬ی ا‪: M:5‬‬

‫‪ .١‬ﺕ ‪ 0‬ا
‪ WI‬ﺏءة
‪$‬وی
ءة ا
‪ WI‬ا
‪ YL‬ﺵی‪ #‬ا
‪ ,0 )KI‬ا
ا
!ي ا
‪8 YL‬‬
‫‪ .٢‬ا‪#‬ؤك ا
رة ‪ ,0‬اﺱ اض ا
ا
!ي ا
‪ YL‬ﺏ‪ WI‬ی ‪ C‬ا
‪ +‬و‪ eK‬ﺕﺕ‪ B‬‬
‫‪ .٣‬ی اﺝاء ‪0‬ت ا‪ KP‬وا
‪SI‬ف ﺏ ن آ ی!‪ 0‬ﺱ‪0‬‬
‫‪: [Y‬‬
‫ﺕ ‪C‬ی ا
آ ا
!ی ا
‪ YL‬ا‪ _K‬ا
‪#‬ق ا
‪ K 9 $‬ا
ﺱ ﺕ ‪ @$‬ذاآة ا
‪I‬ﺱ(ب ا
‪$(Y‬‬
‫
‪ 0‬ا
‪ YL‬ﺏ‪ T0‬و ی ‪S‬ر ذ
‪K w‬ن ا
ءة ﺕ )ا
‪ b‬ﺕزی@ ا
‪+‬‬

Final TrkEb

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Final TrkEb

Transféré par

Droits d'auteur :

Formats disponibles

‫د‬

‫ھ ا د ت‬ ‫م ا وارز ت‬ ‫تو‬ ‫ر با‬

‫د ري‬ ‫درس ا رر‪ /‬أ‪.‬‬

‫دا‬ ‫وا‬ ‫ا د ت وا وب "‬ ‫ھـو ا دس ؟ ‪Stack‬‬

‫دأ ل ا د ت ھو ا ذف وا(' & ‪%‬ر ن ن طرف وا د‬ ‫< ; ل ‪: ) :‬ذف و‬ ‫ا دس ھو أ د ھ ل ا ت ا‬

‫"ل ا د ت طر ن‬ ‫ر ا ‪ , ,‬و ( و‪%‬د‬ ‫ر "‬ ‫ون ا دس ن‬

‫ر ا ‪ , ,‬و ( و‪%‬د‬ ‫ر "‬ ‫ون ا دس ن‬ ‫ن& ا ر ‪%‬‬ ‫‪ %‬نا‬ ‫دم ا د ت &‬

‫ا( د ء ا ذا‬ ‫‪.2‬‬

‫ر‪%‬‬ ‫‪-5‬‬ ‫ط ت ا رى‬ ‫دم &‬ ‫ا‬

Push operation & 'F‫ا‬ Push operation & 'F‫ا‬

: ‫ل ا‬5 ‫ر م ن‬ ‫إ' & أي‬

1. public void Pop() : ‫ل ا‬5 ‫ر م ن‬ ‫ذف ا‬

Peek ‫ر ا@ ر‬ ‫تا‬ ‫رض‬ Peek ‫ر ا@ ر‬ ‫تا‬ ‫رض‬

6 ..‫ا دس‬ ‫تا‬ ‫;ذا‬ ‫ا دس‬ ‫تا‬ ‫;ذا‬

6 ... ‫ت‬ ‫ا‬

top of ‫ل‬ ‫دام ا " ل ا‬ ‫ا ذف‬

‫دام ا د ت‬ ‫ا‬ ‫ا ط ت‬ Pushing an Object (1 of 7)

‫ا و ط‬infix Postfix ‫ا دي‬ Prefix

A+B-C AB+C- -+ABC Node<ElementType> nodeToAdd =

Let’s look at what this does...

‫‪--------‬‬ ‫*‪AB+C‬‬ ‫‪A-B^C‬‬ ‫‪(A+B)*C‬‬ ‫‪A+B*C‬‬

‫‪---------‬‬ ‫‪4‬‬ ‫*‪B+C‬‬ ‫‪ABC^-‬‬ ‫*‪AB+C‬‬ ‫‪ABC*+‬‬

‫‪--------‬‬ ‫‪4,5‬‬ ‫*‪+C‬‬ ‫‪922^-‬‬ ‫*‪72+3‬‬ ‫‪345*+‬‬

‫‪5+4=9‬‬ ‫‪9‬‬ ‫*‪C‬‬ ‫‪9(22^)-‬‬ ‫*‪(72+)3‬‬ ‫‪3(45*)+‬‬

‫‪--------‬‬ ‫‪9,6‬‬ ‫*‬ ‫‪94-‬‬ ‫‪9*3‬‬ ‫‪320+‬‬

‫‪9*6=54‬‬ ‫‪54‬‬ ‫‪5‬‬ ‫‪27‬‬ ‫‪23‬‬

‫ا ء‪..........‬‬ ‫‪ 4‬را ‪ F‬ھ م وا‬

‫د ري‬ ‫درس ا رر‪ /‬أ‪.‬‬

Execution Trace Execution Trace

fibonacci(2) fibonacci(1) fibonacci(2) fibonacci(1)

fibonacci(2)->2 fibonacci(1)->1 fibonacci(2) fibonacci(1)

‫د ء ا ذا‬ ‫ا‬ ‫ذ را‬

Towers of Hanoi: Three Disk

‫ا )‪ 3‬ء‪..........‬‬ ‫‪ 4‬را ‪ B‬ھ م وا‬

‫د ري‬ ‫درس ا رر‪ /‬أ‪.‬‬

‫' ‪....‬‬ ‫د‬

‫ھـ) ا ـ ‪Tree‬؟‬ ‫ھـ) ا ـ ‪Tree‬؟‬

‫‪@8‬‬ ‫ن ا ذي ' ‪,: +‬‬ ‫ت& با‬ ‫و ا ‪#‬ر ھذه‬

‫‪Parrot‬‬ ‫‪Cat‬‬ ‫‪Dog‬‬ ‫‪Level‬‬

‫ر ا‬ ‫لا‬ ‫لا‬ ‫طرق‬ ‫'‬

‫!دام ا ‪5#‬و‪ +‬ت ذات ا د ا وا&د‬ ‫ا ل‬ ‫‪#‬ر‬ ‫! او & وي‬ ‫‪/‬د ون ا ل ا ر ا‬

‫ر ا‬ ‫لا‬ ‫لا‬ ‫'‪ ...‬طرق‬ ‫!دام ا ‪5#‬و‪ +‬ت‬ ‫ل‬ ‫وئ ا‬

‫ر ا‬ ‫لا‬ ‫ءا‬ ‫'ا‬ ‫ر ا‬ ‫لا‬ ‫ءا‬ ‫ا‬

‫ري‬ ‫لا‬ ‫ن ‪ )+‬ا‬ ‫‪#‬ر‬ ‫ا &ث ن‬ ‫ل‬ ‫راض‬ ‫و رد ت &ول ا‬ ‫أ‬

‫ر‬ ‫لا‬ ‫ا‬ ‫ط ت‬

‫ھ) ‪Binary Search Tree‬؟‬ ‫ھـ) ا ـ ‪Binary Tree‬؟‬

‫ت‬ ‫ا>ـ اع ا‬ ‫ت ‪ 1 ` 2 1‬ر` ﺳ ‪: & 1‬‬ ‫نا‬

‫‪Graphs Type‬‬ ‫)‪(Element‬‬ ‫‪ 1 < . .1‬ا ‪0‬‬

‫‪.‬‬ ‫ت ا‪K‬‬ ‫ا‬ ‫)‪(Vertices‬‬

‫تا ‪.‬‬ ‫ا‬ ‫‪: >g‬‬

‫ ي‬. ‫ اض ا‬+‫ * ارز اﻻ‬c _ (Linked Representation) 3 ‫ ا‬O`‫ا = ا‬

‫‪ M‬ا ‪% + :‬ام ‪ AB‬ات ا ‪M‬‬ ‫! ا‬ ‫ٔ‬

‫‪`4‬‬ ‫‪ ` 4‬ـ ا ﺤ اف‬

‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪NULL‬‬

‫= ﺤﺳ ب ا ﺤ اف ا ر‪: 2‬‬ ‫و ‪L‬ا‬

‫ا‬% ‫ ا‬: > Og indegree Int

‫= اﻻو ﻰ ‪:‬‬ ‫• ا‬ ‫= ‪:1‬‬ ‫و‪ . /‬د ا‪ 34‬ا ات >ﺳ ‪%‬م اﺣ‪%‬ى ا‬

‫ا ‪Dijkstra‬‬ ‫‪% +‬ام * ارز د ‪ .‬ﺳ‬

:: ; C++ K 7 3 ‫ ا‬1< ‫ن‬N<‫ اﻻ‬O ‫و‬ C D

: ! !‫ ا‬7 3 ‫ا‬ : > !‫ ا‬7 3 ‫ا‬

‫ ا ات‬34‫ د ا‬. / ‫ ﺳ ا‬. ‫ * ارز د‬0‫و‬

‫اوﻻ‪:‬‬ ‫‪ .1‬ا ‪%‬ا ﻪ ‪: ReadMAT‬‬

‫ا ‪%‬ا ﻪ ‪: FINDMIN‬‬ ‫‪.3‬‬

‫‪true‬‬ ‫‪3‬ﺢ ﺳو =‬ ‫ا = ط ا = ﺳ وي ‪false‬‬

‫‪--------‬‬ ‫‪AB+C‬‬ ‫‪A-B^C‬‬ ‫‪(A+B)C‬‬ ‫‪A+B*C‬‬

‫‪---------‬‬ ‫‪4‬‬ ‫‪B+C‬‬ ‫‪ABC^-‬‬ ‫‪AB+C‬‬ ‫‪ABC*+‬‬

‫‪--------‬‬ ‫‪4,5‬‬ ‫‪+C‬‬ ‫‪922^-‬‬ ‫‪72+3‬‬ ‫‪345*+‬‬

‫‪5+4=9‬‬ ‫‪9‬‬ ‫‪C‬‬ ‫‪9(22^)-‬‬ ‫‪(72+)3‬‬ ‫‪3(45*)+‬‬

‫‪--------‬‬ ‫‪9,6‬‬ ‫‬ ‫‪94-‬‬ ‫‪93‬‬ ‫‪320+‬‬

DoubleList DoubleList::DeleteNode(DoubleList list){ u.

DoubleList DoubleList::InsertNode(DoubleList list, char name, int id, char major){

‫) ‪Q 22‬ﻡ!(‬ ‫ا)‪F‬ال ا‪$‬ول‪:‬‬

‫) ‪Q 13‬ﻡ!(‬ ‫ا)‪F‬ال ا‪:04‬‬

‫) ‪Q 9‬ﻡت(‬ ‫ا)‪F‬ال ا‪:n4‬‬

‫) ‪Q 10‬ﻡ!(‬ ‫ا)‪F‬ال ااﺏ‪:G‬‬

‫) ‪Q 7‬ﻡت(‬ ‫ا)‪F‬ال اﻡ‪:p‬‬

‫) ‪Q 8‬ﻡت(‬ ‫ا)‪F‬ال ا)دس‪:‬‬

‫) ‪Q 11‬ﻡ!(‬ ‫ا)‪F‬ال ا)ﺏ‪:G‬‬

‫‪ .١‬ا ‪-‬اض و@‪ h‬ا) ق ا ‪. LDR 0B‬‬

‫) ‪Q 10‬ﻡت(‬ ‫ا)‪F‬ال ا‪4‬ﻡ'‪:‬‬

‫أ‪ ' .‬أﺡ ا)‪F‬ا ' ا '‪:‬‬

‫)‪Q 10‬ﻡت(‬ ‫ا)‪F‬ال ا‪:W-‬‬

‫ا‪ w2‬ا‪!"# $‬‬