C++实现常见排序算法

最新推荐文章于 2024-04-06 15:18:57 发布

qq1041256623

最新推荐文章于 2024-04-06 15:18:57 发布

阅读量437

点赞数

分类专栏：算法文章标签：数据结构排序

算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本程序参考了网上各位大牛和数据结构中的程序，VS2005运行通过，如有问题，请各位大牛指正。

实现的排序有：直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序等等
#include <iostream>
using namespace std;
const int len = 100;
class CSort
{
public:
CSort();
~CSort();
virtual void sort()=0;
void swap(int& a,int& b);
friend ostream& operator<<(ostream &cout,const CSort& csort);
protected:
int* arr;
int length;
};
CSort::CSort():length(len)
{
arr = new int[length];
for (int i=0;i<length;i++)
{
arr[i]=rand()%1000;
}
}
CSort::~CSort()
{
delete[]arr;
}
void CSort::swap(int& a,int& b)
{
int temp = a;
a=b;
b=temp;
}
ostream& operator<<(ostream& cout,const CSort& csort)
{
for (int i=0;i<csort.length;i++)
{
cout<<csort.arr[i]<<" ";
}
cout<<endl;
return cout;
}
/*
插入排序思想：将一个记录插入到已经排好的有序表中，从而得到一个新的、记录增1的有序表，直到将所有待排记录全部插入为止
*/
class CInsertSort : public CSort
{
public:
void sort();
};
//直接插入排序--小到大
void CInsertSort::sort()
{
int i,j;
int key;//存放乱序的元素
for ( i=1;i<length;i++)
{
if (arr[i-1]>arr[i])
{
key=arr[i];
for ( j=i-1;j>=0 && arr[j]>key;j--)
{
arr[j+1]=arr[j];
}
arr[j+1]=key;
}
}
}
class BInsertSort : public CSort
{
public:
void sort();
};
void BInsertSort::sort()
{
for (int i=1;i<length;i++)
{
//先找到要插入的位置
int low = 0;
int high = i-1;
while(high>=low)
{
int mid = (low+high)/2;
if (arr[i]>arr[mid])
{
low=mid+1;
}
else
{
high=mid-1;
}
}
//找到应该插入的位置high+1,之后移位置
int key = arr[i];
for (int j=i-1;j>=high+1;j--)
{
arr[j+1]=arr[j];
}
//已经找到位置，把要排序的数放入其中
arr[high+1]=key;
}
}
class CShellInsert : public CSort
{
public:
void sort();
private:
void ShellInsert(int dk);
};
void CShellInsert::sort()//调用希尔排序
{
int dlta[3]={5,3,1};//设置希尔排序的增量，调用希尔排序函数
for (int i=0;i<3;i++)
{
ShellInsert(dlta[i]);
}
}
void CShellInsert::ShellInsert(int dk)//希尔排序函数,把直接插入排序中的1变成dk就好，直接插入排序中增量为1
{
int i,j;
int key;//存放乱序的元素
for (i=dk;i<length;i++)
{
if (arr[i-dk]>arr[i])
{
key=arr[i];
for (j=i-dk;j>=0 && arr[j]>key;j=j-dk)
{
arr[j+dk]=arr[j];
}
arr[j+dk]=key;
}
}
}
/*气泡排序*/
class BubbleSort:public CSort
{
public:
void sort();
};
void BubbleSort::sort()
{
bool change = true;//表示第i个位置的元素在确定位置时，是不是有换位置。true表示，下面的数据还没拍好。没有的话，说明下面元素已经排好，不用在继续下去
for (int i=0;i<length-1 && change;i++)
{
change = false;//先设置已经拍好
for (int j=0;j<length-1-i;j++)
{
if (arr[j]>arr[j+1])
{
change = true;//需要调换位置
swap(arr[j],arr[j+1]);
}
}
}
}
/*快速排序*/
class CQuickSort:public CSort
{
public:
void sort();
private:
int Partition(int low,int high);
void QuickSort(int low,int high);
};
void CQuickSort::sort()
{
QuickSort(0,len-1);
}
int CQuickSort::Partition(int low,int high)
{
int key=arr[low];//先挖第一个洞
while(low<high)
{
while(low<high && arr[high]>=key)//此时，low位置待放元素：比较时，比枢轴元素大，位置不变
high--;
arr[low]=arr[high];//见到第一个比枢轴元素小的，应该把这个元素放到洞（左边）中。
while(low<high && arr[low]<=key)//这时，应该从另一侧进行检测，high待放元素，比较时，比枢轴元素小，位置不变
low++;
arr[high] = arr[low];//见到第一个比枢轴元素大的，应该把这个元素放到洞中（右边）
}
arr[low]=key;//这时第一个洞的元素应该是在low处
return low;//返回这次划分的位置
}
void CQuickSort::QuickSort(int low,int high)
{
if (low<high)
{
int keyloc = Partition(low,high);//在keyloc的元素已经找到正确的位置了
QuickSort(low,keyloc-1);//分别对之后低子表进行快排
QuickSort(keyloc+1,high);//分别对之后高子表进行快排
}
}
class CSelectionSort:public CSort
{
public:
void sort();
};
void CSelectionSort::sort()
{
for (int i=0;i<length-1;i++)
{
int k = i;
for (int j=i+1;j<length;j++)
{
if (arr[j]<arr[k])//要求的序列是由小到大，这里k应该记得是小值，if条件成立时，记的就为大值
{
k=j;
}
}
if (k!=i)
{
swap(arr[i],arr[k]);
}
}
}
class CHeapSort:public CSort
{
public:
void sort();
private:
void HeapSort();
void HeapAdjust(int s,int m);
};
void CHeapSort::sort()
{
HeapSort();
}
/*
堆排序：
初始数据：存储在数组arr中
建立初始堆排序时，
首先把无序序列看成一个完全二叉树：处在0号元素的为根，12号为左右子树之后一次化成完全二叉树的形式画树
调整初始堆时，应该从最后一个非叶子节点开始调整
在建立初始堆后，再进行调整堆，输出序列
首先是堆顶元素(总是数组的第一个元素)和最后一个未排好的元素交换(一直在变化)，之后进行调整堆就好
调整堆时，总是自上而下的调整。即使是在建堆的时候也是这样的。
注意：建初始堆和排序时的调整堆都需调用调堆函数HeapAdjust，两种的不同之处在于调换元素和顺序不同
*/
void CHeapSort::HeapSort()//堆排序
{
for (int i=length/2-1;i>=0;i--)//建堆,相当于从序号m-0的非叶子结点开始调整
{
HeapAdjust(i,length);
}
for (int j=length-1;j>0;j--)
{
swap(arr[0],arr[j]);//调整堆后，第一个元素总是存放着最大的元素(由小到大排序的)，让其给最后一个元素j交换
HeapAdjust(0,j);
}
}
//要从小到大排序：建立大根堆，把顶端元素(数组中第一个元素)和数组中最后一个未排元素交换
//s表示调换的位置，m表示未排好序列的个数
void CHeapSort::HeapAdjust(int s,int m)//调整推,变成大根堆
{
int key =arr[s];//先把要调整的元素取出来,传过来的
//之后对非终结点进行调整
for (int i=2*s+1;i<m;i=2*i+1)
{
if (i<m-1 && arr[i] < arr[i+1])//先让要调整元素的两个孩子进行调整,其中i下标保存最大的值 i<m-1:保证其有左右孩子时，才进行左右孩子的比较
{
i++;
}
if (key > arr[i])//这时，根保存着最大值，不用调整(建立大根堆)
{
break;
}
arr[s]=arr[i];
s=i;//这时，s应该指向刚刚调过去的位置，因为，在调整时，总是从上而下进行的，要从他的左孩子开始
}
arr[s]=key;
}
/*归并排序*/
class CMergingSort:public CSort
{
public:
void sort();
private:
void MergeSort(int left,int right);
void Merge(int left,int mid,int right);
};
void CMergingSort::sort()
{
MergeSort(0,length-1);
}
void CMergingSort::MergeSort(int left,int right)
{
if (left<right)
{
int mid = (left+right)/2;
MergeSort(left,mid);
MergeSort(mid+1,right);
Merge(left,mid,right);
}
}
void CMergingSort::Merge(int left,int mid,int right)
{
int* temp = new int[right - left + 1];
int i=left;
int j=mid+1;
int k=0;
while(i<=mid && j<=right)
{
if (arr[i]>arr[j])
{
temp[k++]=arr[j++];
}
else
{
temp[k++]=arr[i++];
}
}
while(i<=mid)
{
temp[k++]=arr[i++];
}
while(j<=right)
{
temp[k++]=arr[j++];
}
for (i=0,k=left;k<=right;k++,i++)//归并后的数组对应的原来的数组是 left--right 那段，因此还要把这段数据放到原数组中
{
arr[k]=temp[i];
}
delete []temp;
}
int main()
{
CSort *pCsort;//执行这条代码时，是不调用类CSort的构造函数的
//pCsort = new CInsertSort();//直接插入排序
//pCsort = new BInsertSort();//测试折半插入
//pCsort = new CShellInsert();//测试希尔排序
//pCsort = new BubbleSort();//冒泡排序
//pCsort = new CQuickSort();//快速排序
//pCsort = new CSelectionSort();//选择排序
pCsort = new CMergingSort();//堆排序
cout<<"排序前："<<endl;
cout<<*pCsort<<endl;
pCsort->sort();//排序
cout<<"排序后："<<endl;
cout<<*pCsort<<endl;
//pCsort = new CMergingSort();//归并排序
system("pause");
return 1;
}