数据结构——排序算法
数据结构算法
排序序列默认递增
插入排序
直接插入排序代码
//直接插入排序
void InsertSort(int A[], int n){
int i, j;
for(i = 2; i < n; i++){ //将A[2]-A[n]插入到前面已排序序列
if(A[i] < A[i-1]){ //若A[i]小于前驱，需将A[i]插入有序表
A[0] = A[i]; //复制为哨兵，A[0]不存放元素
for(j = i-1; A[0] < A[j]; j--){ //从后往前查找待插入位置
A[j+1] = A[j]; //向后挪位
}
A[j+1] = A[0]; //复制到插入位置
}
}
}
折半插入排序代码
//折半插入排序
void InsertSort(int A[], int n){
int i,j,low,high,mid;
for(i = 2;i <= n; i++){ //将A[2]-A[n]插入到前面已排序序列
A[0] = A[i]; //将A[i]暂存到A[0]
low = 1; //设置折半查找的范围
high = i-1;
while(low <= high){ //折半查找，默认递增有序
mid = (low+high)/2; //取中间点
if(A[mid] > A[0]){
high = mid-1; //查找左半子表
}else{
low = mid+1; //查找右半子表
}
}
for(j = i-1;j >=high+1; j--){
A[j+1] = A[j]; //统一插入后
}
A[high+1] = A[0]; //插入操作
}
}
交换排序
冒泡排序
//冒泡排序
void BubbleSort(int A[], int n){
int i,j;
bool flag;
for(i = 0; i < n-1; i++){
flag = false;
for(j = n-1; j > i; j--){
if(A[j-1] > A[j]){ //若为逆序
swap(A[j-1], A[j]); //交换
flag = true;
}
}
if(flag == false)
{
return ; //本趟遍历后没有发生交换，说明表已经有序
}
}
}
快速排序
//快速排序
//Partition()就是划分操作，将表A[low,...,high]划分为满足条件的两个子表
int Partition(int A[], int low, int high){
int pivot = A[low]; //将当前表中第一个元素设为枢轴值，对表进行划分
while(low < high){
while(low < high && A[high] >= pivot){
high--;
}
A[low] = A[high]; //将比枢轴值小的元素移动到左端
while(low < high && A[low] <= pivot){
low++;
}
A[high] = A[low]; //将比枢轴值大的元素移动到右端
}
A[low] = pivot; //枢轴元素存放到最终位置
return low; //返回存放枢轴的最终位置
}
void QuickSort(int A[], int low, int high){
if(low < high){
int pivotpos = Partition(A, low, high); //划分
QuickSort(A, low, pivotpos-1); //依次对两个子表进行递归排序
QuickSort(A, pivotpos+1, high);
}
}
选择排序
简单选择排序
//简单选择排序
void SelectSort(int A[], int n){
//从A[0]开始存放元素
int i,min;
for(i = 0; i < n-1; i++){
min = i;
for(j = i+1; j < n; j++){
if(A[j] < A[min]){
min = j; //更新最小元素位置
}
}
if(min != i){
swap(A[i], A[min]); //与第i个位置交换
}
}
}
堆排序
堆排序，最大堆用于递增排序，最小堆用于递减排序
//将元素k向下调整
void AdjustDown(int A[], int k, int len){
int i;
A[0] = A[k]; //A[0]暂存元素k
for(i = 2*k; i <= len; i *= 2){ //向下筛选子节点
if(i<len && A[i]<A[i+1]){ //比较兄弟节点，选出值大的节点与父节点比较
i++;
}
if(A[0]>= A[i]){ //父节点比子节点中最大的还大，所以筛选结束
break;
}else{
A[k] = A[i]; //将A[i]调整到父节点处，不用管父节点原来的值，因为在A[0]暂存
k = i; //修改k的值，继续向下筛选
}
}
A[k] = A[0]; //被筛选的节点放入最终位置
}
//建立大根堆
void BuildMaxHeap(int A[], int len){
for(int i = len/2; i > 0; i--){ //从i = [n/2]~1,反复调整堆
AdjustDown(A,i,len);
}
}
//堆排序
void HeapSort(int A[], int len){
BuildMaxHeap(A,len);
int i;
for(i = len; i > 1; i--){
swap(A[i],A[1]); //将堆顶元素和堆底元素交换
AdjustDown(A,1,i-1);
}
}
int main(){
int a[8] = {0,7,9,2,4,6,8,10};
HeapSort(a, 7);
for(int i =1;i<8;i++){
cout<<a[i]<<" ";
}
return 0;
}
归并排序
//归并排序
int *B=(int *)malloc((n+1)*sizeof(int)); //辅助数组B
void Merge(int A[], int low, int mid, int high){
//表A的两段A[low,...,mid]和A[mid+1,...,high]各自有序，将它们合并成一个有序表
for(int k=low; k<=high; k++){
B[k] = A[k]; //将A中所有元素复制到B中
}
for(int i= low,int j =mid+1, int k=i; i<=mid&&j<=high;k++){
if(B[i] <= B[j]){ //比较B的左右两段中的元素，将较小值复制到A中
A[k] = B[i];
i++;
}else{
A[k] = B[j];
j++;
}
}//for
//以下两个while()循环只有一个会执行
while(i <= mid){
A[k++] = B[i++]; //若第一个表未检测完，复制
}
while(j <= high){
A[k++] = B[j++]; //若第二个表未检测完，复制
}
}
void MergeSort(int A[], int low, int high){
if(low<high){
int mid = (low+high)/2;
MergeSort(A,low,mid);
MergeSort(A,mid+1,high);
Merge(A,low,mid,high);
}
}
