浅析Hadoop下的基础排序算法(QuickSort）

最新推荐文章于 2023-05-09 09:25:37 发布

Yannick_J

最新推荐文章于 2023-05-09 09:25:37 发布

阅读量949

点赞数

分类专栏： Hadoop 文章标签： Hadoop QuickSort HeapSort InsertSort

本文链接：https://blog.csdn.net/don_chiang709/article/details/80307389

版权

Hadoop 专栏收录该内容

23 篇文章 4 订阅

订阅专栏

一前言:

1. 语术：

QS: QuickSort。
IS: InsertSort
HS: HeapSort
Hadoop 版本: 基于Version 2.7.1代码分析

2. QS排序思想回顾：两个索引 i 和 j 分别从左右两端进行扫描，并让索引i扫描到大于等于分割基数为止，索引j扫描到小于等于分割基数为止，然后交换两个元素，重复这个过程直到两个索引相遇；

3. 目的

分析Haoop 里的 QuickSort 与你认识的 QuickSort 有哪些区别？是否有优化？

二内容:

public final class QuickSort implements IndexedSorter {

  private static final IndexedSorter alt = new HeapSort();

  public QuickSort() { }

  private static void fix(IndexedSortable s, int p, int r) {
    if (s.compare(p, r) > 0) {
      s.swap(p, r);
    }
  }

  /**
   * Deepest recursion before giving up and doing a heapsort.
   * Returns 2 * ceil(log(n)).
   */
  protected static int getMaxDepth(int x) {
    if (x <= 0)
      throw new IllegalArgumentException("Undefined for " + x);
    return (32 - Integer.numberOfLeadingZeros(x - 1)) << 2;
  }

  /**
   * Sort the given range of items using quick sort.
   * {@inheritDoc} If the recursion depth falls below {@link #getMaxDepth},
   * then switch to {@link HeapSort}.
   */
  @Override
  public void sort(IndexedSortable s, int p, int r) {
    sort(s, p, r, null);
  }

  @Override
  public void sort(final IndexedSortable s, int p, int r,
      final Progressable rep) {
    sortInternal(s, p, r, rep, getMaxDepth(r - p));
  }

  private static void sortInternal(final IndexedSortable s, int p, int r,
      final Progressable rep, int depth) {
    if (null != rep) {
      rep.progress();
    }
    while (true) {
    if (r-p < 13) {
      for (int i = p; i < r; ++i) {
        for (int j = i; j > p && s.compare(j-1, j) > 0; --j) {
          s.swap(j, j-1);
        }
      }
      return;
    }
    if (--depth < 0) {
      // give up
      alt.sort(s, p, r, rep);
      return;
    }

    // select, move pivot into first position
    fix(s, (p+r) >>> 1, p);
    fix(s, (p+r) >>> 1, r - 1);
    fix(s, p, r-1);

    // Divide
    int i = p;
    int j = r;
    int ll = p;
    int rr = r;
    int cr;
    while(true) {
      while (++i < j) {
        if ((cr = s.compare(i, p)) > 0) break;
        if (0 == cr && ++ll != i) {
          s.swap(ll, i);
        }
      }
      while (--j > i) {
        if ((cr = s.compare(p, j)) > 0) break;
        if (0 == cr && --rr != j) {
          s.swap(rr, j);
        }
      }
      if (i < j) s.swap(i, j);
      else break;
    }
    j = i;
    // swap pivot- and all eq values- into position
    while (ll >= p) {
      s.swap(ll--, --i);
    }
    while (rr < r) {
      s.swap(rr++, j++);
    }

    // Conquer
    // Recurse on smaller interval first to keep stack shallow
    assert i != j;
    if (i - p < r - j) {
      sortInternal(s, p, i, rep, depth);
      p = j;
    } else {
      sortInternal(s, j, r, rep, depth);
      r = i;
    }
    }
  }

}

QS算法分析：

1. 当排序的sub数组长度少于13时，使用IS排序方式。目的是应该是为了减少迭代调用。相关代码如下：

if (r-p < 13) {

for (int i = p; i < r; ++i) {

for (int j = i; j > p && s.compare(j-1, j)> 0; --j) {

s.swap(j, j-1);

}

return;

}

高亮的代码含有个小技巧，为什么写成下面这样不好（显而易见）？

for (int j = i; j > p ; --j){

if (s.compare(j-1, j) > 0) s.swap(j, j-1);

}

2. 当迭代深度depth使用完后，开始用HS排序方式来接手后面的活。//例如，100 000条数时，按getMaxDepth (100 000)返回depth = 68，最多可迭代68次. 如果没有getMaxDepth这个控制，QS标准代码最坏情况时（比如是一个已排好序的数组）depth=n-1=99999，需要迭代99999次。

三、思考

1. 为什么QS在实践中是最快的排序算法？推荐链接分析: https://cs.stackexchange.com/questions/3/why-is-quicksort-better-than-other-sorting-algorithms-in-practice

Yannick_J

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
浅析Hadoop下的基础排序算法(QuickSort）

一前言:1.语术：QS: QuickSort。 IS: InsertSort HS:HeapSort Hadoop 版本: 基于Version 2.7.1代码分析2. QS排序思想回顾：两个索引 i 和 j 分别从左右两端进行扫描，并让索引i扫描到大于等于分割基数为止，索引j扫描到小于等于分割基数为止，然后交换两个元素，重复这个过程直到两个索引相遇；...
复制链接

扫一扫