1. 2-1 تعريف الگوريتم الگوريتم مجموعه اي از دستورالعمل ها است که
2-1 تعريف الگوريتم
الگوريتم مجموعه اي از دستورالعمل ها است که
اگر دنبال شوند، موجب انجام کار خاصي مي گردد

2. 2-1 شرايط الگوريتم
ورودي: يک الگوريتم مي تواند هيچ يا چندين کميت ورودي داشته باشدکه از محيط خارج تامين مي شود.
خروجي: الگوريتم بايستي حداقل يک کميت به عنوان خروجي داشته باشد.
قطعيت: هر دستورالعمل بايد واضح و بدون ابهام باشد.
محدوديت: اگر دستورالعمل هاي يک الگوريتم را دنبال کنيم ،براي تمام حالات ، الگوريتم بايد پس از طي مراحل محدودي خاتمه يابد.
کارايي: هر دستورالعمل بايد به گونه اي باشد که با استفاده از قلم و کاغذ بتوان آن را با دست نيز اجرا نمود.

3. 2-1 مثالی از الگوريتم: الگوریتم مرتب سازي
2-1 مثالی از الگوريتم: الگوریتم مرتب سازي
از اعداد صحیحی که مرتب نیستند کوچکترین عدد را پیدا و به دنبال اعداد مرتب شده قرار دهید
ورودی: n عدد در یک آرایه به نام x
خروجی :آرایه مرتب شده به صورت صعودی
1- برای i=0 تا n مراحل زیر را انجام بده
در گذر i ام ابتدا کوچکترین عنصر x[i] تا x[n-1] را پیدا کن //
2- min=i
3- برای j=i+1 تا n-1 عملیات زیر را انجام بده
4- اگر x[i]<x[min] آنگاه
5- min=i
6- جابجایی کوچکترین عنصر با i امین عنصر

4. 2-1 مثال الگوريتم جستجوي دودويي
int binsearch ( int list [ ] ، int searchnum ، int left ، int right ) {
/* search list [0] <= list [1] <= … <=list [ n-1 ] for searchnum Return its position if found . Otherwise return -1 */
int middle ;
if (left <= right ) {
middle = ( left + right ) / 2 ;
switch ( COMPARE ( list [ middle ] ، searchnum )) {
case -1 : return
binsearch ( list ، searchnum ، middle +1 ، right ) ;
case 0 : return middle ;
case 1 : return
binsearch ( list ، searchnum ، left ، middle -1 ) ; }
return -1 ;

5. 4-1 تحليل نحوه اجراي يک برنامه
معيارهاي محک زدن يک برنامه
آيا برنامه اهداف اصلي کاري را که مي خواهيم، انجام مي دهد؟
آيا برنامه درست کار مي کند؟
آيا برنامه مستند سازي شده است تا نحوه استفاده و طرز کار با آن مشخص شود؟
آيا برنامه براي ايجاد واحدهاي منطقي ، به طور موثر از توابع استفاده مي کند؟
آيا کد گذاري خوانا است؟
اصلاح عادات برنامه نویسی

6. Measurements Criteria Is it correct? Is it readable? …
Performance Analysis (machine independent)
space complexity: storage requirement
time complexity: computing time
Performance Measurement (machine dependent)

7. 4-1 ميزان حافظه يا پيچيدگي فضاي يک برنامه
ميزان حافظه يا پيچيدگي فضاي يک برنامه مقدارحافظه
مورد نيازبراي اجراي کامل يک برنامه است.
ميزان يا پيچيدگي زمان يک برنامه مقدار زماني از کامپيوتر
است که براي اجراي کامل برنامه لازم است.

8. نيازمنديهاي فضاي متغير
4-1 ميزان حافظه
فضاي مورد نياز يک برنامه شامل موارد زير است :
اين مطلب به فضاي مورد نيازي که به تعداد و اندازه ورودي و خروجي بستگي ندارد، اشاره دارد.(فضا دستورالعمل- متغیرهای ثابت و....
اين مورد شامل فضاي مورد نياز متغيرهاي ساخت يافته اي است که اندازه آن بستگي به نمونه I از مساله اي که حل مي شود، دارد.(متغیرهای مرجع- بازگشت پشته ....)
نيازمنديهاي فضاي ثابت
نيازمنديهاي فضاي متغير

9. Space Complexity S(P)=C+SP(I)
Fixed Space Requirements (C) Independent of the characteristics of the inputs and outputs
instruction space
space for simple variables, fixed-size structured variable, constants
Variable Space Requirements (SP(I)) depend on the instance characteristic I
number, size, values of inputs and outputs associated with I
recursive stack space, formal parameters, local variables, return address

10. 4-1 ميزان حافظه(ادامه) نيازمنديهاي فضاي کل نيازمنديهاي فضاي ثابت
نيازمنديهاي فضاي متغير

11. Space Complexity
float abc(float a, float b, float c) {
return a + b + b*c + (a+b-c) / (a+b) + 4.0; }
Space required for this function is independent of inputs, so Sabc = 0

12. Space Complexity
float sum(float *a, const int n) {
float s = 0;
for (int i =0; i < n; i++) s += a[i];
return s; }
Summing over an entire array, problem size = array length [n]. Need four words - one word apiece for a, n, s, i. Again requirements for this function are independent of inputs, so Ssum = 0

13. Space Complexity
float rsum(float *a, const int n) {
if (n <= 0) return 0;
else return (rsum(a, n-1) + a[n-1]); }
Summing over an entire array, problem size = array length [n]. Need four words - one word apiece for a, n, s, i.
Every recursive call needs those four words, and depth of recursion is n + 1 (base = 0, 1..n)
Requirements for this function are dependent on inputs, so Srsum = 4(n+1)

14. زمان T(P) برنامه T(P) = compile time(Tc) + run time(Tp)
زمان اجراي برنامه.
زمان کامپايل مشابه اجزاي فضاي ثابت است زيرا به
خصيصه هاي نمونه بستگي ندارد.
را به صورت زير تعريف مي شود:

15. یک مرحله از برنامه توضیحات 0 اعلان 0 انتساب 1 a = 2 (one step) a = 2
یک مرحله از برنامه توضیحات 0 اعلان 0 انتساب 1 a = 2 (one step) a = 2 * b + 3 * c / d – e + f / g (one step) if 1 دستورات تکرار دستورات مدیریت حافظه

16. Time Complexity in C++ Context
Comments:
Not executed
Step count = 0
Declarations: (int b; )
Either not executable or lumped into cost of calling function

17. C++ Time Complexity Expressions: (for example: a == true)
Generally step count = 1
If expression contains functions, sum of costs for function invocations (defined later)
Assignments: <variable> = <expression>
Generally, step count for evaluation of expression
If variable size dependent on instance,
step count = size of variable + expression step count
I.E. a = (2+b); a,b both lists, then:
step count = cost of evaluating expression (2+b) + cost of copying list b into list a

18. C++ Time Complexity Iteration:
Consider loop control elements, not internal statements of the loop body
While <expr> do
Do… while <expr>
For (<init_stmt>; <expr1>; <expr2>)
while, do: Each iteration requires step count of <expr>
for:
Generally 1 for each iteration unless <init_stmt>, <expr1>, <expr2> dependent on size
1st time (initialize, test) = <init_stmt> steps + <expr1> steps
All other times (update, test) = <expr1> steps + <expr2> steps
Generally have to count iterations + 1 (all true iterations where fall into body plus one where the condition fails)

19. C++ Time Complexity Switch statement:
switch <expr> { case cond1: <statement1> case cond2: <statement2> default: <statement>}
Header: <expr> steps
Conditions: Cost of own check plus cost of all preceding checks
If/else:
If (<expr>) <statements1>; else <statements2>
<expr> = true: <expr> +<statements1> cost
<expr> = false: <expr>+ <statements2> cost

20. C++ Time Complexity Function invocation: Step cost of 1 generally
Pass by value parameters: If variable size dependent on problem instance, add step cost of size (to do copy)
If recursive, include all copies of local variables that are size dependent because must be generated in recursive call

21. C++ Time Complexity Memory management: new/delete
Step cost 1 generally
If call constructor, destructor, compute similar to function invocation (take into account cost of pass by value parameters)
Jump statements: continue/ break/ goto/ return / return<expr> :
Step cost 1 for continue/break/goto/return
return <expr>: Cost of <expr>

22. Measuring Complexity float sum(float *a, const int n) { float s = 0;
for (int i =0; i < n; i++) s += a[i];
return s; }
count++; // assignment
for (int i =0; i < n; i++)
{ count++; s += a[i]; count++;} // 1 for for , 1 for +=
count ++; // last time checking for
return s;
count ++; // return statement }

23. Measuring Complexity Strip out everything except count statements:
float sum(float *a, const int n) {
count++; // assignment
for (int i =0; i < n; i++)
{ count = count + 2;} // 1 for for, 1 for +=
// last time checking for and return statement
count = count + 2; }

24. Measuring Complexity:
Sum all count statements:
1 at beginning
+ (N iterations of loop) * (2 within a loop)
+ 2 at end
=> 2N + 3

25. Measuring Complexity float rsum(float *a, int n) {
if (n <= 0) return 0;
else return (rsum(a, n-1) + a[n-1]); }
count ++; // if conditional
if (n <= 0) { count++; return 0;} // return
else { count++; return (rsum(a,n-1) + a[n-1]);
// return statement
How to handle recursion?

26. Measuring Complexity: Recursion
float rsum(float *a, cont int n) {
count ++; // if conditional
if (n <= 0) { count++;} // return
else { count++; return (rsum(a,n-1) + a[n-1]); }
If (n <= 0) count = 2
Otherwise count = 2 + count(n-1)

27. Measuring Complexity: Recursion
2 + count(n-1) Recurrence relation
Solve by repeatedly substituting count(n-1) with its recursive definition
=> 2+ count(n-1)
= count(n-2)
= count(n – 3) …
= 2 * n + count(0) => 2n + 2

28. Time Complexity Iterative Sum: 2n + 3 Recursive Sum: 2n + 2
Is recursive sum faster than iterative?
Not necessarily – Each step of recursive sum may actually
be more expensive than a step of iterative sum
Not a problem - We are really interested in measurements
in relation to input size, which we see are very similar.

29. Time Complexity 2n + 2 => Run time is linear in N
If input grows by a factor of 10, execution time should grow by a factor of 10
If input grows by a factor of 10,000, cost should grow by a factor of 10,000
Xn + C => Xn often dominates constant term so we often ignore C

30. Time Complexity Matrix addition example:
void add(matrix a, matrix b, matrix c, int m, int n) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
c[i][j] = a[i][j] + b[i][j] }

31. Time Complexity void add(matrix a, matrix b, matrix c, int m, int n) {
for (int i = 0; i < m; i++) {
count++; // for loop
for (int j = 0; j < n; j++) {
c[i][j] = a[i][j] + b[i][j]
count++; // assignment }
count ++; // last time through for loop on j
count++; // last time through for loop on i

32. Time Complexity void add(matrix a, matrix b, matrix c, int m, int n) {
for (int i = 0; i < m; i++)
count = count + 2; // for loop start, last time on j [case 1]
for (int j = 0; j < n; j++)
count = count + 2; } // for loop start, assignment [case 2] }
count++; // last time through for loop on i [case 3]
=> 2m [case 1]+ 2mn [case 2] + 1 [case 3]

33. Time Complexity Matrix addition: 2mn + 2m + 1 What does that tell us?
Potential speedup: If m >> n, then we might want to switch order of loops, can change 2m to 2n in the middle
In general – dominated by 2mn statement

34. Measuring Complexity First approach: Add count statements
Second approach: Tabulation method
Steps per execution of each statement
Frequency of each statement

35. Tabular Method for Complexity
float sum(float *a, const int n)
1 {
2 float s = 0;
for (int i =0; i < n; i++)
s += a[i];
5 return s; 6}
Line S/E Freq Total
0 1 0
1 1 1
n+1 n+1
n n
Total: 2n+3

36. Tabular Method for complexity
Line S/E Freq Total
=0 >0 =0 >0 2b
3 1 + tn tn-1
Total: n = 0 => 2
n > 0 => 2+ tn-1
float rsum(float *a, const int n)
1 {
2 if (n <= 0) return 0;
3 else return (rsum(a, n-1) + a[n-1]); 4}

37. Tabular Method for Complexity
void add(matrix a, matrix b, matrix c, int m, int n) {
1 for (int i = 0; i < m; i++)
2 for (int j = 0; j < n; j++)
3 c[i][j] = a[i][j] + b[i][j] }
Line S/E Freq Total
1 m m+1
1 m(n+1) mn+m
1 mn mn
Total: 2mn + 2m + 1

38. Time Complexity
Best-Case: Minimum number of steps that can be executed for the given parameters
Worst-Case: Maximum number of steps that can be executed for the given parameters
Average-Case: Average number of steps that can be executed for the given parameters

39. علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
هدف از تعيين تعداد مراحل، مقايسه پيچيدگي دو برنامه که يک تابع را اجرا مي کنند و پيش بيني رشد و افزايش زمان اجرا با تغيير صفات نمونه مي باشد.
تشخیص یک مرحله خود دقیق نیست
مگر تعداد مراحل با هم اختلاف زیاد داشته باشند
3n+3
100n+10

40. Time Complexity T(A) = c1n2 + c2n T(B) = c3n
Consider c1 = 5, c2 = 3, c3 = 100
When is cost of algorithm A > cost of algorithm B?
(When do we not want to use A anymore?)
5n2 + 3n > 100n => 5n2 > 97n
=> 5n > 97
=> n > 19.4
19.4 is the breakpoint

41. Big “Oh” Notation Defines relationships between functions
F(n) is O(g(n)) if
Exists c and n0 > 0 such that f(n) <= cg(n) for all n, n >= n0
3n + 2 is O(n) because:
3n+2 <= 4n for all n >= 2 (c = 4, n0 = 2)

42. Big “Oh” notation 10n2 + 4n + 2 is O(n2) because:
10n2 + 4n + 2 < 11n2 for all n >= 5 (c = 11, n0 = 5)
10n2 + 4n + 2 is not O(n) because:
there do not exist any c or n0 for which
10n2 + 4n + 2 is < cn for all n >= n0

43. Big “Oh” Notation
f(n) = O(g(n)) statement provides an upper bound on the value of f(n)
Not necessarily the best upper bound:
Want to use minimum upper bound you can find
F(n) = 4n + 2 is O(n) and O(n2) and O(n3).. => Use O(n)

44. Big “Oh” notation O(1) = constant O(n) = linear O(n2) = quadratic
O(n3) = cubic
O(log n) = logarithmic
O(2n) = exponential
O(1) <O(log n) <O(n)<O(n2)<O(n3)< O(2n)

45. 4-1علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
3n+2=O(n) /* 3n+24n for n2 */
3n+3=O(n) /* 3n+34n for n3 */
100n+6=O(n) /* 100n+6101n for n10 */
10n2+4n+2=O(n2) /* 10n2+4n+211n2 for n5 */
6*2n+n2=O(2n) /* 6*2n+n2 7*2n for n4 */
5n + 4 = O(n)
100n + 6 = O(n)
10 n2 + 4n + 2 = O(n2)
6*2n + n2 = O(2n)
3n + 2  O(1)
O(1) <O(log n) <O(n)<O(n2)<O(n3)< O(2n)

46. 4-1علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
O(n) : يک تابع خطي ناميده مي شود
: تابع درجه دو ناميده مي شود
قضيه :
اگر باشد، بنابراين
خواهد بود

47. 4-1 علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
تعريف:]امگا [: f(n)=Ω(g(n)) مي باشد(خوانده مي شود f(n) امگاي g(n) اگر و فقط اگر به ازاي مقادير ثابت مثبت c و n0 ، f(n)≥cg(n) باشد(براي تمام مقادير n به شرطي که n≥n0 باشد)
قضيه :
اگر باشد، و
بنابراين خواهد بود

48. 4-1علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
3n+2= Ω(n) /* 3n+2  3n for n1*/
100n+6= Ω(n) /* 100n+6  100n for n1 */
10n2+4n+2= Ω(n2) /* 10n2+4n+2  n2 for n1 */
6*2n+n2= Ω(2n) /* 6*2n+n2  2n for n1 */

49. Omega Notation Ω(g(n)) provides a lower bound on computation time
Should use tightest lower bound you can find

50. 4-1 علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
تعريف تتا[Theta] : f(n) = θ(g(n)مي باشد (خوانده مي شود f(n) تتاي (g(n) اگر و فقط اگر به ازاي مقادير ثابت c1 و c2 و n0، c1g(n)<= f(n) <= c2g(n) وجود داشته باشد (براي تمام مقاديرn>=n0)
نشانه گذاري تتا از دو نشانه گذاري ذکر شده “ big oh “ و امگا دقيق تر مي باشد . f(n) = Θ(g(n)) مي باشد اگر و فقط اگر g(n) هم به عنوان کرانه بالا و هم به عنوان کرانه پايين در f(n) باشد.

51. 4-1 علامت گذاري مجانبي(O، Ω ،Θ)(Asymptotic)
قضيه :
اگر باشد، و
بنابراين خواهد بود

52. 4-1 مثال(پيچيدگي جمع ماتريس ها)
Asymptotic complexity
Statement
Θ(rows)
Θ(rows.cols)
Void add (int a []MAX-SIZE…) {
int I،j;
For(i=0;i<rows ; i++)
For[j=0 ; j<cols ; j++)
C[i][j]=a[i][j]+b[i][j]; }
Total

53. Theta Notation f(n) = Θ(g(n)) iff
Exist positive constants c1, c2, and n0 such that c1g(n) <= f(n) <= c2g(n) for all n, n >= n0
3n + 2 is Θ(n) because:
3n + 2 <= 4n for all n >= 2 O(n)
3n + 2 >= 3n for all n >= 2 Ω(n)
Θ(g(n)) provides a tight upper and lower bound on f(n)

54. Graphs Points to notice:
f(n)
cg(n)
f(n) is O(g(n)) N
f(n)
cg(n)
f(n) is (g(n)) N
f(n)
c2g(n)
c1g(n)
f(n) is (g(n)) N
Points to notice:
What happens near the beginning (n < N) is not important
In the third diagram, c1g(n) and c2g(n) have the same “shape” (why?)

56. nlogn n
logn

58. 5-1روش هاي اندازه گيري زمان رويدادها
int seqsearch (int *a, const int n, const int x ) {
int i = n; a[0] = x;
while (a[i] != x) i--;
return i; }

59. void TimeSearch (const long m) {
int a[1001], n[20];
for ( int j = 1; j<=1000; j++ ) a[j] = j; // 初始化a
for ( j=0; j<10; j++ ) { // n的取值
n[j] = 10*j; n[j+10] = 100*( j+1 ); }
cout << “ n 总时间 运行时间” << endl;
for ( j=0; j<20; j++ ) {
long start, stop;
time (&start); // 开始计时
for ( long b=1; b <= m; b++ )
int k = seqsearch(a, n[j], 0 ); // 失败查找
time (&stop); // 停止计时
long totalTime = stop - start;
float runTime = (float) (totalTime) / (float)m;
cout <<" "<<n[j]<<" "<<totalTime<<" "<<runTime<<endl;