: .. //.. Data Structures ..// ..~



Chelsea 4ever
10-10-10, 03:35 AM
..~

, ! ..

, !

, , .. !

Linked List !

.. !

!

, .. !!

, , , , , ... !

!

!!


.. !

!

..:)

10-10-10, 01:43 PM




:D




[ YOYO ]
10-10-10, 03:07 PM
: )



..

: )

-

LOTUS |
10-10-10, 03:49 PM
: )
..

R O S E M A R Y
10-10-10, 04:06 PM
: ( !

.




.





.





.


:)












[ YOYO ]
10-10-10, 04:13 PM
^

: )

..

:8:

-

11-10-10, 12:08 AM
^^
" R O S E M A R Y " .. .. :rolleyes:

..

" Chelsea 4ever " .. A+ :smile13:

FAISAL F
11-10-10, 09:48 PM

[ YOYO ]
12-10-10, 02:18 PM
^



: ( !

12-10-10, 02:55 PM

!



!!!!

FAISAL F
12-10-10, 03:10 PM

IS student
12-10-10, 09:04 PM
..,
" " ..,
,
,, :)

:a15:

Prince Without Emirate
12-10-10, 11:14 PM


: Chelsea

: , ,
, .

.

linked list.




Chelsea 4ever
13-10-10, 12:05 PM
..~

..~

http://www.imam1.com/vb/showthread.php?t=151373


Singly Linked List !


Chelsea 4ever
14-10-10, 03:04 AM
Linked List ..~

http://www.forums.fci4all.com/index.php?showtopic=17981 (http://www.forums.fci4all.com/index.php?showtopic=17981)

:)

N a ! F
14-10-10, 04:15 AM
^^


FAISAL F
14-10-10, 10:56 AM
single linked list

http://www.4shared.com/********/QZHvQeKe/__online.html




FAISAL F
14-10-10, 11:04 AM

FAISAL F
14-10-10, 11:09 AM

http://www.4shared.com/********/WtvPjbzm/__2.html

********

d o c u m e n t

Chelsea 4ever
14-10-10, 06:41 PM
^^



Na!F

..~

Chelsea 4ever
14-10-10, 06:44 PM

http://www.4shared.com/********/WtvPjbzm/__2.html

********


14-10-10, 06:48 PM
1
:1003:

Chelsea 4ever
14-10-10, 08:01 PM
..~

!!

Prince Without Emirate
14-10-10, 08:19 PM
Linked List

http://www.arabteam2000-forum.com/index.php?showtopic=152349

....

Chelsea 4ever
14-10-10, 09:03 PM
#include<iostream>
using namespace std ;
class node{
public :
int data ;
node *next ;
public :
node (int d){
data = d ;
next = NULL ;
}
};
class SinglyLinkedList {
private :
node *head ;
public :
SinglyLinkedList (){
head = NULL ;
}
bool isEmbty (){
if (head == NULL)
return true ;
else
return false ;
}
void addNode (int d){
node *newPtr = new node (d);
node *current = head ;
if (head == NULL){
head = newPtr ;
return ;
}
while (current->next != NULL){
current = current->next ;
}
current->next = newPtr ;
}
void addToHead (int d){
node *newPtr = new node (d);
newPtr->next = head ;
head = newPtr ;
}
void printList (){
node *current = head ;
if (current == NULL){
cout << "Nothing .. " << endl;
return ;
}
while (current != NULL){
cout << current->data << " " ;
current = current->next ;
}
}
};
int main (){
SinglyLinkedList s1;
s1.addNode(10);
s1.addNode(20);
s1.addNode(30);
s1.addNode(40);
s1.addNode(50);
s1.printList();
getchar ();
getchar ();
return 0;
}




Singly Linked List ..~

Node !!

... !!

Chelsea 4ever
14-10-10, 09:04 PM
Linked List

http://www.arabteam2000-forum.com/index.php?showtopic=152349

....


prince

!

14-10-10, 10:44 PM
,,

,,

- -
15-10-10, 10:13 AM
..
..

:)

16-10-10, 06:58 PM


write algorithem that satisfy the following situation
start thier efficiency and the big o notation
1)swap the first node and the last node of a single linked list without changing the middle
2)find the largest of tow number in tow nodes in integer linked list without make any change in the list

16-10-10, 08:49 PM
.. ..
:(
..
:(

Chelsea 4ever
17-10-10, 12:39 AM


write algorithem that satisfy the following situation
start thier efficiency and the big o notation
1)swap the first node and the last node of a single linked list without changing the middle
2)find the largest of tow number in tow nodes in integer linked list without make any change in the list

alqorithem !


R O S E M A R Y
17-10-10, 04:07 PM


write algorithem that satisfy the following situation
start thier efficiency and the big o notation
1)swap the first node and the last node of a single linked list without changing the middle
2)find the largest of tow number in tow nodes in integer linked list without make any change in the list

,,

befor after ,,
<<

swap
<< head.link

<< null

swap

<< << : swap=ptr.data

<< : ptr.data=str.data

swap << str.data=swap

swap << !!

,,

2




Chelsea 4ever
17-10-10, 05:26 PM
^^^

ROSEMARY

Chelsea 4ever
17-10-10, 05:27 PM
isu ..~



http://www.imam1.com/vb/showthread.php?t=152897&p=2751657&posted=1#post2751657

Chelsea 4ever
17-10-10, 05:31 PM
Singly Linked List

..~
..






..~




#include <iostream>
using namespace std ;
class node {
public :
int data ;
node *next ;
public :
node (int d){
next=NULL;
data = d ;
}
};
class SinglyLinkedList{
public :
node *head ;
public :
SinglyLinkedList (){
head = NULL ;
}
/* ~SinglyLinkedList (){
node *nextPtr ,*current = head ;
while (!current){
nextPtr = current->next ;
delete current ;
current = nextPtr ;
}
}*/
void addBefore (int d){
node *newPtr = new node (d);
newPtr->next = head ;
head = newPtr ;
}
void addAfter (int d){
node *newPtr = new node (d);
node *current = head ;
if (!current){
head = newPtr ;
return ;
}
while(current->next!=NULL){
current = current->next ;
}
current->next = newPtr ;
}
void addBeforeByValue (int searchData,int newData){
node *newPtr = new node (newData);
node *current = head ;
node *prefPtr = NULL ;
bool found = false ;
while (current!=NULL && (found == false)){
if (current->data==searchData)
found = true ;
else{
prefPtr = current ;
current = current->next ;
}
}
if (found == false){
cout << "We didn't find ! " << endl;
return ;
}
else if(head->data == searchData){
newPtr->next = head ;
head = newPtr ;
}
else {
newPtr->next = NULL ;
prefPtr->next = newPtr ;
newPtr->next = current ;
}
}
void addAfterByValue (int searchData,int newData){
node *newPtr = new node (newData);
node *current = head ;
node *prefPtr = NULL ;
newPtr->next = NULL ;
bool found = false ;
while (current!=NULL && (found == false)){
if (current->data==searchData)
found = true ;
else{
current = current->next ;
}
}
if (found == false){
cout << "We didn't find ! " << endl;
return ;
}
else if(current->next==NULL){
current->next = newPtr ;
}
else {
newPtr->next = current->next ;
current->next = newPtr ;
}
}
void removeByValue (int d){
node *current=head ;
node *prefPtr ;
bool found = false ;
while (current!=NULL && found == false){
if (current->data == d)
found = true ;
else {
prefPtr = current ;
current = current->next ;
}
}
if (found == false){
cout << "We didn't Find The Value To remove ! " << endl;
return;
}
else if (head->data == d){
head = current->next;
delete current ;
}
else {
prefPtr->next = current->next ;
delete current ;
}
}
void removeOneByOne (){
node *current = head ;
if (!current){
cout << "Nothing to remove !!" << endl;
return ;
}
while (current != NULL){
head = current->next ;
delete current ;
current = head ;
}

}
void checkIndex (){
node *current = head ;
if (current==NULL)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
void printList (){
node *current = head ;
if (!current){
cout << "Nothing.. " << endl;
return ;
}
while (current!=NULL){
cout << current->data << " -> ";
current = current->next ;

}
}
void removeAfterValue (int searchData){
node *current = head ;
node *prefPtr ;
bool found = false ;
while (current!=NULL && (found == false)){
if (current->data==searchData)
found = true ;

else{
prefPtr = current ;
current = current->next ;
}
}
if (found == false){
cout << "We didn't find ! " << endl;
return ;
}
else if (head->data == searchData){
prefPtr = current->next ;
current->next = prefPtr->next ;
delete prefPtr ;
}
else if (current->next==NULL){
cout << "It's Nothing after Value ! " << endl;
current = NULL ;
}
else {

prefPtr = prefPtr->next ;
current = current->next ;
prefPtr->next = current->next ;

delete current ;
}
}
void removeBeforByValue(int searchData){
node *current = head ;
node *prefPtr , *PrefPtr2 ;
bool found = false ;
while (current!=NULL && found == false){
if (current->data == searchData)
found = true ;
else {
PrefPtr2 = prefPtr ;
prefPtr = current ;
current = current->next;
} }
if (found == false){
cout << "We Didn't find !! " << endl;
return ;
}
else if (head->data==searchData){
cout << "It's Nothing Before Value !! " << endl;
current = NULL ;
}
else{
if (prefPtr == head){
prefPtr->next = current->next ;
head = current ;
delete prefPtr ;
}
else {
PrefPtr2->next = current;
delete prefPtr ;
}
}
}
};
int main (){
SinglyLinkedList s1 ;

//s1.addBefore (30);
s1.addAfter (10);
s1.addAfter (20);
s1.addAfter (30);
s1.addAfter (40);
s1.addAfter (50);
//s1.checkIndex ();
s1.printList ();
cout << endl;
// cout << endl<<s1.checkIndex ()<<endl;
// s1.checkIndex ();
// s1.removeOneByOne ();
// cout << "After Delete All (^_^)"<<endl;
//s1.checkIndex ();
//s1.addAfterByValue (3,100);
//s1.removeByValue (30);
//s1.removeAfterValue (50);
// s1.removeBeforByValue(50);
//s1.printList ();
getchar ();
getchar ();
return 0 ;
}




:)

17-10-10, 05:36 PM

17-10-10, 06:26 PM



..!

17-10-10, 06:52 PM



..!


Don DaVinci
17-10-10, 09:50 PM
,,

befor after ,,
<<

swap
<< head.link

<< null

swap

<< << : swap=ptr.data

<< : ptr.data=str.data

swap << str.data=swap

swap << !!

,,

2





..
..

..
..

/


3 .. temp1 , temp2 , tail
head
temp1 = head->next

while (temp2->next->next == NULL)

( )
tail = temp2 ->next



temp2->next = head;
tail->next = temp1
head->next = NULL
head = tail

big O O(n)
loop



.. !
:D

17-10-10, 10:00 PM





NASSAYIM
18-10-10, 08:39 PM








http://www.vc4arab.com/showthread.php?t=2211

http://www.wepapers.com/Papers/19377/Data_Structures,__Exam_1

Chelsea 4ever
21-10-10, 02:15 AM
^^^^


21-10-10, 01:55 PM


:D
..!

23-10-10, 05:12 PM
..

..
..
..

oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010lkqzo23/Al-shrh_almfsl.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010zktlf23/Amthlh_wtmaryn.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010ocfiu23/Bramj_fy.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010goqle23/Trakyb_albyanat.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010vcusd23/Trakyb_albyanat.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010ceyiq23/Hl_as'ilh.html)
oOo- -oOo
http://www.rofof.com/dw.png (http://sub3.rofof.com/010xmatu23/Hyakl_albyanat.html)


..
..

23-10-10, 07:10 PM


LOTUS |
23-10-10, 10:28 PM
^

..

..
..
..

oOo- -oOo
http://sub3.rofof.com/010lkqzo23/Al-shrh_almfsl.html
oOo- -oOo
http://sub3.rofof.com/010zktlf23/Amthlh_wtmaryn.html
oOo- -oOo
http://sub3.rofof.com/010ocfiu23/Bramj_fy.html
oOo- -oOo
http://sub3.rofof.com/010goqle23/Trakyb_albyanat.html
oOo- -oOo
http://sub3.rofof.com/010vcusd23/Trakyb_albyanat.html
oOo- -oOo
http://sub3.rofof.com/010ceyiq23/Hl_as'ilh.html
oOo- -oOo
http://sub3.rofof.com/010xmatu23/Hyakl_albyanat.html

..
..

http://vb.eqla3.com/images/smilies/004.gif

2009
23-10-10, 11:52 PM
....

24-10-10, 09:00 AM
:D

24-10-10, 06:07 PM
LOTUS | :7:


.. ..

..

24-10-10, 07:57 PM

Chelsea 4ever
26-10-10, 01:41 PM
... ..~


... ..~

26-10-10, 05:06 PM
..

M.T.B
26-10-10, 05:29 PM

.. ,, . . .


||
26-10-10, 06:53 PM




26-10-10, 06:58 PM
..


.. A+

26-10-10, 11:08 PM

28-10-10, 08:58 PM


\\

29-10-10, 08:04 PM
^ ^ ^

()
:D

loletta
01-11-10, 02:17 PM


:cool:

274

01-11-10, 11:33 PM


:cool:

274


: && :
: )30014(

loletta
02-11-10, 05:56 AM
.. (F)

||
02-11-10, 04:38 PM


:smile15:

02-11-10, 08:26 PM
...
Coding :7890:
{
To Section 271,272,273,274

Tomorrow ,you have to submit Exercise-2 ( d , e ). And the coding part submission will

be in Saturday.
}

04-11-10, 02:17 PM






b. The ADT stack lets you peek at its top element without removing it. Assume that an application needs to peek at any element in a stack myStack, where myStack is a stack of Strings. Write a method peekN, at the client level, that receives a position (pos) and returns the string at that position without changing the stack. If pos is greater than the number of elements in the stack, an empty string should be returned. The top element of the stack is at position 1.


!

04-11-10, 09:02 PM

..

04-11-10, 11:54 PM



Prince Without Emirate
05-11-10, 12:03 AM



Prince Without Emirate
05-11-10, 12:05 AM


:smile15:

2 ʿ

05-11-10, 02:15 PM



A certain airport contains a single runway on which arriving aircraft must
land. The first aircraft is preparing to land, it will use the runway,
doesnt allow other aircraft to land. Otherwise, it waits until all aircrafts,
arrived before, landed. When the aircraft has landed, the runway is
available for use by other aircraft.
1. Give the suitable data structure to solve this problem.
2. Implement the following operations:
a. Arriving of an aircraft (add new entry).
b. Landing of an aircraft.
c. Print the aircrafts waiting for landining amd number of them

If aircrafts landed on the ground will take a certain period of time before
departing.
So, implement the following operations:
d. Print the number of landed aircrafts.

||
05-11-10, 04:44 PM
2 ʿ



||
05-11-10, 04:49 PM



.!



Chelsea 4ever
05-11-10, 04:59 PM



..~

06-11-10, 06:48 PM
73



ʿ

[ YOYO ]
06-11-10, 07:52 PM
^

Searching

Sorting

Chelsea 4ever
06-11-10, 10:28 PM
..~


.. two linked List one Linked List ..~


..~


.. ..~





s3=s1.addTwoLikedList (s1,s2);




..~




SinglyLinkedList & addTwoLikedList (SinglyLinkedList &s1, SinglyLinkedList &s2){
SinglyLinkedList L ;
node *current1 = s1.head , *current2 = L.head, *current3 = s2.head ;
node *newPtr ;
if (current2 == NULL){
newPtr = new node (current1->data);
L.head = newPtr ;
current2 = newPtr ;
current1 = current1->next ;
}
cout << current2->data << endl;
while (current1 != NULL){
newPtr = new node (current1->data);
current2->next = newPtr;
current2 = newPtr ;
current1 = current1->next ;
}
//cout << current2->data << endl;
while (current3 != NULL){
newPtr = new node (current3->data);
current2->next = newPtr;
current2 = newPtr ;
current3 = current3->next ;
}
return L ;
}





.. .. .. !!





SinglyLinkedList & extact2(){
SinglyLinkedList L ;
node *current = head ;
node *prefPtr = head ;
int c = 0 ;
while (current!=NULL){
c++ ;
current = current->next ;
}
current = head ;
if (c % 2 == 0){
for (int i = 1 ; i<=c/2 ; i++){
prefPtr = current ;
current = current->next ;
}
prefPtr->next = NULL ; ;
L.head = current ;
return L ;
}
else {
cout << "We Can't ! " << endl;
}
}





.. ..


2 ..~


..~





SinglyLinkedList & extact(int sd , int n){
SinglyLinkedList L ;
node *current = head ;
node *temp;
node *prefPtr = head ;
do{
if (current->data == sd){
break ;
}
prefPtr = current ;
current = current->next ;
}while (current!=NULL) ;
temp=current;
for (int i =1 ; i<n; i++){
temp = temp->next ;
}
prefPtr->next = temp->next ; ;
L.head = current ;
temp->next = L.head ;
return L ;
}





:)

Don DaVinci
07-11-10, 03:04 PM



A certain airport contains a single runway on which arriving aircraft must
land. The first aircraft is preparing to land, it will use the runway,
doesnt allow other aircraft to land. Otherwise, it waits until all aircrafts,
arrived before, landed. When the aircraft has landed, the runway is
available for use by other aircraft.
1. Give the suitable data structure to solve this problem.
2. Implement the following operations:
a. Arriving of an aircraft (add new entry).
b. Landing of an aircraft.
c. Print the aircrafts waiting for landining amd number of them

If aircrafts landed on the ground will take a certain period of time before
departing.
So, implement the following operations:
d. Print the number of landed aircrafts.



!

||
07-11-10, 03:19 PM
^^^




Michiru
07-11-10, 07:17 PM
,

Priority Queues
..
, access Queues
remove get ..

, ..
..

,
:)

Chelsea 4ever
07-11-10, 11:07 PM
^^^






.. ..~

, ..~


Chelsea 4ever
07-11-10, 11:08 PM
,

Priority Queues
..
, access Queues
remove get ..

, ..
..

,
:)

..~



Don DaVinci
08-11-10, 12:31 AM
,

Priority Queues
..
, access Queues
remove get ..

, ..
..

,
:)

-
( ) ( ) cpu cpu

..

.. !! :smile15:

Don DaVinci
08-11-10, 12:45 AM
:D


..


.. .. ( ) :smile15:
..
..

http://www.imam1.com/vb/attachment.php?attachmentid=3360&stc=1&d=1289166171

:rolleyes:

~~
08-11-10, 11:12 AM

08-11-10, 02:34 PM

:-(

11-11-10, 12:10 AM

!

,

~~
11-11-10, 01:14 AM



~~
11-11-10, 01:44 AM
3 4

Don DaVinci
11-11-10, 01:54 AM



A certain airport contains a single runway on which arriving aircraft must
land. The first aircraft is preparing to land, it will use the runway,
doesnt allow other aircraft to land. Otherwise, it waits until all aircrafts,
arrived before, landed. When the aircraft has landed, the runway is
available for use by other aircraft.
1. Give the suitable data structure to solve this problem.
2. Implement the following operations:
a. Arriving of an aircraft (add new entry).
b. Landing of an aircraft.
c. Print the aircrafts waiting for landining amd number of them

If aircrafts landed on the ground will take a certain period of time before
departing.
So, implement the following operations:
d. Print the number of landed aircrafts.

..
..



.

1-
2- :
- Arriving of an aircraft (add new entry) ( )
- Landing of an aircraft.
-
- ..

13-11-10, 04:13 AM
If aircrafts landed on the ground will take a certain period of time before
departing.

,

Don DaVinci
14-11-10, 12:57 AM
If aircrafts landed on the ground will take a certain period of time before
departing.

,

Sleep() windows.h
S

.. :)

14-11-10, 09:24 PM

R O S E M A R Y
17-11-10, 11:17 PM
::





http://www.zshare.net/download/82814060f9736937/

..

^_^

: (



,,

<<

------
18-11-10, 08:49 PM
...!

...
3 & 4 ...
...!
...!

..

18-11-10, 09:27 PM
^ ^ ^


http://sites.google.com/site/cs242website/home


18-11-10, 10:42 PM
::





http://www.zshare.net/download/82814060f9736937/

..

^_^

: (



,,

<<




------
19-11-10, 12:22 AM
^ ^ ^


http://sites.google.com/site/cs242website/home




...^_^

19-11-10, 06:26 PM
[QUOTE=R O S E M A R Y;2798916]::





http://www.zshare.net/download/82814060f9736937/

..

................................................

..

isu
20-11-10, 08:56 PM
::





http://www.zshare.net/download/82814060f9736937/

..

^_^

: (



,,

<<

()


R O S E M A R Y
20-11-10, 10:03 PM
^


/ :)


,,,,,,,,,,,,,,




..

21-11-10, 09:56 PM
.
.
R O S E M A R Y:heart:
.
.

24-11-10, 01:00 AM
.
.
..

------
24-11-10, 12:35 PM
... 4#
..
..

..!

..!

25-11-10, 10:37 AM
^^^^





------
25-11-10, 03:00 PM
^^^^^
...

..
.. ..!


..

25-11-10, 11:03 PM
Submission of sheet#3 and sheet#4 will be in Sunday before 8:00

<< :)

||
30-11-10, 06:07 PM
~
sorting


:(

Chelsea 4ever
30-11-10, 06:52 PM
^^

Tree ..~

..

R O S E M A R Y
30-11-10, 10:36 PM
~
sorting


:(




:5020:

..


||
01-12-10, 04:01 PM
Chelsea 4ever








: )

R O S E M A R Y
01-12-10, 06:51 PM
:smile13:


..



( )
: ..
: : " " / " " / " "
,,



* (increasing)


* bubble sort element <<


* " " ..


,,,,,,,,,,,,,,,,,,


sorting :
Insertion sort & Exchange sort



: Insertion sort
: Straight insertion sort
(wall)
sorted unsorted
:


:


56, 32, 8, 45, 78, |23


.. ..


56 32 8 45 | 78 23
56 32 8 | 78 45 23
56 32 | 78 45 23 8
56 | 78 45 32 23 8
| 78 56 45 32 23 8


,,



Exchange sort 2
swap ..


Bubble sort :


: " 8 2 4 1 5 "



2 .. Bold


First pass:


( 8 2 4 5 1) ( 8 2 4 1 5 )
( 8 2 5 4 1) ( 8 2 4 5 1)
(8 5 2 4 1 ) ( 8 2 5 4 1)
( 8 5 2 4 1) (8 5 2 4 1)

8 5
:


Second pass:
:

(8 5 2 4 1) ( 8 5 2 4 1)
(8 5 4 2 1) (8 5 2 4 1)
(8 5 4 2 1) (8 5 4 2 1)
(8 5 4 2 1) (8 54 2 1)

.. :


Therd pass :

(8 5 4 2 1) (8 5 4 2 1)
(8 5 4 2 1) (8 5 4 2 1)
(8 5 4 2 1) (8 5 4 2 1)
(8 5 4 2 1) (8 5 4 2 1)


.. ..


& ..


,,

:)

01-12-10, 07:41 PM
...0 R O S E M A R Y

traver tree trace recursev

02-12-10, 12:27 AM
write the binary tree PostOrder traversal algorithm using a stack instead of recursion




02-12-10, 10:40 AM
^^

,,, ..!!!

||
02-12-10, 12:39 PM
...!:heart:
..:5::5:




>>



:heart::heart:

R O S E M A R Y
02-12-10, 03:04 PM
...!:heart:
..:5::5:




>>



:heart::heart:

.. :5:

:7:

:)

||
04-12-10, 10:11 PM



04-12-10, 11:59 PM
.
.

.. = )

Binary Tree Traversals (http://nova.umuc.edu/~jarc/idsv/lesson1.html)


Binary Search Trees (http://nova.umuc.edu/~jarc/idsv/lesson4.html)

..

..

,, = $

||
05-12-10, 05:33 PM


09-12-10, 01:11 PM

:smile15:
0 " " 0 ....:1003:


#5 ...

10-12-10, 05:40 PM
.
.
.. ..

Tree Animation + Code (http://groups.engin.umd.umich.edu/CIS/course.des/cis350/treetool/index.html)

,,

[ YOYO ]
10-12-10, 11:16 PM


/

: )



. : )

LOTUS |
10-12-10, 11:37 PM
^


14 / 1 / 1432

[ YOYO ]
10-12-10, 11:39 PM
: )

||
18-12-10, 04:06 PM
\

~

LOTUS |
18-12-10, 04:30 PM
^
safaakasbah@hotmail.com

..

[ YOYO ]
18-12-10, 05:48 PM


: )

: $



: )


||
18-12-10, 06:54 PM
LOTUS




[ YOYO ]


||
18-12-10, 06:58 PM



http://sub5.rofof.com/012lnihe18/Tree.html


[ YOYO ]
18-12-10, 06:58 PM
^

: )

: )

||
23-12-10, 11:03 AM

~

||
23-12-10, 11:08 AM
sorting

\


http://www.cs.pitt.edu/~kirk/cs1501/animations/Sort1.html

immortal computer
23-12-10, 11:40 AM
^^^

2 MID TERMS


loletta
23-12-10, 04:03 PM


.. ..

[ YOYO ]
24-12-10, 02:50 PM


AVL tree



:)

24-12-10, 08:57 PM
STACK QUEUE <





- -
24-12-10, 09:57 PM
^^^

..

http://sites.google.com/site/cs242website/home/assignments

..

..

.......

Chelsea 4ever
25-12-10, 12:15 AM
...~

..
1000 .. !





#include <iostream>
using namespace std ;
class node {
public :
int data ;
node *next ;
public :
node (int d){
next=NULL;
data = d ;
}
};
class Queue{
public :
node *front ;
node *rear ;
public :
Queue ();
~Queue ();
int getSize ();
void enQueue (int d);
int deQueue ();
bool deQueue(int &RetrieveElement);
void reversQueue (Queue &Q);
void reversQueue ();
void printQueue();
void print ();
bool isEmbty ();
void printReverseWithSkip2Characters();
void choice (int data , int i);
void printBeforeValue (int sd);
void printAfterValue (int sd);
void deleteValue (int sd);
void reverseBestMethod();
void deleteAllBeforeValue (int sd);
void deleteAllAfterValue (int sd);
void addNodeBecomeFirst(int d);
bool isSort();
int deleteLast ();
void deleteDuplicate();
void copy (Queue &out);
void copySpecial(Queue &);
void swapfirstWithLast();
};
//************************** Class Stack *********************************
class Stack{
public :
node *top ;
public :
Stack ();
~Stack ();
bool isEmbty ();
int getSize ();
void push (int d);
int pop ();
bool pop (int &retrieveElement);
void printStack ();
void print ();
void reverseStack ();
void reverseStack (Stack &s);
void Combine(Stack& S1,Stack& S2);
void choice (int data , int i);
void printBeforeValue (int sd);
void printAfterValue (int sd);
void deleteValue (int sd);
void reverseBestMethod();
void deleteAllBeforeValue (int sd);
void deleteAllAfterValue (int sd);
void addNodeBecomeLast (int d);
bool isSort();
int deleteLast ();
void deleteDuplicate();
void copy (Stack &);
void copySpecial (Stack &);
void swapfirstWithLast();
};
Queue :: Queue (){
front = NULL ;
rear = NULL ;
}
//***************************
Queue :: ~Queue (){
while (!isEmbty()){
deQueue ();
}
front = NULL ;
rear = NULL ;
}
//***************************
int Queue :: getSize (){
int i = 0 ;
int d ;
Queue Q ;
while (!isEmbty()){

i++ ;
d = deQueue ();
Q.enQueue (d);
}
int c = 0 ;
while (c != i){
d = Q.deQueue() ;
enQueue (d);
c++ ;
}
return i ;
}
//***************************
void Queue :: enQueue (int d){
node *newPtr = new node (d);
if(front==NULL){
front = newPtr ;
rear = newPtr ;
}
else{
rear->next = newPtr ;
rear = newPtr ;
}
}
//***************************
int Queue :: deQueue (){
int oldData ;
node *current=front ;
if (front == NULL){
return 0 ;
}
else {
oldData = front->data ;
current = front ;
if (front == rear)
rear = NULL ;

front = front->next ;
delete current ;
}
return oldData ;
}
//******************************QUEUE*************** ***************
bool Queue :: deQueue (int &RetrieveElement){
if (front == NULL)
return false ;

node *current = front ;
RetrieveElement = front->data ;
front = front->next ;
if (front == NULL)
rear = NULL ;
delete current ;
return true ;
}
//******************************QUEUE*************** ***************
void Queue :: reversQueue (Queue &Q){
Stack S ;
while (!Q.isEmbty())
S.push (Q.deQueue());

while (!S.isEmbty())
Q.enQueue (S.pop());
}
//******************************QUEUE*************** ***************
void Queue :: reversQueue (){
Stack S ;
while (!isEmbty())
S.push (deQueue());

while (!S.isEmbty())
enQueue (S.pop());
}
//******************************QUEUE*************** ***************
void Queue :: printQueue(){
cout << "*********** Queue List ************"<<endl;
int size=getSize();
cout << "Front -> " ;
int data ;
for (int i = 0 ; i < size ; i++){
data = deQueue ();
cout << data << " -> ";
enQueue (data);
}
cout << " Rear " << endl;
}
//***************************
void Queue :: print (){
node *current = front ;
while (current != NULL){
cout << current->data << " -> ";
current = current->next ;
}
cout << endl;
}
bool Queue :: isEmbty (){
return front == NULL ;
}
//******************************QUEUE*************** ***************
void Queue::printReverseWithSkip2Characters(){
int i,Element;
Stack S;
Queue Q;

while(!isEmbty())
{
Element=deQueue();
S.push(Element);
Q.enQueue(Element);
}

while(!S.isEmbty()){
cout<<S.pop()<<endl;
i=1;
while(!S.isEmbty() && i<=2){
S.pop();
i++;
}
}
}
//******************************QUEUE*************** ***************
void Queue :: addNodeBecomeFirst(int d){
enQueue (d);
int size = getSize();
for (int i = 0 ; i < size-1 ; i++){
enQueue (deQueue());
}
}
//******************************QUEUE*************** *********************//
int Queue :: deleteLast (){
int x ;
int size = getSize ();
for (int i = 0 ; i < size-1 ; i++){
enQueue (deQueue());
}
x = deQueue ();
return x ;
}
//***************************** Queue ***********************************//
void Queue :: deleteDuplicate(){
Stack s1,s2 ;
int x , y ;
while (!isEmbty()){
s1.push (deQueue());
}
s2.push (s1.pop());
while (!s1.isEmbty()){
x = s2.pop();
y = s1.pop();
if (x != y){
s2.push (x);
s2.push (y);
}
else {
s2.push (x);
}
}
while (!s2.isEmbty()){
enQueue (s2.pop());
}
}
//***************************** Queue ***********************************//
void Queue :: printAfterValue (int sd){
Queue Q ;
int x ;
while (!isEmbty()){
x = deQueue ();
if (sd != x){
Q.enQueue (x);
}
else {
Q.enQueue (x);
while (!isEmbty()){
x = deQueue ();
cout << x << endl;
Q.enQueue (x);
}
}
}
while (!Q.isEmbty()){
enQueue (Q.deQueue());
}

}
//***************************** Queue ***********************************//
void Queue :: deleteValue (int sd){
Queue Q ;
int x ;
while (!isEmbty()){
x = deQueue();
if (x != sd){
Q.enQueue (x);
}
}
while (!Q.isEmbty()){
x = Q.deQueue();
enQueue(x);
}
}
//***************************** Queue ***********************************//
void Queue :: printBeforeValue (int sd){
Queue Q ;
int x ;
while (!isEmbty()){
x = deQueue ();
if (x == sd){
Q.enQueue (x);
break ;
}
}
while (!isEmbty()){
x = deQueue ();
Q.enQueue (x);
}
while (!Q.isEmbty()){
enQueue (Q.deQueue());
}

}
//***************************** Queue ***********************************//
void Queue :: choice (int data , int i){
int d ;
int size = getSize ();
int t = 0;
int count ;
int equation ;
for (count =1; count<=size; count++){
d=deQueue ();
enQueue (d);
if(data == d){
t=count ;
}
}
if (t != 0 && i <= count){
if (t == i){
cout << "SomeIndex !" << endl;
return ;
}
equation=(count-i)+t;
cout << "Equation : "<< equation <<endl;
for (int j = equation ; j > 0 ; j--){
d = deQueue ();
enQueue (d);
}
}
else {
cout << "WE Can't !" << endl;
}
}
//***************************** Queue ***********************************//
void Queue :: deleteAllBeforeValue (int sd){
Queue Q ;
int x ;
while (!isEmbty()){
x = deQueue ();
if (sd != x){
Q.enQueue (x);
}
else {
Q.enQueue (x);
while (!isEmbty()){
x = deQueue ();
}
}
}
while (!Q.isEmbty()){
enQueue (Q.deQueue());
}

}
//***************************** Queue ***********************************//
void Queue :: deleteAllAfterValue (int sd){
Queue Q ;
int x ;
while (!isEmbty()){
x = deQueue ();
if (x == sd){
Q.enQueue (x);
break ;
}
else {
cout << x << endl;
Q.enQueue (x);
}
}
while (!isEmbty()){
x = deQueue ();
Q.enQueue (x);
}
while (!Q.isEmbty()){
enQueue (Q.deQueue());
}
}
//***************************** Queue ***********************************//
bool Queue :: isSort(){
int x , y ;
bool check = true ;
int size = getSize() ;
for (int i = 0 ; i<size-1; i++){
x = deQueue();
y = deQueue();
if (x > y){
check = false ;
}
enQueue(x);
addNodeBecomeFirst(y);
print ();
}
enQueue (deQueue());
if (check == true )
return true ;
else
return false ;
}



//***************************** Queue ***********************************//
void Queue :: copy (Queue &out){
Queue q1,q2 , temp ;
Stack s1;
int x ;
while (!isEmbty()){
x = deQueue ();
q1.enQueue(x);
q2.enQueue(x);
}
int size = q1.getSize ();
int equation = size / 2 ;
cout << "Equation : " << equation << endl;
if (size %2 != 0)
equation+=1;
int counter = 0 ;
for (int i=0 ; i<=size; i++){
cout << i << " - " << equation << endl;
if(i == equation){
cout << "Accept " << endl;
while (!q1.isEmbty()){
temp.enQueue (q1.deQueue());
}
}
q1.deQueue();
}
while (!temp.isEmbty())
s1.push (temp.deQueue ());
while (!s1.isEmbty())
temp.enQueue (s1.pop());
temp.printQueue();
while (!q2.isEmbty()){
x = q2.deQueue ();
enQueue (x);
out.enQueue (x);
}
while (!temp.isEmbty ())
out.enQueue (temp.deQueue());
out.printQueue();
}
//***************************** Queue ***********************************//
void Queue :: copySpecial (Queue &out ){
int x , y ;
Queue q1 , q2 ;
int size = getSize ();
while (!isEmbty()){
x =deQueue();
q1.enQueue(x);
q2.enQueue(x);
}
for (int i=1; i<=x; i++){
while (!q1.isEmbty()){
y = q1.deQueue();
out.enQueue(y);
enQueue(y);
}
while (!isEmbty()){
q1.enQueue(deQueue());
}
}
while (!q2.isEmbty()){
enQueue(q2.deQueue());
}
}
//***************************** Queue ***********************************//
void Queue :: swapfirstWithLast(){
int x , y ;
Queue Q ;
Stack s1 , s2;
while (!isEmbty()){
s1.push (deQueue());
}
y = s1.pop ();
while (!s1.isEmbty()){
s2.push (s1.pop());
}
x = s2.pop ();
s2.push (y);
while (!s2.isEmbty()){
enQueue (s2.pop());
}
enQueue (x);
}
//***************************** Queue ***********************************//
//***************************** Queue ***********************************//
//***************************** Queue ***********************************//
//***************************** STACKS ***********************************//
void Stack :: copySpecial (Stack &out ){
int x , y ;
Stack s1 , s2 ;
while (!isEmbty()){
x = pop();
s1.push (x);
s2.push (x);
}
x = s1.pop();
s1.push (x);
for (int i=1; i<=x; i++){
while (!s1.isEmbty()){
y = s1.pop();
out.push(y);
push (y);
}
while (!isEmbty()){
s1.push(pop());
}
}
while (!s2.isEmbty()){
push(s2.pop());
}
}
//***************************** STACKS ***********************************//
//***************************** STACKS ***********************************//
void Stack :: Combine(Stack& S1,Stack& S2) // &#227;&#199;&#229;&#214;&#227;&#202;&#229; !!!!!!!!!!!!!!!!!
{
int val1,val2;
Stack temp , T1 , T2;
while(!S1.isEmbty() && !S2.isEmbty ())
{
val1=S1.pop();
val2=S2.pop();
if(val1<val2)
{
temp.push(val1);
T1.push(val1);
S2.push(val2);
}
else
{
temp.push(val2);
T2.push(val2);
S1.push(val1);
}
}

while(!S1.isEmbty())
{
val1=S1.pop();
T1.push(val1);
temp.push(val1);
}

while(!S2.isEmbty())
{
val2=S2.pop();
T2.push(val2);
temp.push(val2);
}

while(!temp.isEmbty())
push(temp.pop());

while(!T1.isEmbty())
S1.push(T1.pop());

while(!T2.isEmbty())
S2.push(T2.pop());
}
//***************************** STACKS ***********************************//

Stack :: Stack (){
top = NULL ;
}
Stack :: ~Stack (){
node *current;
while (top != NULL){
pop ();
}
}
//***************************** STACKS ****************************
bool Stack :: isEmbty (){
return top == NULL ;
}
//***************************** STACKS ****************************
int Stack :: getSize (){
int i = 0 ;
int d ;
Stack S ;
while (!isEmbty()){
d = pop ();
S.push (d);
i++ ;
}
while (!S.isEmbty ()){
d = S.pop ();
push (d);
}
return i++ ;
}
//***************************** STACKS ****************************
void Stack :: push (int d){
node *newPtr = new node (d);
if (top == NULL)
top = newPtr ;
else {
newPtr->next = top ;
top = newPtr ;
}
}
//***************************** STACKS ****************************
int Stack :: pop (){
if (top == NULL)
return 0 ;
int data ;
node *current = top ;
data = top->data ;
top = top->next ;
delete current ;
return data ;
}
//***************************** STACKS ****************************
bool Stack :: pop (int &retrieveElement){
node *current = top ;
if (top == NULL)
return false ;
retrieveElement = top->data ;
top = top->next ;
delete current ;
return true ;
}
//***************************** STACKS ****************************
void Stack :: printStack (){
Stack S ;
int size = getSize();
int d ;
cout << "*********** Stack List ************"<<endl;
cout << "Top -> " ;
for (int i = 0 ; i < size ; i++){
d = pop ();
cout << d << " -> " ;
S.push (d);
}
cout << endl;
while (!S.isEmbty()){
d = S.pop ();
push (d);
}
}
//***************************** STACKS ****************************
void Stack :: print (){
node *current = top ;
while (current != NULL){
cout << current ->data << " -> ";
current = current->next ;
}
}
//***************************** STACKS ****************************
void Stack :: reverseStack (){
Queue Q ;
while (!isEmbty())
Q.enQueue (pop());

while (!Q.isEmbty())
push (Q.deQueue());
}
//***************************** STACKS ****************************
void reverseStack (Stack &s){
Queue Q ;
while (!s.isEmbty())
Q.enQueue (s.pop());

while (!Q.isEmbty())
s.push (Q.deQueue());
}
//***************************** STACKS ****************************
void Stack :: choice (int data , int i){
int d ;
int size = getSize ();
int t = 0;
int count ;
int equation ;
Queue Q ;
for (count =1; count<=size; count++){
d=pop ();
Q.enQueue (d);
if(data == d){
t=count ;
}
}
if(t != 0 && i <= size ){
if (t == i){
cout << "SomeIndex !" << endl;
return ;
}
equation=(size-i)+t;
cout << "Equation : "<< equation <<endl;

for (int j = 1 ; j <= equation ; j++){

d = Q.deQueue();
Q.enQueue (d);
cout << "&&&&&&&&&&&&&&&&&&&&&&&&"<< endl;
Q.print ();
cout << "&&&&&&&&&&&&&&&&&&&&&&&&"<< endl;
}

while (!Q.isEmbty()){
d = Q.deQueue ();
push (d);
}
while (!isEmbty()){
d = pop ();
Q.enQueue (d);
}
while (!Q.isEmbty()){
d = Q.deQueue ();
push (d);
}
}
else {
cout << "ERROR : " << endl;
}

}
//***************************** STACK ***********************************//
void Stack :: printAfterValue (int sd){
Stack S ;
int x ;
while (!isEmbty()){
x = pop();
if (sd != x){
S.push (x);
}
else {
S.push (x);
while (!isEmbty ()){
x = pop();
cout << x << endl;
S.push (x);
}
}
}
while (!S.isEmbty()){
push (S.pop());

}
}
//***************************** STACKS ***********************************//
void Stack :: printBeforeValue (int sd){
Stack S ;
int x ;
while (!isEmbty()){
x = pop();
if (sd == x){
S.push (x);
break ;
}
else {
cout << x << endl;
S.push (x);

}
}
while (!isEmbty ()){
x = pop();
S.push (x);
}
while (!S.isEmbty()){
push (S.pop());

}
}
//***************************** STACKS ***********************************//
void Stack :: deleteAllAfterValue (int sd){
Stack S ;
int x ;
while (!isEmbty()){
x = pop();
if (sd != x){
S.push (x);
}
else {
S.push (x);
while (!isEmbty ()){
x = pop();
}
}
}
while (!S.isEmbty()){
push (S.pop());

}
}
//***************************** MAIN ***********************************//
void Stack :: deleteAllBeforeValue (int sd){
Stack S ;
int x ;
while (!isEmbty()){
x = pop();
if (sd == x){
S.push (x);
break ;
}
}
while (!isEmbty ()){
x = pop();
S.push(x);
}
while (!S.isEmbty()){
push (S.pop());

}
}
//***************************** STACK ***********************************//
void Stack :: deleteValue (int sd){
Stack S ;
int x ;
while (!isEmbty()){
x = pop();
if (x != sd){
S.push (x);
}
}
while (!S.isEmbty()){
x = S.pop();
push (x);
}
}
//***************************** Stacks ***********************************//
void Stack :: reverseBestMethod(){
Stack s1 , s2 ;
while (!isEmbty()){
s1.push (pop());
}
while (!s1.isEmbty()){
s2.push (s1.pop());
}
while (!s2.isEmbty()){
push (s2.pop());
}
}
//***************************** STACK ***********************************//
void Stack :: addNodeBecomeLast (int d){
Queue Q ;
Stack S ;
while (!isEmbty()){
Q.enQueue(pop());
}
Q.enQueue (d);
while (!Q.isEmbty()){
S.push(Q.deQueue());
}
while (!S.isEmbty()){
push(S.pop());
}
}
//***************************** STACK ***********************************//
bool Stack :: isSort(){
int x , y ;
bool check = true ;
int size = getSize() ;
for (int i = 0 ; i<size-1; i++){
x = pop();
y = pop();
if (x > y){
check = false ;
}
push(y);
addNodeBecomeLast(x);
/*cout <<endl;
print ();
cout<<endl;*/
}
addNodeBecomeLast(pop());
if (check == true )
return true ;
else
return false ;
}
//***************************** STACK ***********************************//
int Stack :: deleteLast (){
int x ;
int size = getSize ();
Stack S ;
Queue Q ;
while(!isEmbty()){
Q.enQueue (pop());
}
for(int i = 0 ; i < size-1 ; i++){
Q.enQueue (Q.deQueue());
}
x = Q.deQueue ();
while (!Q.isEmbty()){
S.push (Q.deQueue());
}
while (!S.isEmbty()){
push (S.pop());
}
return x ;
}
//***************************** STACK ***********************************//
void Stack :: deleteDuplicate(){
int x , y ;
Queue Q ;
Stack s1 ;
s1.push(pop());
while (!isEmbty()){
x = s1.pop ();
y = pop ();
if (x != y){
s1.push (x);
s1.push (y);
}
else
s1.push (x);
}
while (!s1.isEmbty ())
push (s1.pop());
}
//***************************** STACK ***********************************//
void Stack :: copy (Stack &out){
Stack s1,s2 ;
int x ;
while (!isEmbty()){
x = pop ();
s1.push (x);
s2.push (x);
}
int size = s1.getSize ();
for (int i=0 ; i<(size/2); i++){
push (s1.pop());
}
while (!isEmbty()){
out.push (pop());
}
while (!s2.isEmbty()){
x = s2.pop();
push (x);
out.push (x);
}
}
//***************************** STACK ***********************************//
void Stack :: swapfirstWithLast(){
int x , y ;
Stack s1 ;
x = pop();
while (!isEmbty()){
s1.push(pop());
}
y = s1.pop ();
push (x);
while (!s1.isEmbty()){
push (s1.pop());
}
push (y);
}
//***************************** STACK ***********************************//
void copyStackExcptTopAndBottom (Stack &source , Stack &dest){
Stack s ;
Queue q ;
int x , y , z ;
x = source.pop();
while (!source.isEmbty ())
s.push (source.pop());
y = s.pop();
while (!s.isEmbty ()){
z = s.pop () ;
dest.push (z);
source.push(z);
}
source.push(x);
while (!source.isEmbty())
s.push (source.pop());

source.push (y);

while (!s.isEmbty())
source.push (s.pop());

}
//***************************** STACK ***********************************//
int main (){
cout << " ::: Queue ::: \n"<< endl;
int element ;
Queue Q1,out1;
Q1.enQueue (1);
Q1.enQueue (2);
Q1.enQueue (3);
Q1.enQueue (4);
Q1.swapfirstWithLast();
//Q1.copySpecial (out1);
//Q1.copy (out1);
//Q1.deleteDuplicate();
//cout << "The remover : "<< Q1.deleteLast ()<<endl;
//cout << Q1.isSort() << endl;
//Q1.addNodeBecomeFirst(10);
//Q1.deleteAllBeforeValue (4);
//Q1.printBeforeValue (1);
//Q1.printAfterValue (2);
//Q1.printBeforeValue (2);
//Q1.deleteValue (1);
Q1.printQueue();
out1.printQueue();
//Q1.reversQueue ();
//Q1.print (); //imprtant to Sure U'r program
//Q1.deQueue(element);
//cout << "The Element = : " << element << endl;
//Q1.printReverseWithSkip2Characters();
//Q1.choice (4,4);
//Q1.printQueue();


//+_+_+_+_+_+_+_+_+_+_+_STACKS_+_+_+_+_+_+_+_+_+_+_+ _+_+_+

cout << "\n ::: STACK ::: \n"<< endl;
Stack s1,out,source ,dest ;
s1.push (4);
s1.push (3);
s1.push (2);
s1.push (1);
//s1.swapfirstWithLast();
copyStackExcptTopAndBottom (s1,dest);
//s1.copySpecial (out);
//s1.copy (out);
//s1.deleteDuplicate();
//cout <<"The Remover : "<<s1.deleteLast()<<endl;
//cout << "The Result : "<<s1.isSort() << endl;
//s1.printStack ();
cout << endl;
//s1.pop (element);
//cout << "The Element = : " << element << endl;
//s1.reverseStack ();
//s2.Combine(s1,s2);
//s1.choice (4,1);
//s1.printAfterValue (2);
//s1.printBeforeValue (2);
//s1.deleteValue (4);
//s1.print ();
//s1.reverseBestMethod8();
//s1.deleteAllBeforeValue (2);
//s1.deleteAllAfterValue (2);
//s1.addNodeBecomeLast (10);
s1.printStack ();
dest.printStack ();
getchar ();
getchar ();
return 0;
}

26-12-10, 09:17 PM




Don DaVinci
27-12-10, 07:08 PM







^

!

27-12-10, 08:58 PM
^ ^ ^

Depth first traversal .. ߿!






;2840617']

AVL tree



:)


.!

..

27-12-10, 09:31 PM



27-12-10, 09:37 PM
[QUOTE= ;2846800]^ ^ ^

Depth first traversal .. ߿!








............

- -
28-12-10, 10:31 AM
..


...



....

R O S E M A R Y
28-12-10, 04:46 PM
^^

!

LOTUS |
28-12-10, 07:02 PM
&


:")

R O S E M A R Y
28-12-10, 07:13 PM
^




~~
30-12-10, 09:46 PM
....


05-01-11, 01:39 PM
60

:/

LOTUS |
05-01-11, 03:38 PM
^
:D
: )

1 2

60 60 :D
20 + 20 + 5 = 45
5
10 : )
+

||
05-01-11, 07:34 PM


5
10


06-01-11, 04:36 PM
TREE lab exam

08-01-11, 02:53 PM
.. =) ..

LOTUS |
08-01-11, 04:35 PM
^
safaakasbah@hotmail.com

08-01-11, 05:17 PM
shotest path

08-01-11, 07:03 PM

:)

08-01-11, 09:47 PM
8

,,

09-01-11, 07:23 PM
Algorithm
Algorithm


http://www.rofof.com/dw.png (http://sub3.rofof.com/01fxajp9/Algorithm.html)

2009
09-01-11, 08:24 PM



http://www.uqucs.com/vb/showthread.php?t=9646


40

Miss.Ghost
09-01-11, 08:43 PM
Algorithm
Algorithm


http://www.rofof.com/dw.png (http://sub3.rofof.com/01fxajp9/Algorithm.html)

..!

09-01-11, 09:41 PM
8

,,

http://www.imam1.com/vb/showthread.php?t=139399&p=2866220&viewfull=1#post2866220
http://www.imam1.com/vb/showthread.php?t=139399&p=2866272&viewfull=1#post2866272

LOTUS |
09-01-11, 09:44 PM
..!

http://sub3.rofof.com/01fxajp9/Algorithm.html
http://blog.eqla3.com/mkportal/modules/gallery/album/a_4071.png

09-01-11, 09:47 PM
..!


http://www.4shared.com/file/pBgznKq8/algorithm.html?

[ YOYO ]
09-01-11, 10:21 PM
^



Graph

: )

: )

||
09-01-11, 11:13 PM
8

,,

http://www.m5zn.com/uploads/2011/1/6/photo/010611020140sqursyh.png

||
09-01-11, 11:17 PM
;2875917']
^



Graph

: )

: )






You will not be asked to write a graph algorithm, we didnt take the graph algorithms in class, so you will not be asked to write a graph algorithm, but you are responsible to know about the MST and the dijkastra, how they work and how to find the MST and the shortest path of a graph....


09-01-11, 11:56 PM
.
.
graph traversal

http://www.youtube.com/watch?v=or9xlA3YYzo

....

.. =(

[ YOYO ]
10-01-11, 12:01 AM
eng. s!lence





: )

: )

:smile11:

Chelsea 4ever
14-01-11, 08:01 PM
B-tree
http://www.imam1.com/vb/showthread.php?t=162763

16-01-11, 04:08 AM



16-01-11, 08:50 PM
^



immortal computer
18-01-11, 05:37 PM
,,