【数据结构】整数排序(排序-基本题)

问题描述

从标准输入中输入一组互不相同的整数（个数不超过100）及排序方式，按照从小到大排序，输出按某种算法排序的结果及元素的比较次数。
说明：排序方式为一个1~5的整数，分别表示：

• 1：选择排序，比较次数是指选择未排序部分的最小元素时的比较次数。
• 2：冒泡排序，比较次数是指相邻元素的比较次数，若某趟排序中没有进行数据交换，就认为排序结束。
• 3：堆排序，比较次数是指根元素调整过程中根元素与子树根结点的比较次数，即下面算法中红色语句的执行次数：

void adjust(int k[ ],int i,int n)
{
    int j,temp;
    temp=k[i];
    j=2*i+1;
    while(j<n){
        if(j<n-1 && k[j]<k[j+1])
            j++;
        if(temp>=k[j]) //标红语句，统计其执行次数
            break;
        k[(j-1)/2]=k[j];
        j=2*j+1;
    }
    k[(j-1)/2]=temp;
}

• 4：二路归并排序，比较次数是指两组有序数据合并成一组时的比较次数，即下面算法中红色语句的执行次数：

void merge(int x[ ],int tmp[ ],int left,int leftend,int rightend)
{     
    int i=left, j=leftend+1, q=left;
    while(i<=leftend && j<=rightend)
    {
        if(x[i]<=x[j])  //标红语句，统计其执行次数
            tmp[q++]=x[i++];
        else
            tmp[q++]=x[j++];
    }
    while(i<=leftend)
        tmp[q++]=x[i++];
    while(j<=rightend)
        tmp[q++]=x[j++];
    for(i=left; i<=rightend; i++)
        x[i]=tmp[i];
}

• 5：快速排序，比较次数是指分界元素与其它元素的比较次数，即下面算法中红色语句的执行次数：

void quickSort(int k[ ],int left,int right)
{     
    int i, last;
    if(left<right){
        last=left; 
        for(i=left+1;i<=right;i++)
            if(k[i]<k[left]) //标红语句，统计其执行次数
                swap(&k[++last],&k[i]); 
        swap(&k[left],&k[last]);
        quickSort(k,left,last-1); 
        quickSort(k,last+1,right);   
    }
}

输入形式

首先在屏幕上输入2个整数，分别表示待排序的整数个数及排序方式，然后在下一行依次输入待排序的整数。各整数之间都以一个空格分隔。

输出形式

先在一行上输出排序结果，各整数间以一个空格分隔。然后在下一行上输出排序过程中的元素比较次数。

样例1输入

20 1
38 356 98 -102 126 46 65 -9 100 0 21 2 90 8 18 12 78 16 189 23

样例1输出

-102 -9 0 2 8 12 16 18 21 23 38 46 65 78 90 98 100 126 189 356
190

样例1说明

输入了20个整数数据，要求按照选择排序算法对输入的数据进行从小到大排序，输出排序结果，排序过程中元素的比较次数为190次。

其它样例说明

若输入的待排序数据与样例1完全相同，要求的排序算法不同，则输出的排序结果与样例1完全一样，但比较次数不同，为了方便说明，下面左侧为排序方式，右侧为对应的比较次数：

2 162
3 58
4 66
5 75

代码

#include <iostream>
#include<cstring> 
using namespace std;

void Print(int num[], int n) {
    for (int i = 0; i < n; i++) {
        cout << num[i]<<" ";
    }
    cout << endl;
}

int SelSort(int num[],int n) {
    int count = 0;
    for (int i = 0; i < n-1; i++) {
        int min = i;
        for (int j = i + 1; j < n; j++) {
            count++;
            if (num[j] < num[min]) {
                int temp = num[j];
                num[j] = num[min];
                num[min] = temp;
            }
        }
    }
    return count;
}

int  BubSort(int num[],int n) {
    int count = 0;
    for (int i = 0; i < n - 1; i++) {
        int flag = 0;
        for (int j = 0; j < n - i - 1; j++) {
            count++;
            if (num[j] > num[j + 1])
            {
                flag++;
                int temp = num[j];
                num[j] = num[j + 1];
                num[j + 1] = temp;
            }
        }
        if (flag == 0) {
            break;
        }
    }
    return count;
}

int Adjust(int num[],int n,int i) {
    int count = 0;
    if (i < n) {
        int temp = num[i];
        int j = 2 * i + 1;
        while (j < n) {
            if (j < n - 1 && num[j] < num[j + 1])
                j++;
            count++;
            if (temp >= num[j])
                break;
            num[i] = num[j];
            i = j;
            j = 2 * i + 1;
        }
        num[(j + 1) / 2 - 1] = temp;
    }
    return count;
}

int HeapSort(int num[], int n) { 
    int i;	
    int temp;
    int count = 0;
    for (i = n / 2 - 1; i >= 0; i--) { 
        count+=Adjust(num, n,i); 
    }	
   	for (i = n - 1; i >= 0; i--) {
        temp = num[i];		
        num[i] = num[0];		
        num[0] = temp;		
        count +=Adjust(num, i, 0);
    }
    return count;
}


int Merge(int num[], int tmp[], int left, int mid, int right ,int count)
{
    
    int i = left, j = mid + 1, q = left;
    while (i <= mid && j <= right)
    {
        count++;
        if (num[i] <= num[j])
            tmp[q++] = num[i++];
        else
            tmp[q++] = num[j++];
    }
    while (i <= mid)
        tmp[q++] = num[i++];
    while (j <= right)
        tmp[q++] = num[j++];
    for (i = left; i <= right; i++)
        num[i] = tmp[i];
    return count;
}

int MerSort(int num[], int temp[], int left, int right,int count) {
    int mid;
    if(left<right)	{		
        mid=(left+right)/2;		
        count = MerSort(num,temp,left,mid,count);//����ǰ�벿��		
        count = MerSort(num,temp,mid+1,right,count);//���ź�벿��		
        count = Merge(num,temp,left,mid,right,count);//ǰ�������ֺϲ�	
    }
    return count;
    
}

int quickSort(int num[], int left, int right,int count)
{
    int i, last;
    if (left < right) {
        last = left;
        for (i = left + 1; i <= right; i++) {
            count++;
            if (num[i] < num[left]) {
                last++;
                int temp = num[last];
                num[last] = num[i];
                num[i] = temp;

            }
        }
        int temp = num[left];
        num[left] = num[last];
        num[last] = temp;
        count = quickSort(num, left, last - 1,count);
        count = quickSort(num, last + 1, right,count);
    }
    return count;
}


int main()
{
    int n, i;
    cin >> n >> i;
    int* num = new int[n];
    int* temp = new int[n];
    memset(temp, 0, n * sizeof(int));
    for (int i = 0; i < n; i++) {
        cin >> num[i];
    }
    int count = 0;
    switch (i)
    {
    case 1:count = SelSort(num, n); break;
    case 2:count = BubSort(num, n); break;
    case 3:count = HeapSort(num, n); break;
    case 4:count = MerSort(num, temp,0, n-1,0); break;
    case 5:count = quickSort(num, 0, n - 1, 0); break;
    default:
        break;
    }
    Print(num,n);
    cout << count;
    int* p = num;
    delete(p);
    p = temp;
    delete(p);
    return 0;
}