新建
上传
首页
助手
最?/div>
资料?/div>
工具

(一)目?/p>

 

在实际问题的解决过程中,我们发现,很多问题都可以归结为对数据的排序和查询。而查询的效率则在?/p>

大程度上依赖于排序的效率;尤其是在数据量达到海量级的时候。因此,设计一个有效的排序算法是至?/p>

重要的。本文设计了一个通用?/p>

c++ quicksort 

模板类。通过简单的提供一?/p>

data

类,可以实现任意数据?/p>

快速排序算法,提高了开发效率?/p>

 

 

(二)快速排序算法的思想

 

最基本的快速排序的思想是基于分治策略的?/p>

 

对于输入的子序列

l[p..r]

,如果规模足够小则直接进行排序,否则分三步处理:

 

1 

分解

(divide)

:将输入的序?/p>

l[p..r]

划分成两个非空子序列

l[p..q]

?/p>

l[q+1..r]

?/p>

 

?/p>

l[p..q]

中任一元素的值不

大于

l[q+1..r]

中任一元素的值?/p>

 

2 

递归求解

(conquer)

:通过递归调用快速排序算法分别对

l[p..q]

?/p>

l[q+1..r]

进行排序?/p>

 

3 

合并

(merge)

:由于对分解出的两个子序列的排序是就地进行的?/p>

 

所以在

l[p..q]

?/p>

l[q+1..r]

都排好序后不

需要执行任何计?/p>

l[p..r]

就已排好序?/p>

 

 

(三)准备工作和源代?/p>

 

1 

使用

vc6

建立

console

工程

 

2 

加入下面的模板类(快速排序的模板类?/p>

?/p>

?/p>

 

template<typename datatype>//datatype

是模板参数,代表了欲排序的数据类?/p>

 

class quicksorttemp 

  

{ 

public: 

   

 quicksorttemp() 

   

 { 

   

 }   

  

   

 ~quicksorttemp() 

   

 { 

   

 }   

  

public: 

   

 // 

快速排序的实现?/p>

array

是要排序数据的数组,

nlower

?/p>

nupper

范围?/p>

0 ~ 

数据总个?/p>

-1 

   

 static void quicksort(datatype* array, int nlower, int nupper) 

   

 { 

   

    

 // 

测试是否排序完毕

 

   

    

 if (nlower < nupper) 

   

    

 { 

   

    

    

 // 

分解和分别进行排?/p>

 

   

    

    

 int nsplit = partition (array, nlower, nupper);//

数据切分为两个部?/p>

 

   

    

    

 quicksort (array, nlower, nsplit - 1);//

左半部分递归排序

 

   

    

    

 quicksort (array, nsplit + 1, nupper);//

右半部分递归排序

 

   

    

 } 

   

 } 

   

  

   

 // 

切分数据为左右两个部分,返回中间元素

x

的编?/p>

 

Ͼλ
新建
上传
首页
助手
最?/div>
资料?/div>
工具

(一)目?/p>

 

在实际问题的解决过程中,我们发现,很多问题都可以归结为对数据的排序和查询。而查询的效率则在?/p>

大程度上依赖于排序的效率;尤其是在数据量达到海量级的时候。因此,设计一个有效的排序算法是至?/p>

重要的。本文设计了一个通用?/p>

c++ quicksort 

模板类。通过简单的提供一?/p>

data

类,可以实现任意数据?/p>

快速排序算法,提高了开发效率?/p>

 

 

(二)快速排序算法的思想

 

最基本的快速排序的思想是基于分治策略的?/p>

 

对于输入的子序列

l[p..r]

,如果规模足够小则直接进行排序,否则分三步处理:

 

1 

分解

(divide)

:将输入的序?/p>

l[p..r]

划分成两个非空子序列

l[p..q]

?/p>

l[q+1..r]

?/p>

 

?/p>

l[p..q]

中任一元素的值不

大于

l[q+1..r]

中任一元素的值?/p>

 

2 

递归求解

(conquer)

:通过递归调用快速排序算法分别对

l[p..q]

?/p>

l[q+1..r]

进行排序?/p>

 

3 

合并

(merge)

:由于对分解出的两个子序列的排序是就地进行的?/p>

 

所以在

l[p..q]

?/p>

l[q+1..r]

都排好序后不

需要执行任何计?/p>

l[p..r]

就已排好序?/p>

 

 

(三)准备工作和源代?/p>

 

1 

使用

vc6

建立

console

工程

 

2 

加入下面的模板类(快速排序的模板类?/p>

?/p>

?/p>

 

template<typename datatype>//datatype

是模板参数,代表了欲排序的数据类?/p>

 

class quicksorttemp 

  

{ 

public: 

   

 quicksorttemp() 

   

 { 

   

 }   

  

   

 ~quicksorttemp() 

   

 { 

   

 }   

  

public: 

   

 // 

快速排序的实现?/p>

array

是要排序数据的数组,

nlower

?/p>

nupper

范围?/p>

0 ~ 

数据总个?/p>

-1 

   

 static void quicksort(datatype* array, int nlower, int nupper) 

   

 { 

   

    

 // 

测试是否排序完毕

 

   

    

 if (nlower < nupper) 

   

    

 { 

   

    

    

 // 

分解和分别进行排?/p>

 

   

    

    

 int nsplit = partition (array, nlower, nupper);//

数据切分为两个部?/p>

 

   

    

    

 quicksort (array, nlower, nsplit - 1);//

左半部分递归排序

 

   

    

    

 quicksort (array, nsplit + 1, nupper);//

右半部分递归排序

 

   

    

 } 

   

 } 

   

  

   

 // 

切分数据为左右两个部分,返回中间元素

x

的编?/p>

 

">
新建
上传
首页
助手
最?/div>
资料?/div>
工具

(一)目?/p>

 

在实际问题的解决过程中,我们发现,很多问题都可以归结为对数据的排序和查询。而查询的效率则在?/p>

大程度上依赖于排序的效率;尤其是在数据量达到海量级的时候。因此,设计一个有效的排序算法是至?/p>

重要的。本文设计了一个通用?/p>

c++ quicksort 

模板类。通过简单的提供一?/p>

data

类,可以实现任意数据?/p>

快速排序算法,提高了开发效率?/p>

 

 

(二)快速排序算法的思想

 

最基本的快速排序的思想是基于分治策略的?/p>

 

对于输入的子序列

l[p..r]

,如果规模足够小则直接进行排序,否则分三步处理:

 

1 

分解

(divide)

:将输入的序?/p>

l[p..r]

划分成两个非空子序列

l[p..q]

?/p>

l[q+1..r]

?/p>

 

?/p>

l[p..q]

中任一元素的值不

大于

l[q+1..r]

中任一元素的值?/p>

 

2 

递归求解

(conquer)

:通过递归调用快速排序算法分别对

l[p..q]

?/p>

l[q+1..r]

进行排序?/p>

 

3 

合并

(merge)

:由于对分解出的两个子序列的排序是就地进行的?/p>

 

所以在

l[p..q]

?/p>

l[q+1..r]

都排好序后不

需要执行任何计?/p>

l[p..r]

就已排好序?/p>

 

 

(三)准备工作和源代?/p>

 

1 

使用

vc6

建立

console

工程

 

2 

加入下面的模板类(快速排序的模板类?/p>

?/p>

?/p>

 

template<typename datatype>//datatype

是模板参数,代表了欲排序的数据类?/p>

 

class quicksorttemp 

  

{ 

public: 

   

 quicksorttemp() 

   

 { 

   

 }   

  

   

 ~quicksorttemp() 

   

 { 

   

 }   

  

public: 

   

 // 

快速排序的实现?/p>

array

是要排序数据的数组,

nlower

?/p>

nupper

范围?/p>

0 ~ 

数据总个?/p>

-1 

   

 static void quicksort(datatype* array, int nlower, int nupper) 

   

 { 

   

    

 // 

测试是否排序完毕

 

   

    

 if (nlower < nupper) 

   

    

 { 

   

    

    

 // 

分解和分别进行排?/p>

 

   

    

    

 int nsplit = partition (array, nlower, nupper);//

数据切分为两个部?/p>

 

   

    

    

 quicksort (array, nlower, nsplit - 1);//

左半部分递归排序

 

   

    

    

 quicksort (array, nsplit + 1, nupper);//

右半部分递归排序

 

   

    

 } 

   

 } 

   

  

   

 // 

切分数据为左右两个部分,返回中间元素

x

的编?/p>

 

Ͼλ">
Ͼλ
Ŀ

简单实用的c++快速排序模板类 - 百度文库
新建
上传
首页
助手
最?/div>
资料?/div>
工具

(一)目?/p>

 

在实际问题的解决过程中,我们发现,很多问题都可以归结为对数据的排序和查询。而查询的效率则在?/p>

大程度上依赖于排序的效率;尤其是在数据量达到海量级的时候。因此,设计一个有效的排序算法是至?/p>

重要的。本文设计了一个通用?/p>

c++ quicksort 

模板类。通过简单的提供一?/p>

data

类,可以实现任意数据?/p>

快速排序算法,提高了开发效率?/p>

 

 

(二)快速排序算法的思想

 

最基本的快速排序的思想是基于分治策略的?/p>

 

对于输入的子序列

l[p..r]

,如果规模足够小则直接进行排序,否则分三步处理:

 

1 

分解

(divide)

:将输入的序?/p>

l[p..r]

划分成两个非空子序列

l[p..q]

?/p>

l[q+1..r]

?/p>

 

?/p>

l[p..q]

中任一元素的值不

大于

l[q+1..r]

中任一元素的值?/p>

 

2 

递归求解

(conquer)

:通过递归调用快速排序算法分别对

l[p..q]

?/p>

l[q+1..r]

进行排序?/p>

 

3 

合并

(merge)

:由于对分解出的两个子序列的排序是就地进行的?/p>

 

所以在

l[p..q]

?/p>

l[q+1..r]

都排好序后不

需要执行任何计?/p>

l[p..r]

就已排好序?/p>

 

 

(三)准备工作和源代?/p>

 

1 

使用

vc6

建立

console

工程

 

2 

加入下面的模板类(快速排序的模板类?/p>

?/p>

?/p>

 

template<typename datatype>//datatype

是模板参数,代表了欲排序的数据类?/p>

 

class quicksorttemp 

  

{ 

public: 

   

 quicksorttemp() 

   

 { 

   

 }   

  

   

 ~quicksorttemp() 

   

 { 

   

 }   

  

public: 

   

 // 

快速排序的实现?/p>

array

是要排序数据的数组,

nlower

?/p>

nupper

范围?/p>

0 ~ 

数据总个?/p>

-1 

   

 static void quicksort(datatype* array, int nlower, int nupper) 

   

 { 

   

    

 // 

测试是否排序完毕

 

   

    

 if (nlower < nupper) 

   

    

 { 

   

    

    

 // 

分解和分别进行排?/p>

 

   

    

    

 int nsplit = partition (array, nlower, nupper);//

数据切分为两个部?/p>

 

   

    

    

 quicksort (array, nlower, nsplit - 1);//

左半部分递归排序

 

   

    

    

 quicksort (array, nsplit + 1, nupper);//

右半部分递归排序

 

   

    

 } 

   

 } 

   

  

   

 // 

切分数据为左右两个部分,返回中间元素

x

的编?/p>

 



ļ׺.doc޸Ϊ.docĶ

  • ¹ϲ˵
  • ЭλʩȫЭ
  • ͳѧģ()
  • 2014꽭նԿڵвƻ߿Ծ
  • ʵģ.doc
  • 2014רҵԱĿ-Ӧ(2014
  • 2017ӢױǴѧҵѧԺ
  • ϵ
  • ABAQUSüɹ(ͼIJï).
  • ʵţ̵ĸйټ

վ

԰ Ͼλ
ϵͷ779662525#qq.com(#滻Ϊ@)