快速排序partition过程常见的两种写法+快速排序非递归实现

简介:

这里不详细说明快速排序的原理,具体可参考here

快速排序主要是partition的过程,partition最常用有以下两种写法

第一种:

1
2
3
4
5
6
7
8
9
10
11
12
13
int  mypartition(vector< int >&arr, int  low, int  high)
{
     int  pivot = arr[low]; //选第一个元素作为枢纽元
     while (low < high)
     {
         while (low < high && arr[high] >= pivot)high--;
         arr[low] = arr[high]; //从后面开始找到第一个小于pivot的元素,放到low位置
         while (low < high && arr[low] <= pivot)low++;
         arr[high] = arr[low]; //从前面开始找到第一个大于pivot的元素,放到high位置
     }
     arr[low] = pivot; //最后枢纽元放到low的位置
     return  low;
}

 

 

第二种:

1
2
3
4
5
6
7
8
9
10
int  mypartition(vector< int >&arr, int  low, int  high)
{
     int  pivot = arr[high]; //选最后一个元素作为枢纽元
     int  location = low-1; //location指向比pivot小的元素段的尾部
     for ( int  i = low; i < high; i++) //比枢纽元小的元素依次放在前半部分
        if (arr[i] < pivot)
            swap(arr[i], arr[++location]);
     swap(arr[high], arr[location+1]);
     return  location+1;
}

 

当第二种方法也可以选择第一个元素作为枢纽(当我们对链表进行快排时选用这种做法),对上面代码稍作改动即可,具体改动见注释                         本文地址

1
2
3
4
5
6
7
8
9
10
11
int  mypartition(vector< int >&arr, int  low, int  high)
  {
      int  pivot = arr[low]; //选第一个元素作为枢纽元
      int  location = low; //location指向比pivot小的元素段的尾部
      for ( int  i = low+1; i <= high; i++) //比枢纽元小的元素依次放在前半部分
      if (arr[i] < pivot)
          swap(arr[i], arr[++location]);
      swap(arr[low], arr[location]); //注意和前面的区别,是为了保证交换到头部的元素比pivot小
      return  location;
 
  }

 

快排主函数如下:

1
2
3
4
5
6
7
8
9
void  quicksort(vector< int >&arr, int  low, int  high)
{
     if (low < high)
     {
         int  middle = mypartition(arr, low, high);
         quicksort(arr, low, middle-1);
         quicksort(arr, middle+1, high);
     }
}

 

快排非递归实现

主要思想是用栈来保存子数组的左右边界,一下代码中用数组模拟栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void  quicksort_unrecursion(vector< int >&arr) //快速排序非递归
  {
      int  mystack[2000]; //假设递归不超过1000层
      //栈中保存下次需要排序的子数组的开始位置和结束位置
      int  top = -1;
      mystack[++top] = 0;
      mystack[++top] = arr.size() - 1;
      while (top > 0) //栈非空
      {
          int  high = mystack[top--], low = mystack[top--];
          int  middle = mypartition(arr, low, high);
          if (middle+1 < high) //右边子数组入栈
          {
              mystack[++top] = middle+1;
              mystack[++top] = high;
          }
          if (low < middle-1) //左边子数组入栈
          {
              mystack[++top] = low;
              mystack[++top] = middle-1;
          }
      }
  }





本文转自tenos博客园博客,原文链接:http://www.cnblogs.com/TenosDoIt/p/3665038.html,如需转载请自行联系原作者

目录
相关文章
|
3月前
|
算法
快排(代码的实现)
快排(代码的实现)
|
4月前
|
存储 算法 搜索推荐
【数据结构】归并排序的非递归写法和计数排序
【数据结构】归并排序的非递归写法和计数排序
|
5月前
迭代归并:归并排序非递归实现解析
迭代归并:归并排序非递归实现解析
34 0
|
5月前
|
搜索推荐 Java 索引
快速排序的新用法
快速排序的新用法
40 0
|
5月前
|
JavaScript 搜索推荐 前端开发
JS数组自定义排序方法,冒泡排序、插入排序、选择排序和快速排序。
JS数组自定义排序方法,冒泡排序、插入排序、选择排序和快速排序。
65 0
|
5月前
|
搜索推荐
排序算法:快速排序(三种排序方式、递归和非递归)
排序算法:快速排序(三种排序方式、递归和非递归)
104 0
|
存储 算法 搜索推荐
【排序】排序这样写才对Ⅰ --插入排序与选择排序
常见的排序算法有这些.将会分成几个章节讲完,感兴趣的uu们可以关注下我的排序专栏,方便和后期观看.
54 0
初学算法之---递归的插入排序
初学算法之---递归的插入排序
初学算法之分治---快速排序
初学算法之分治---快速排序