SCAU程序设计在线实训OJ数据结构实验6排序算法代码整理（1）

华农第一蒟蒻

已于 2024-05-30 20:00:32 修改

阅读量610

点赞数 18

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

于 2024-05-15 21:17:13 首次发布

本文链接：https://blog.csdn.net/2301_80011650/article/details/138921809

版权

排序专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.直接插入排序

直接插入排序算法的原理，简单来讲就是将无序的一组数中的其中一个数插入到有序的一组数中。我们取每次都取出无序数的第一个数字，将其插入到有序数中即可。详见代码


#include <iostream>
using namespace std;

void Insertsort(int* a, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (a[end] > tmp)
            {
                a[end + 1] = a[end];
                end--;
            }
            else
                break;
        }
        a[end + 1] = tmp;

        for (int i = 0; i < n; i++)
        {
            cout << a[i] << ' ';
        }
        cout << endl;
    }
}

int main()
{
    int n, a[100];
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    Insertsort(a, n);
    return 0;
}

2.折半插入排序

折半插入排序与直接插入排序唯一的区别就是：折半插入排序运用了二分查找。折半插入排序的基本思想是：顺序地把待排序的序列中的各个元素按其关键字的大小，通过二分查找插入到已排序的序列的适当位置。关键点：插入位置为r+1处

#include <iostream>
using namespace std;

void binarysort(int* a, int n)
{
    int l, r, mid;
    int i, j ,k;
    for (i = 1; i < n; i++)
    {
        l = 0, r = i - 1;
        while (l <= r)
        {
            mid = (l + r) / 2;
            if (a[i] < a[mid])
                r = mid - 1;
            else
                l = mid + 1;
        }
        //跳出循环后，r+1的位置即为要插入的位置

        int t = a[i]; //待插入元素

        for (j = i-1; j >= r+1; j--)
        {
            a[j+1] = a[j]; //后移
        }
        a[j+1] = t;

        for (int t = 0; t < n; t++)
        {
            cout << a[t] << ' ';
        }
        cout << endl;

    }
}
int main()
{
    int n;
    cin >> n;
    int a[100];
    for (int i = 0; i < n; i++)
        cin >> a[i];
    binarysort(a, n);
    return 0;
}

3.希尔排序

希尔排序也是一种插入排序，只不过它每次进行排序的数字间隔不同。但需要注意的是，最后一次间隔必须为一，即最后一次排序为一次正常的直接插入排序。以下我给出了两种代码：

OJ AC代码

#include <iostream>
using namespace std;

void ShellSort(int* a, int len)
{
    int gap = len/2;
    while (gap)
    {
        int i;
        for (i = gap; i < len; i++) 
        {
            int j = i;
            int temp = a[i];
            while (j >= gap && temp < a[j - gap])
            {
                a[j] = a[j - gap];
                j -= gap;
            }
            a[j] = temp;
        }
        gap = gap / 2;
        for (int k = 0; k < len; k++)
        {
            cout << a[k] << " ";
        }
        cout << endl;
       
    }
}

int main()
{
    int a[100];
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    ShellSort(a, n);
    return 0;
}

比较易于理解的代码，以供学习



#include <iostream>
using namespace std;

void Shellsort(int* a, int n)
{
    int gap = n;
    while (gap>1)
    {
        gap = gap / 3 +1 ;
        for (int i = 0; i < n - gap; i++) //1改为gap
        {
            int end = i;
            int tmp = a[end + gap];   //1改为gap
            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end + gap] = a[end];  //1改为gap
                    end-=gap; //end-=1改为end-=gap
                }
                else
                    break;
            }
            a[end + gap] = tmp;

            for (int i = 0; i < n; i++)
            {
                cout << a[i] << ' ';
            }
            cout << endl;
        }
    }
    
}

int main()
{
    int n, a[100];
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    Shellsort(a, n);
    return 0;
}

4.冒泡排序

冒泡排序，有手就行！

不过需要注意的是，我们这里需要定义一个标记flag。如果没有数字再进行交换时，我们就没有必要继续进行排序了，直接break。这样子也是对算法的一种优化，减少了程序执行的次数。详见代码

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

void BubbleSort(int* a, int n)
{
    int flag;
    for (int i = 0; i < n-1 ; i++)
    {
        flag = 0;
        for (int j = 0; j < n - 1-i; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
                flag = 1;
            }
        }

        for (int k = 0; k < n; k++)
            cout << a[k] << " ";
        cout << endl;

        if (flag == 0) break;
    }
}
int main()
{
    int n;
    int a[100];
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    BubbleSort(a, n);
    return 0;
}

5.快速排序

快排作为比较重要的一种排序算法，一定要掌握！！

思想就是取一个数字作为基准元素，比基准小的放一边，比基准大的放另外一边。（分治思想）

写代码时需注意细节。例如：如果将左边的第一个元素作为基准元素，那么需要从序列右边的第一个元素开始遍历


#include <iostream>
#include <algorithm>
using namespace std;
int n;
int a[100];

int partition(int a[],int l, int r)
{
    int key = a[l];
    while (l < r)
    {
        while (l < r && a[r] >= key) r--;
        a[l] = a[r];
        while (l < r && a[l] <= key) l++;
        a[r] = a[l];
    }
    a[l] = key;
    for (int i = 0; i < n; i++)
        cout << a[i] << ' ';
    cout << endl;
    return l;
}

void quicksort(int a[],int l, int r)
{
    if (l >= r) return;
    else {
        int mid = partition(a,l, r);
        quicksort(a,l, mid - 1);
        quicksort(a,mid + 1, r);
    }
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    quicksort(a,0, n - 1);
    for (int i = 0; i < n; i++)
        cout << a[i] << ' ';
    return 0;
}

6.简单选择排序

简单选择排序 有手就行

就是不断的将序列的最小的数字往前放就好了


#include <iostream>
#include <algorithm>
using namespace std;
void selectsort(int a[], int len)
{
    
    for (int i = 0; i < len - 1; i++)
    {
        int k = i;
        for (int j = i + 1; j < len; j++)
        {
            if (a[j] < a[k])
                k = j;
        }
        swap(a[i], a[k]);
        for (int t = 0; t < len; t++)
            cout << a[t] << ' ';
        cout << endl;

    }
}
int main()
{
    int n;
    int a[100];
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    selectsort(a, n);
    return 0;
}

7.堆排序

堆排序就是一个不断调整堆及排序的过程。理解起来还是比较简单的。不过要是要先了解一下堆的基本知识。关键是堆的调整过程

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

void HeapAdjust(int *a,int s,int m)
{
    int t = a[s];
    for(int i=2*s;i<=m;i*=2)
    {
        if(i<m&&a[i]<a[i+1]) i++;
        if(t>=a[i])  break;
        else
        {
            a[s] = a[i];
              s = i;
        }

    }
    a[s] = t;
}
void creatheap(int *a,int len)
{
    for(int i=len/2;i>0;i--)
        HeapAdjust(a,i,len);
}

void Heapsort(int *a,int len)
{
    creatheap(a,len);
    for(int i=1;i<=len;i++)
        cout<<a[i]<<' ';
        cout<<endl;
    for(int i=len;i>1;i--)
    {
        swap(a[1],a[i]);
        HeapAdjust(a,1,i-1);

        for(int i=1;i<=len;i++)
        cout<<a[i]<<' ';
        cout<<endl;
    }


}

int a[100];

int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    Heapsort(a,n);

    return 0;
}