4、分布式文件系统(算法与数据结构2)- 学习课件

{ return (i+j)/2; }
排序
快速排序中的划分算法
template <class Elem> int partition(Elem A[], int l, int r,Elem& pivot) {
do { while (A[l] < pivot) l++; while ((r > l) && A[r] >=pivot) r--;
冒泡
Q(n2) Q(n2) Q(n2)
选择
Q(n2) Q(n2) Q(n2)
排序
快速排序
• 快速排序是一种“分而治之”的方法:
• 选择一个记录的值作为支点（pivot）。 • 使用该支点 划分 存储记录的序列 :
• 将小于支点的记录安排在支点的左侧，将大于等于支点的记录安 排在支点的右侧。从而将原序列划分为左右两个子序列。
1. if (j <= i) return;
// List too small
2. int pivot = findpivot(A, i, j);
3. swap(A, pivot, j); // Put pivot at end
4. int k = partition<Elem>(A, i, j, A[j]);
} }
排序
选择排序--代价分析
template <class Elem> void selsort(Elem A[], int n) {
for (int i=0; i<n-1; i++) { // select the minial values in [i,n-1]
int lowindex = i; // lowindex指向较小的元素 for (int j=n-1; j>i; j--) // Find least
}
36 20 17 13 28 14 23 15
36 20 17 13
28 14 23 15
20 36 36 20
13 17 17 13
排序
归并排序
List mergesort(List inlist) { if (inlist.length() <= 1)return inlist; List l1 = half of the items from inlist; List l2 = other half of items from inlist; return merge(mergesort(l1), mergesort(l2));
}
36 20 17 13 28 14 23 15
36 20 17 13
28 14 23 15
20 36
17 13
36 20
17 13
33
排序
归并排序
List mergesort(List inlist) { if (inlist.length() <= 1)return inlist; List l1 = half of the items from inlist; List l2 = other half of items from inlist; return merge(mergesort(l1), mergesort(l2));
}
排序
冒泡排序--代价分析
template <class Elem> void bubsort(Elem A[], int n) {
for (int i=0; i<n-1; i++) for (int j=n-1; j>i; j--) if (A[j]< A[j-1]) swap(A, j, j-1);
}
36 20 17 13 28 14 23 15
13 17 20 36
28 14 23 15
20 36
13 17
28 14
23 15
36 20
17 13
28 14
35
排序
归并排序
List mergesort(List inlist) { if (inlist.length() <= 1)return inlist; List l1 = half of the items from inlist; List l2 = other half of items from inlist; return merge(mergesort(l1), mergesort(l2));
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
72 6 57 88 60 42 83 73 48 85
48 6 57 42 60 88 83 73 72 85
< 60
≥ 60
排序
快速排序
• 递归的对左右两个子序列进行划分,直到每个子序列都仅包含一个记录。
排序
快速排序
template <class Elem> void qsort(Elem A[], int i, int j) {
排序
选择排序
第i趟排序就是从位置属于[i,n-1]的元素中 选出最小的元素，并将其和第i位置上的元素交换
排序
选择排序--实现过程
template <class Elem> void selsort(Elem A[], int n) {
for (int i=0; i<n-1; i++) { //select the minial values in [i,n-1] int lowindex = i; // lowindex指向较小的元素 for (int j=n-1; j>i; j--) // Find least if (A[j]< A[lowindex]) lowindex = j; swap(A, i, lowindex);
}
最好的情况: 最坏的情况: 平均情况:
Q(n2) Q(n2) Q(n2)
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
排序
选择排序
select the smallest one
Sort the coins by their size
5. swap(A, k, j);
// Put pivot in place
6. qsort<Elem>(A, i, k-1);
7. qsort<Elem>(A, k+1, j); }
排序
选择支点
• 一些可选的方法 : • 选择第一个记录作为支点 • 选择中间的记录作为支点 • 其他方法.
template <class Elem> int findpivot(Elem A[], int i, int j)
swap(A, l, r); // Swap out-of-place values
} while (l < r); // Stop when they cross
return l;
// Return first pos on right
}
排序
快速排序--代价分析
最好的情况: Q(n log n)
1336 1270 2107 3163
1248 1154 2233 2185
排序
归并排序
List mergesort(List inlist) { if (inlist.length() <= 1)return inlist; List l1 = half of the items from inlist; List l2 = other half of items from inlist; return merge(mergesort(l1), mergesort(l2));
}
for (int i=1; i<n; i++)
for (int j=i; (j>0) &&
(A[j](A, j, j-1);
}
最好情况:
Q(n)
最坏情况 :
Q(n2)
平均情况:
Q(n2)
排序
冒泡排序
一次冒泡的过程：
42 42 42 42 42 13 20 20 20 20 13 42 17 17 17 13 20 20 13 13 13 17 17 17 28 28 14 14 14 14 14 14 28 28 28 28 23 15 15 15 15 15 15 23 23 23 23 23
}
36 20 17 13 28 14 23 15
36 20 17 13
28 14 23 15
36 20 36 20