C++各种常见排序算法 冒泡排序，插入排序，快排序，选择排序，希尔排序

最新推荐文章于 2023-12-12 15:15:48 发布
最新推荐文章于 2023-12-12 15:15:48 发布
阅读量906 收藏
点赞数
分类专栏： 资料 文章标签： c++ 算法 interface pivot class iostream

BubbleSort.cpp ~ 657B 下载(216)


01// BubbleSort.cpp: implementation of the CBubbleSort class.

05#include "BubbleSort.h"
06
07//
08// Construction/Destruction
09//
10
11CBubbleSort::CBubbleSort()
12{
13
14}
15
16CBubbleSort::~CBubbleSort()
17{
18
19}
20
21void CBubbleSort::Sort (int * arr,const int size)
22{
23int tmp =0 ;
24for (int i =0 ;i<size ;i++)
25for (int j=i+1;j<size ;j++)
26{
27if(arr[i]>arr[j])
28{
29tmp =arr[i];
30arr[i] = arr[j];
31arr[j] = tmp ;
32}
33}
34}

[文件] BubbleSort.h ~ 613B 下载(167)


01// BubbleSort.h: interface for the CBubbleSort class.
02//
03//
04
05#if !defined(AFX_BUBBLESORT_H__2A6E4581_4C19_4061_BD68_9FA2DD286EB5__INCLUDED_)
06#define AFX_BUBBLESORT_H__2A6E4581_4C19_4061_BD68_9FA2DD286EB5__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12#include "Sort.h"
13
14class CBubbleSort : public CSort
15{
16public:
17CBubbleSort();
18virtual ~CBubbleSort();
19
20virtual void Sort(int * arr,const int size) ;
21
22};
23
24#endif // !defined(AFX_BUBBLESORT_H__2A6E4581_4C19_4061_BD68_9FA2DD286EB5__INCLUDED_)

[文件] InsertSort.h ~ 682B 下载(149)


01// InsertSort.h: interface for the CInsertSort class.
02//
03//
04
05#if !defined(AFX_INSERTSORT_H__FF5699F7_8D6A_4709_93F1_97CDC299528A__INCLUDED_)
06#define AFX_INSERTSORT_H__FF5699F7_8D6A_4709_93F1_97CDC299528A__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12#include "Sort.h"
13#include <stdlib.h>
14
15class CInsertSort : public CSort
16{
17public:
18CInsertSort();
19virtual ~CInsertSort();
20
21virtual void Sort (int * arr,const int size) ;
22void DirectInsertSort(int *arr,const int size);
23};
24
25#endif // !defined(AFX_INSERTSORT_H__FF5699F7_8D6A_4709_93F1_97CDC299528A__INCLUDED_)

[文件] InsertSort.cpp ~ 1KB 下载(98)


01// InsertSort.cpp: implementation of the CInsertSort class.
02//
03//
04
05#include "InsertSort.h"
06
07//
08// Construction/Destruction
09//
10
11CInsertSort::CInsertSort()
12{
13
14}
15
16CInsertSort::~CInsertSort()
17{
18
19}
20/*
21if (mid != high&& mid != low)
22{
23exit(0);
24}
25*/
26
27
28//���ֲ�������
29void CInsertSort::Sort (int * arr,const int size)
30{
31if(!arr)
32return ;
33//
34for (int i =1 ;i<size ;i++)
35{
36int tmp = arr[i];

38int low =0,high = i-1 ,mid ;
39while (low<= high)
40{
41mid= (low+high)/2;
42if(arr[i]<arr[mid])
43high = mid-1;
44else
45low = mid +1 ;
46}
47//high ָ��tmpӦ�����ǰһλ�ã�lowֵΪhigh+1
48for (int j =i-1 ;j>=low;j--)
49{
50arr[j+1]= arr[j];
51}
52arr[low]= tmp ;

57void CInsertSort::DirectInsertSort(int *arr,int size)
58{
59if(!arr)
60return ;
61for (int i=1;i<size ;i++)
62{
63int tmp = arr[i];
64for (int j = i-1; j>=0 && tmp < arr[j];j--)
65{
66arr[j+1] = arr[j];
67}
68arr[j+1] =tmp ;
69
70}
71}

[文件] Main.cpp ~ 1KB 下载(149)

01#include <iostream>
02#include <stdlib.h>
03#include <memory>
04#include "BubbleSort.h"
05#include "InsertSort.h"
06#include "QuickSort.h"
07#include "SelectionSort.h"
08#include "ShellSort.h"
09
10#define LENGTH 100
11
12using namespace std;
13
14int main()
15{
16// FILE *pFile ;
17//auto_ptr<FILE> apFile(pFile);
18//std::tr1::shared_ptr<int> sp(new int(0));
19//tr1::shared_ptr<FILE> spFile ;
20// pFile = fopen( ("2.txt"), ("wt"));
21// if(!pFile)
22// {
23// std::cout<<"File open error!\n"<<std::endl;
24// exit(0);
25// }
26int arr[LENGTH];
27int i =0 ;
28for(i=0;i<LENGTH ;i++)
29{
30arr[i] = rand()%1000;
31//cout<<arr[i]<<endl;
32}
33
34CSort *pSort ;
35pSort = new CShellSort ;
36pSort->Sort(arr,LENGTH) ;
37// CInsertSort is ;
38// is.DirectInsertSort(arr,LENGTH);
39
40delete pSort ;
41for ( i =0 ;i<LENGTH;i++)
42{
43std::cout<<arr[i]<<std::endl;
44}
45// for( i=0;i<LENGTH ;i++)
46// {
47// fprintf(pFile, ("%d\n"),arr[i]);
48// //cout<<arr[i]<<endl;
49// }
50// fclose(pFile);
51
52// FILE *pFileReader ;
53// pFileReader = fopen("1.txt","rt");
54// if(!pFileReader)
55// {
56// std::cout<<"File open error!\n"<<std::endl;
57// exit(0);
58// }
59
60// int n =0;
61// for(i=0;i<LENGTH;i++)
62// {
63// fscanf(pFileReader,"%d\n",&n);
64// std::cout<<n<<std::endl;
65// }
66// //fclose(pFileReader);
67
68return 0 ;
69}

[文件] SelectionSort.cpp ~ 776B 下载(148)

view source
print ?
01// SelectionSort.cpp: implementation of the CSelectionSort class.
02//
03//
04
05#include "SelectionSort.h"
06
07//
08// Construction/Destruction
09//
10
11CSelectionSort::CSelectionSort()
12{
13
14}
15
16CSelectionSort::~CSelectionSort()
17{
18
19}
20
21//����������ѡ��С�ģ�������������棬�Ӷ��������+1
22void CSelectionSort::Sort (int * arr,const int size)
23{
24if(!arr)
25return ;
26for (int i =0 ;i<size ;i++)
27{
28int pos= i ;
29for (int j= i;j<size ;j++)
30{
31if(arr[pos] > arr[j])
32pos = j ;
33}
34int tmp = arr[i];
35arr[i] = arr[pos];
36arr[pos]= tmp ;
37}
38}

[文件] SelectionSort.h ~ 635B 下载(151)


01// SelectionSort.h: interface for the CSelectionSort class.
02//
03//
04
05#if !defined(AFX_SELECTIONSORT_H__99AADAE2_AC7F_49BF_B382_388CD8A9E784__INCLUDED_)
06#define AFX_SELECTIONSORT_H__99AADAE2_AC7F_49BF_B382_388CD8A9E784__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12#include "Sort.h"
13
14class CSelectionSort : public CSort
15{
16public:
17CSelectionSort();
18virtual ~CSelectionSort();
19
20virtual void Sort(int * arr,const int size) ;
21};
22
23#endif // !defined(AFX_SELECTIONSORT_H__99AADAE2_AC7F_49BF_B382_388CD8A9E784__INCLUDED_)

[文件] Sort.cpp ~ 374B 下载(141)


01// Sort.cpp: implementation of the CSort class.
02//
03//
04
05#include "Sort.h"
06
07//
08// Construction/Destruction
09//
10
11CSort::CSort()
12{
13
14}
15
16CSort::~CSort()
17{
18
19}

[文件] Sort.h ~ 530B 下载(144)


01// Sort.h: interface for the CSort class.
02//
03//
04
05#if !defined(AFX_SORT_H__39C9279B_CB59_4081_B68B_C8D0459C1C1E__INCLUDED_)
06#define AFX_SORT_H__39C9279B_CB59_4081_B68B_C8D0459C1C1E__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12class CSort
13{
14public:
15CSort();
16virtual ~CSort();
17
18virtual void Sort(int * arr,const int size) =0;
19
20};
21
22#endif // !defined(AFX_SORT_H__39C9279B_CB59_4081_B68B_C8D0459C1C1E__INCLUDED_)

[文件] ShellSort.h ~ 652B 下载(145)


01// ShellSort.h: interface for the CShellSort class.
02//
03//
04
05#if !defined(AFX_SHELLSORT_H__77F1EA61_E5FA_42F9_96A0_A718CB82519E__INCLUDED_)
06#define AFX_SHELLSORT_H__77F1EA61_E5FA_42F9_96A0_A718CB82519E__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12#include "Sort.h"
13
14class CShellSort : public CSort
15{
16public:
17CShellSort();
18virtual ~CShellSort();
19
20virtual void Sort(int * arr,const int size) ;
21void ShellPass (int *arr ,int size ,int delta);
22};
23
24#endif // !defined(AFX_SHELLSORT_H__77F1EA61_E5FA_42F9_96A0_A718CB82519E__INCLUDED_)

[文件] QuickSort.h ~ 709B 下载(129)


01// QuickSort.h: interface for the CQuickSort class.
02//
03//
04
05#if !defined(AFX_QUICKSORT_H__55ABF9C0_0E66_431F_B3CE_5D63EF7BE1C6__INCLUDED_)
06#define AFX_QUICKSORT_H__55ABF9C0_0E66_431F_B3CE_5D63EF7BE1C6__INCLUDED_
07
08#if _MSC_VER > 1000
09#pragma once
10#endif // _MSC_VER > 1000
11
12#include "Sort.h"
13
14class CQuickSort : public CSort
15{
16public:
17CQuickSort();
18virtual ~CQuickSort();
19
20virtual void Sort (int * arr,const int size) ;
21private :
22int Partition(int * arr,int low ,int high) ;
23void QuickSort(int *arr,int low , int high) ;
24};
25
26#endif // !defined(AFX_QUICKSORT_H__55ABF9C0_0E66_431F_B3CE_5D63EF7BE1C6__INCLUDED_)

[文件] QuickSort.cpp ~ 1KB 下载(123)


01// QuickSort.cpp: implementation of the CQuickSort class.
02//
03//
04
05#include "QuickSort.h"
06
07//
08// Construction/Destruction
09//
10
11CQuickSort::CQuickSort()
12{
13
14}
15
16CQuickSort::~CQuickSort()
17{
18
19}
20
21void CQuickSort::Sort (int * arr,const int size)
22{
23if(!arr)
24return ;
25QuickSort(arr,0,size-1);
26}
27
28void CQuickSort::QuickSort(int *arr,int low , int high)
29{
30
31if (low<high)
32{
33int pivotloc = Partition(arr,low,high);
34QuickSort(arr,low,pivotloc-1);
35QuickSort(arr,pivotloc+1,high);
36}
37}
38int CQuickSort::Partition(int * arr,int low ,int high)
39{
40int pivot = arr[low];
41while (low<high)
42{
43
44while(low<high && arr[high]>=pivot)
45high --;
46arr[low]= arr[high] ;
47while(low<high && arr[low]<=pivot)
48low ++;
49arr[high]= arr[low];
50}
51arr[low] = pivot;
52return low ;
53}

[文件] ShellSort.cpp ~ 851B 下载(99)


01// ShellSort.cpp: implementation of the CShellSort class.
02//
03//
04
05#include "ShellSort.h"
06
07//
08// Construction/Destruction
09//
10
11CShellSort::CShellSort()
12{
13
14}
15
16CShellSort::~CShellSort()
17{
18
19}
20void CShellSort::Sort (int * arr,const int size)
21{
22if(!arr)
23return ;
24int increment = size ;
25do {
26increment = increment/3 +1;
27ShellPass(arr,size,increment);
28} while(increment>1);
29}
30void CShellSort::ShellPass(int *arr ,int size ,int delta)
31{
32for (int i = delta;i<size;i++)
33{
34int tmp = arr[i];
35for (int j = i-delta; j>=0 && tmp < arr[j];j-=delta)
36{
37arr[j+delta] = arr[j];
38}
39arr[j+delta] = tmp ;
40}
41}
wuqiuming2008
关注
专栏目录
C++希尔排序
wyl1813240346的博客
08-21 2325
希尔排序的提出： 直接插入排序算法的问题： 若一个最小的值在后面，那么当排这个最小值的时候需要一步步移动，将其移动到序列的最前面，那么有没有什么方法减少这种移位？ 我们不希望一步一步移动，而是给它设置一个增量让其大步移动，希尔排序由此产生，同时希尔排序打破了排序算法时间复杂度不能低于O(n2)O(n2)O(n^2)。 希尔排序采用跳跃分割的策略： 将相距某个“增量”的记录组成一个子序列，...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
C++之四种排序算法 插入 选择 冒泡 希尔
咖喱辣椒
10-21 181
#include <iostream> using namespace std; /*插入排序*/ void InsertSort(int a[],int n){ int i,j,temp; for(i=1;i<n;i++){ temp=a[i]; j=i-1; while(j>=0&&temp<a[j]){ a[j+1]=a[j]; j--; } a[j+1]=temp; } for(int k=0;k<n;
冒泡排序、插入排序、选择排序、希尔排序（C++实现）
qq_37724465的博客
02-15 241
冒泡排序： 冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。 最优时间复杂度:O(n) 最差时间复杂度:O(n^2) 平均时间复杂度:O(n^2) 稳定排序 class Solution { public: vector&l...
c++ 希尔排序
lionway
05-17 449
希尔排序是一种不稳定的算法。复杂度在n^2与nlogn 之间 #include using namespace std; void s_ssort(int a[],int n) {     int temp; for(int d=n/2;d>0;d=d/2) { for(int i=d;i { temp=a[i]; for(int j=i-d;j>=0&&temp a[j+
c++ 希尔排序
TuringEvo专栏
12-12 446
【代码】c++ 插入排序。
C/C++排序算法实现，冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序
12-26
C/C++排序算法实现 1、冒泡排序 2、简单选择排序 3、直接插入排序 4、希尔排序 5、堆排序 6、归并排序 7、快速排序
排序算法: 冒泡排序，桶排序，计数排序，堆排序，插入排序，合并排序，快速排序，基数排序，选择排序，希尔排序 实现语言: C++
最新发布
01-15
本文将详细探讨十种经典的排序算法在C++中的实现，分别是冒泡排序、桶排序、计数排序、堆排序、插入排序、合并排序、快速排序、基数排序、选择排序和希尔排序。 1. **冒泡排序**：冒泡排序是最简单的排序算法之一，...
八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）
12-30
本资源提供了八大经典排序算法的C++实现，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序、桶排序以及堆排序。接下来，我们将深入探讨这些排序算法的原理、效率以及它们在C++中的实现。 1. **...
希尔排序（C++）
笔记的博客
03-25 374
希尔排序是插入排序的一种高级变形，当数组元素较少并且基本有序的时候，使用直接插入排序效率很高，因为数组基本有序的时候，只需要执行少量的插入操作就行了。 算法思想 先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成），分别进行直接插入排序 然后依次缩减增量再进行排序 待整个序列中的元素基本有序（增量足够小时），再对全体元素进行一次直接插入排序。 代码实现 #include <iostream> using namespace std; void shell_sort(int
希尔排序(C++)
程序员Link
10-30 336
#include using namespace std; void print(int a[], int num, int dk, int index) { cout << "dk = " << dk << " index = " << index << " : "; for (int i = 0; i < num; ++i) { cout << a[i] << " "; } cout << endl
C++ 希尔排序
wangqinghao的专栏
09-02 648
typedef int KeyType; typedef int Other_Data; typedef struct{ KeyType key; Other_Data other_data; }RecordType; int ShellInsert(RecordType record[],int nLength,int delta){ int j = 0 ; for
C++ 希尔排序
m0_62805850的博客
06-16 305
【代码】C++ 希尔排序。
c++希尔排序
阿旭的博客
11-02 156
void shellSort(int arr[],int len); int main() //程序入口，主函数，从这里开始执行 { int i; int len; int arr[]={8,4,5,4,1,4,4,5,9}; len = sizeof(arr)/sizeof(int); shellSort(arr,len); for(i=0;i<len;i++) { printf("%d ",arr[i]); } } void shellSort(int arr[],int
C++实现各种排序算法：直接插入、希尔、选择与快速排序
"这篇文档提供了一系列排序算法的C++实现，包括直接插入排序、希尔排序、选择排序（冒泡排序和快速排序）。这些算法都针对数组进行，但也适用于静态链表排序。所有排序结果默认按照升序排列。文档中还包含了一个统一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值