View
227
Download
3
Embed Size (px)
Citation preview
Data Structures: Sorts, CS, TAU
1
שמושים ביישומים רבים•
K1,…..,Knרשומות, לכל רשומה מפתח: n יש •
רוצים לסדר את הרשומות כך שהמפתחות לא •בסדר יורד
)יתכנו כפולים(
לא קריטריונים ליעילות: •תמיד זהה
מספר פעולות
מספר השוואות בין מפתחות
Insertion Sortמיון הכנסה ( 2
,A[1]]דואגים שהאלמנטים i איטרציה ה - ….,A[i
נמצאים בסדר יחסי תקין )על ידי החלפות( 3 )Selection Sort
,A[i]]בוחרים את הקטן ביותר בין i בשלב ה - …,A[n
.i ושמים במקום ה
שיטות פשוטות:שיטות פשוטות:
1 )Bubble Sort
הקל צף כלפי מעלה -
1
2
3
4
5
6
Data Structures: Sorts, CS, TAU
2
סיבוכיותסיבוכיות
ספירת פעולות
כל האלגוריתמים: חסם עליון -
חסם תחתון-
O(N2)
(N2)
2 )Insertion - גם בשיטת החלפות לכן דומה לBubble
ספירת החלפות
- רלבנטי כשגודל הרשומה גדול
1 )Bubble-
אם הן מסודרות יחסית - לא , A[i], A[j ]שתי רשומות - יתחלפו
אחרת- יתחלפו בדיוק פעם אחת!!
- ניקח שני סדרים:
מסודרים ובשני אינם מסודרים Ki,Kj באחד
L1 = K1,…,Kn
L2 = Kn,…,K1
כל זוג יתחלף בממוצע בחצי מהפעמים
n(n-1)/2- מספר הזוגות
n(n-1)/4מספר החלפות ממוצע
Data Structures: Sorts, CS, TAU
3
3 )Selection Sort-
רוב העבודה בהשוואת מפתחות ולא - בהחלפת רשומות.
O(N) - מספר החלפות
עצה שימושית:
החזק פוינטרים לרשומות•אם הרשומות כבדות:
מיין פוינטרים•
O(N) לאחר מיון, הזז רשומות ב •צעדים
סיכום:
(n2), O(n2)- אלגוריתמים פשוטים:
O(nlogn)אלגוריתמים יעילים: -
נקודת חיתוך להחלטה:-
תלויה בהרבה גורמים- מאות - אלפים
Data Structures: Sorts, CS, TAU
4
QUICKSORTQUICKSORT
O(nlogn)סבוכיות: ממוצע
O(n2)גרוע ביותר
במקום A[j],…., A[i]מיון של האיברים
שיטה:
,A[j]]אחד מערכי )V( בחר פיבוט, 1…..,A[i)
כך ש: k ( מצא )וארגן( נקודה2
A[j],…..,A[k]מופיעים ב- V הערכים הקטנים מ-
A[k+1],…..,A[i]מופיעים ב- Vוהגדולים שווים ל-
A[k+1],…..,A[i]ו- A[j],…..,A[k]( מיין את 3רקורסיבית
דוגמא לפיבוט:
האיבר הגדול ביותר בין השניים השונים זה מזה משמאל
Data Structures: Sorts, CS, TAU
5
האלגוריתם מורכב מ:
FindPivot( מציאת פיבוט 1
Partitionחלוקה ( 2
רקורסיה( 3
1 )FindPivot
לך משמאל לימין ומצא את הגדול הראשון מבין השניים
2 )(Partition (pivot
.L, R השתמש בשני סמנים
R מתחיל מימין וזז שמאלה
L מתחיל משמאל וזז ימינה
שמאלה כל עוד הערכים גדולים שווים R. הסע 1Pivotמ
Pivotימינה כל עוד הערכים קטנים מ Lהסע . 2
עצור. L>R אם . 3
R ו- L אחרת: החלף בין האיברים של
שמאלה R הזז
ימינה L הזז
. 1חזור ל
(R = L - 1)
Data Structures: Sorts, CS, TAU
6
פרט לקריאה הרקורסיבית,- QuickSortב(
הכל לינארי במספר האלמנטים
סכם על כל האלמנטים את מספר זמן כולל: הפעמים
שמשתתפים בקריאה
)כולם( סכום העומקים של האלמנטים=
ניתוח סיבוכיות:
O(j - i)לוקחת Partition(i, j)א( נראה ש + 1
התחשבנות עם כל איבר-
- לכל איבר מתבצע:
א( הגעה עם המצביע
ב( אחד מהשניים:
O(1)( ממשיכים עם מצביע- 1
ממתינים. 1( 2
O(1). מחליפים2
מקדמים מצביע. 3
O(j - i + 1)היא Partition(i, j) סיבוכיות מסקנה:- לא חוזרים לאיבר
Data Structures: Sorts, CS, TAU
7
Worst Caseג(
אם כל פעם נבחר לפיבוט את הגדול ביותר אז המערך n -1 + מערך של1יתחלק למערך של n בגודל
n
n - 1
n - 2
2
n -
1
סכום העבודה בכל הרמות )עבודה לינארית באלמנטים(
= סכום העומקים
= n - 1 + (1 + 2 + …… + n - 1) =
O(n2) =
12
)1(
nn
Data Structures: Sorts, CS, TAU
8
ד( ממוצע
כל האלמנטים שונים זה מזה:1הנחה
)אלמנטים זהים רק מקטינים סיבוכיות(
שווי הסתברות! A[i],…,A[j כל הסדרים של ]:2הנחה
נכון?!?
אי אפשר להבחין בין האלמנטים כי כולם היובעד:
גדולים שווים לפיבוט הקודם
נאמץ את ההנחה!
בניתוח מדוקדק- הפיבוט הקודם בד”כ בצד ימיןנגד:
של המערך הימני
- לא כל כך משמעותי )איבר בודד(בכל זאת:
- אם כן משמעותי: ערבב האיברים בצורה
אקראית
Data Structures: Sorts, CS, TAU
9
.nזמן מיון מערך בגודל T(nסימון: )
הסתברויות:
21
1
smallest]1st i isPr[Pivot
n
i
n
ראשון הוא
i + 1st
שני קטן מ
i + 1
החלף בין בני
הזוג
1
1
2
2
1
1
1
1
2
1
1
)(1
2
)()1()()1(
2
)()(1
2)(
n
i
n
i
n
i
n
i
n
n
n
CiTn
CiTniiTnn
CinTiTn
i
nnT
Data Structures: Sorts, CS, TAU
10
נניח:nCnnnOnT log)log()(
נוכיח )באינדוקציה(:
nCninin
C
iin
CnT
n
i
n
ni
n
i
2
2/
1
1
12/
1
1
2
log)1(log1
2
C log1
2)( n
nn
n log)12
(4
3
n
n
Cn
CnCnnCn
Cnnn
nnn
C
2
2
22
)1(24log
)48
(log)22
(1
2
C=4C2אם nCn log
nCn
nn
n
nnn
nn
n
Cn
2
2 log))12
()(2
11(
)12
(4
log)12
(4
1
2
Data Structures: Sorts, CS, TAU
11
הערות ושיפורים:
• QuickSort - המהיר ביותר בממוצע מכל אלגוריתמי הnlogn•:זרוז האלגוריתם
נוכל לדאוג שהפיבוט יהיה מרכזי יותר.
דוגמה: האמצעי מבין שלושה אלמנטים
אלמנטים ובחר אמצעי kדוגמה: קח
• TradeOff:
k קטן ==< חוסר איזון
k גדול ==< מציאת אמצעי יקרה
החלטה על סיום האלגוריתם:•
n = 2- אנחנו סיימנו ב
O(n2קטן לא אכפת לנו שהסיבוכיות תהיה ) nעבור -
-Knuth ממליץ עלn = 9
שימוש בפוינטרים לרשומות:•
- חוסך העתקות
- עולה במצביעים
Data Structures: Sorts, CS, TAU
12
HEAPSORTHEAPSORT
כל צומת קטן מבניו HEAP ב תזכורת:
HEAP הוא מאוזן אם כל העלים כמעט באותהשכבה.
2
5 11
6 9 14
16
7 8 12
15
INSERTפעולות:
DELETEMIN
יצוג במערך:
11
52 14
96 8716
15
12321 654 987 1110
i
2i+1 2i
Data Structures: Sorts, CS, TAU
13
עקרון ה HEAPSORT
1) For X on list L do
2) INSERT(X,heap);
3) While not EMPTY(heap) do
4) y:=DELETEMIN(heap);
5) Print(y);
6) end;
O(nlogn)
O(nlogn)
אם לא רוצים הדפסה- ניתן לשמור במערך:
A[iאזי ] A[1],…,A[iכשמשמיטים איבר מ ]מתפנה
==< הכנס בו את המושמט
==< תקבל בסוף איברים בסדר יורדוהתוכנית היא:
For i = n to 2 do
SWAP(A[i],A[1])
PUSHDOWN(A[1])
Data Structures: Sorts, CS, TAU
14
3דוגמה: 4 7 9 8 11
3
4 7
9 8 11
Swap(11,3)
Pushdown(11)
11
4 7
9 8 3
4
8 7
9 11 3
Swap(11,4)
11
8 7
9 4 3
Pushdown(11)
7
8 11
9 4 3
Data Structures: Sorts, CS, TAU
15
Swap(9,7)
9
8 11
7 4 3
Pushdown(9)
8
9 11
7 4 3
11
9 8
7 4 3
לבסוף נקבל:
11 9 8 7 4 3
החלפות ==< סדר n/2עוד עולה!
עד כאן:
י למערך ממוין-HEAPמעבר ממערך
Data Structures: Sorts, CS, TAU
16
להשלמת התמונה של מיון מערך שרירותי
י.-HEAP העבר מערך למערך צריך:
החל מהשורה הלפני האחרונה בצע דרך:(Pushdown(i
יהיה לגיטימי iדאג שתת העץ מתחת ל- כלומר:
אנליזה:
HEAP( בנית 1
n/2 איטרציות- כ”א לכל היותרlogn
( >==O(nlogn
למעשה:
O(nשנותן )
.....316
28
14
nnn
:sort( ביצוע ה 2
n פעולות- כ”אlogn
( >==O(logn
Data Structures: Sorts, CS, TAU
17
הערות:
1 )O(nlogn) :HEAP בworstcase
( ממוצע: קצת יותר גרוע מ 2QUICKSORT
הקטנים ביותר k( אם רוצים רק את 3ממוינים:
(O(n+klognכניסה kמיין
קטנים
Data Structures: Sorts, CS, TAU
18
MERGESORTMERGESORT עובד על ידי מיזוג •
רשימות ==< רשימה 1 מזג רשימות באורך •
2באורך • 2 >== 4
• 4 >== 8
• n <== n/2
כל מיזוג לינארי•
( >== O(nlogn
(Cormen 13-15)
Data Structures: Sorts, CS, TAU
19
BIN SORTINGBIN SORTING
O(nlognמיונים שראינו עד כה: )
?O(nlognהאם אפשר לבצע בפחות מ )
אם לא יודעים כלום על המספרים (nlogn) בקרוב:
אם יודעים- אפשר לרדת בשלב זה:
:1דוגמה
,nנמצאים המפתחות A[1,…,nאם יודעים שבמערך ]….,1
:O(nב ) Bאזי מיון לתוך
B[A[i].key] = A[i]Count Sort :2דוגמה
k,…,1איברים , A[1],…,A[nמערך ]
כל איבר מופיע מספר פעמים:
3 2 3 1 4 2 2 5
. ספירת האיברים 1מיון המערך ע”י: מכל סוג
. כתיבתם במערך תוצאה2
Cormen 175-177פרטים:
)( nk
Data Structures: Sorts, CS, TAU
20
:3דוגמה
:A, מיון בתוך 1בתנאים של דוגמה
A[jעם ] A[iהחלף ] A[i].key = jאם
From i = 1 to n do
while A[i].key <> i do
swap(A[i], A[A[i].key])
צעדים O(n)פעולות:
(O(n )!החלפות )איבר שנחת במקומו לא יוחלף יותר
BIN SORTING הינו מיון האיברים לתוך תאים(BINS )ולבסוף- שרשור התאים
פשוט BIN-SORT היא 1- דוגמה
(1קבוע ) BINגודל
במקרה הכללי גודל משתנה
פעולות שנרצה:
BINא( הכנס איבר לתוך
ים-BINב( חבר שני
Data Structures: Sorts, CS, TAU
21
פתרון:
רשימה מקושרת BIN( כל 1
2 )HEADERS מצביעים על תחילת הרשומה
H1
E1
H2
E2
O(1הכנסה: )
O(1שרשור: )
כעת ניתן לשרשר מספר שרירותי של רשימות לתוך n סלים
Data Structures: Sorts, CS, TAU
22
אנליזה:
m - מספר הערכים האפשריים )מספרהסלים(
n - מספר המפתחותO(nסיבוכיות הכנסות = )
O(mסיבוכיות שרשורים = )O(m+n)
אם מספר המפתחות גדול ממספר הסלים (m < n)
O(n)
אם מספר המפתחות קטן ממספר הסלים (m > n)
m = n2למשל O(n2)
דוגמה:
i=1,2,..,10כאשר i2מיין את המספרים
0,1,4,....,100כלומר מיין את
Data Structures: Sorts, CS, TAU
23
פתרון:
סלים n- הכן
- מיין לפי הספרה הפחות משמעותית
- מיין לפי הספרה היותר משמעותית
Bin
0
1
2
3
4
5
6
7
8
9
איברים
0
1, 81
-
-
64, 4
25
36, 16
-
-
9, 49
Bin
0
1
2
3
4
5
6
7
8
9
איברים
0, 1, 4, 9
16
25
36
49
-
64
-
81
-
0, 1, 81, 64, 4, 25, 36, 16, 9, 49
שרשור
Data Structures: Sorts, CS, TAU
24
למה עובד?
i = 10a + b, j = 10c + d נניח:
i < jנניח:
==< ברור ש
אזי שלב שני ישים בסלים a < c- אם המתאימים, והמיון תקין.
ca
?BIN SORTלמה טוב
- תחומים שידועה עליהם אינפורמציה כמו
1,…,nk (קבוע k)
k- מחרוזת באורך
ולכן: b < dאזי a = c- אם
מיון ראשון ימיין בסדר
בשלב השני jיכנס לסל לפני iלכן
Data Structures: Sorts, CS, TAU
25
האם תמיד טוב?
מאוד גדול!! kלא אם
n = 100, k = 100דוגמה:
nk :BIN SORT
פעולות(100מחזורים של 100 )
nlognמיון אחר:
nk > nlognו-
אבל… זהירות בהשוואות!
O(k במיון רגיל- השוואה = )
ולכן יש חשיבות למודל החישובי!!!
Data Structures: Sorts, CS, TAU
26
RADIX SORTRADIX SORT
f1,…,fkמפתחות k- נתונים
רוצים למיין בסדר לכסיקוגרפי-
אמ”ם:( a1,…,ak( < )b1,…,bk כלומר: )
1 )a1 < b1
a1 = b1, a2 < b2או ( 2
a1 = b1,…., ak-1 = bk-1, ak = bk (k
מוכלל, רק צריך לכל סוג BIN SORTדומה ל מפתחות את תחום הסלים שלו.
Data Structures: Sorts, CS, TAU
27
חסם תחתון למיון בהשוואות
(nlogn- מיונים בהשוואה: )
(nמיונים בהשמות: )-
בהשוואה התוצאה היא בינארית סיבה:)כן/לא(
בהשמה התוצאה עם יותר האם ניתן להשתמש בהשמה לכל מיון?אפשרויות.
לא למיון תחומים בלתי מוגבלים )דוגמה: השלמים(
בניית החסם התחתון:
עץ החלטה:
- כל צומת מייצג את מרחב האפשרויות
- בביצוע השוואה המרחב מתחלק לשניים, לפי התוצאה.
Insertion Sort דוגמה:
A[1], A[2( מיין האיברים ]1
A[1], A[2], A[3מיין את ]( 2
a
b
c
A[1]
A[2]
A[3]
Data Structures: Sorts, CS, TAU
28
abc
acb
bac
bca
cab
cba
1
bac
bca
cba
abc
acb
cab
2 3
כן לאA[2]<A[1]?
(b<a?)
bca
cba
bac acb
cab
abc4 5 6 7
A[3]<A[2]?(c<a?)
A[3]<A[2]?
cba bca cab acb8 9 10 11
A[2]<A[1]?A[2]<A[1]?
Data Structures: Sorts, CS, TAU
29
חסם תחתון:
עבור מיון שרירותי שתתנו לי, אראה לכם מקרה שייקח כמו החסם התחתון.
- כל מיון שתבחרו יגדיר עץ.
- אבחר את המסלול בעץ.
עלים, אזי קיים מסלול k- עץ הוא בינארי: אם בעץ שאורכו
!!logk לפחות
,logkעץ בינארי מלא ומאוזן ==< בוודאי )
אם לא מלא ==< פחות עלים!!( - העלים מייצגים סדרים בסיסיים ואת כולם!
.n- מספר הסדרים הוא !
log(nלכן אורך המסלול המקסימלי )!
nn
n
nnnn
n
log
log)!log(
2/!
22
2/
Data Structures: Sorts, CS, TAU
30
חסם תחתון לזמן ממוצע
W(nlogn- אפשר להראות שגם הוא )
עלים - עומק k להראות שעץ בינארי צורת ההוכחה:- .logk ממוצע מסלול
הקטן ביותר כך שלא מתקיים. T יהי הוכחה בשלילה:
בן אחד או שניים: T אז ל
א( אם בן בודד
==< סתירה לקטן ביותר
n
1n
עומק
ממוצע
קטן מ
logk
k עלים
1n 2n
nב( אם שני בנים:
מספר העלים בהם הוא
k1 -וk2
k1<k k-k1=k2
Data Structures: Sorts, CS, TAU
31
הוא: Tאזי ממוצע אורך מסלולים לעלים ב
1)log()log( 221
21
21
1
k
kk
kk
kk
k
- מציאת חסם תחתון לביטוי, ע”י מציאת מינימום שלו
(k1+k2=k )תחת אילוץ
==< k1=k2פתרון התרגיל נותן מינימום ב
k
k
kkT
log
12/log
12/log2/log 21
21
Data Structures: Sorts, CS, TAU
32
סטטיסטיקת סדר ומציאת סטטיסטיקת סדר ומציאת חציוןחציון
Order - Statistics and MedianOrder - Statistics and Medianith order statistic: האיבר הi .בגודלו
iאיברים, מצא את האיבר ה n נתונים בעיה:בגודלו.דוגמה:
( מצא מקסימום1
האיבר האמצעי ( - Median( מצא חציון )2בקבוצה.
( מציאת מקסימום:( מציאת מקסימום:11
max max A[1] A[1]
for i for i 2 to length(A) 2 to length(A)
do if max < A[i]do if max < A[i]
then max then max A[i] A[i]
return maxreturn max
O(nO(nסיבוכיות )סיבוכיות )
Data Structures: Sorts, CS, TAU
33
( מציאת מינימום:( מציאת מינימום:22
O(nO(nכנ”ל )כנ”ל )
( מציאת מינימום ומקסימום:( מציאת מינימום ומקסימום:33
השוואות השוואות צורה פשטנית צורה פשטנית•
השוואות: השוואות: תחכום דורש רק תחכום דורש רק•
a,ba,bקח זוג נתונים מהקלט: קח זוג נתונים מהקלט: - -
bbל- ל- aaהשווה השווה - -
maxmaxהשווה הגדול ל השווה הגדול ל - -
minminהשווה הקטן ל השווה הקטן ל - -
12 n
23 n
33רק רק פעולותפעולות
לשני לשני איבריםאיברים
פעולותפעולות ( מציאת שני בגודלו:( מציאת שני בגודלו:44 n2
פעולותפעולות בגודלו:בגודלו: kk( מציאת ( מציאת 44 kn
HEAPHEAPשכלול: בצע על שכלול: בצע על
)()log(דורש:דורש: nkOnO
Data Structures: Sorts, CS, TAU
34
( מציאת חציון:( מציאת חציון:22
הקשה ביותר בין סטאטיסטיקות הסדרהקשה ביותר בין סטאטיסטיקות הסדר
)log( nnO
O(n) וכל סטאטיסטיק חציוןבשיעור זה:
O(nO(nא( מציאה אקראית בזמן ממוצע )א( מציאה אקראית בזמן ממוצע )
אקראיאקראי partitionpartitionבצע בצע
חפש בצד הנכוןחפש בצד הנכון
O(nO(n22) :worst case) :worst case( סיבוכיות ( סיבוכיות 11
איבריםאיברים nn: : 11כי איטרציה כי איטרציה
22 : :n-1n-1 ’איברים וכו’איברים וכו
( סיבוכיות ממוצעת:( סיבוכיות ממוצעת:22
1
2
)()(1
2)(n
nk
nOkTn
nT
)גודל צד שמאל של החלוקה מתפלג אחיד בין (n ל 1
Data Structures: Sorts, CS, TAU
35
נניח אינדוקטיבית:
)(נוכיח:
)()(
nT
kOkT
cn
nOnc
nOnn
n
cnc
nOnn
nnn
c
nOkkn
c
nOckn
nT
n
k
n
k
n
nk
)(2
1
4
3
)(2
12
1
)(2
122
11
2
12
)(2
)(2
)(
1
1
12
1
1
2
גדול c)כי אפשר לבחור מספיק(
Data Structures: Sorts, CS, TAU
36
::O(n) worst caseO(n) worst caseב- ב- statisticstatisticא( מציאת א( מציאת
((selectselectאיברים: )איברים: ) nnמתוך מתוך iiבחר אלמנט בחר אלמנט
איברים איברים55קבוצות של קבוצות של n/5n/5( חלק האיברים ל ( חלק האיברים ל 11
( מצא את החציון של כ”א מהקבוצות )מיון ( מצא את החציון של כ”א מהקבוצות )מיון 22פשוט(פשוט(
למציאת למציאת selectselect( השתמש רקורסיבית ב ( השתמש רקורסיבית ב 33החציון של החציוניםהחציון של החציונים
מסביב לחציון החציוניםמסביב לחציון החציונים partitionpartition( בצע ( בצע 44
מספר האיברים בחלק הנמוךמספר האיברים בחלק הנמוך kkיהי יהי
מספר האיברים בחלק הגבוהמספר האיברים בחלק הגבוה n-kn-kיהי יהי
רקורסיבית למציאתרקורסיבית למציאת selectselect( השתמש ב ( השתמש ב 55
ii בחלק הנמוך אובחלק הנמוך או
i-ki-k בחלק הגבוהבחלק הגבוה
Data Structures: Sorts, CS, TAU
37
x
3n/10
3n/10
גדולים
קטניםחציון החציוני
ם אנליזה:אנליזה:
80
80
)()610/7(5
)1()(
n
n
nOnTnTnT
חציון החציוניםרקורסיה
(O(n 1סכום השברים קטן מ
Data Structures: Sorts, CS, TAU
38
הוכחה:הוכחה:
cn
nOcnc
nOcnccnc
nOncncnT
)(7109
)(61075
)(61075)(
c(n/10-7גדול מספיק כך ש ) c)ניתן לבחור O(nגדול מהפונקציה המתוארת ע”י )