SCAU程序设计在线实训平台_实验_数据结构_实验6

最新推荐文章于 2022-07-26 20:41:58 发布
最新推荐文章于 2022-07-26 20:41:58 发布
阅读量1.1k 收藏 7
点赞数 2
分类专栏： SCAU 编程学习 SCAU数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23211951/article/details/117791592
版权
SCAU 同时被 3 个专栏收录
33 篇文章 60 订阅
订阅专栏
编程学习
31 篇文章 8 订阅
订阅专栏
SCAU数据结构
7 篇文章 30 订阅
订阅专栏

好久没更CSDN了，个人博客同步更新，欢迎大家来看

8638 直接插入排序

Description

用函数实现直接插入排序，并输出每趟排序的结果.

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出一趟排序结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

4 5 8 0 9 3 2 6 7 1
4 5 8 0 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 3 4 5 8 9 2 6 7 1
0 2 3 4 5 8 9 6 7 1
0 2 3 4 5 6 8 9 7 1
0 2 3 4 5 6 7 8 9 1
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>
using namespace std;

void Insort(int *sq, int len) {
    for (int i = 2; i <= len; ++i) {
        if (sq[i] < sq[i - 1]) {
            sq[0] = sq[i];//哨岗
            sq[i] = sq[i - 1];//移位
            int j;
            for (j = i - 1; sq[j - 1] > sq[0]; j--)
                sq[j] = sq[j - 1];//移位，找位置，直到要插入的位置的前一个元素<=要插入的元素（等于的话一般为碰到哨岗，所以插在第一位）
            sq[j] = sq[0];//插入
        }
        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
    }
}

int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    Insort(sq, cas);
}

8639 折半插入排序

Description

用函数实现折半插入排序，并输出每趟排序的结果.

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出一趟排序结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

4 5 8 0 9 3 2 6 7 1
4 5 8 0 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 3 4 5 8 9 2 6 7 1
0 2 3 4 5 8 9 6 7 1
0 2 3 4 5 6 8 9 7 1
0 2 3 4 5 6 7 8 9 1
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;

void BInsort(int *sq, int len) {
    for (int i = 2; i <= len; ++i) {
        sq[0] = sq[i];
        int s = 1, e = i - 1;//查找区间
        //折半查找可插入的位置
        while (s <= e) {
            int m = (s + e) / 2;
            if (sq[0] < sq[m])e = m - 1;
            else s = m + 1;
        }
        //此时m为要插入的位置
        //将插入位置m=e+1后的元素统一后移，
        for (int j = i; j > e + 1; j--)sq[j] = sq[j - 1];

        sq[e + 1] = sq[0];//插入

        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
    }
}

int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    BInsort(sq, cas);
}

8640 希尔(shell)排序

Description

用函数实现希尔(shell)排序，并输出每趟排序的结果,初始增量d=n/2,其后d=d/2

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出一趟排序结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

3 2 6 0 1 5 4 8 7 9
1 0 3 2 4 5 6 8 7 9
0 1 2 3 4 5 6 7 8 9

代码实现

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


void shellSort(int a[], int len) {
    int tmp;
    int d = len / 2;
    while (d) {
        for (int i = d; i < len; i++) //分组，遍历每个组
        {
            tmp = a[i];
            int j = i;
            //组内向前查询可插入的位置
            while (j >= d && tmp < a[j - d]) {
                a[j] = a[j - d];//记录后移
                j -= d;//前一个组内元素
            }
            a[j] = tmp;//插入
        }
        d = d / 2;
        for (int i=0;i<len;i++) {
            printf("%d ",a[i]);
        }
        cout<<endl;
    }
}

int main() {
    int n;

    cin>>n;
    int L[n];
    for(int i=0;i<n;i++){
        scanf("%d",&L[i]);
    }


    shellSort(L, n);

    return 0;
}

8641 冒泡排序

Description

用函数实现冒泡排序，并输出每趟排序的结果(要求当一趟冒泡过程中不再有数据交换，则排序结束)

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出每趟排序结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

4 5 0 8 3 2 6 7 1 9
4 0 5 3 2 6 7 1 8 9
0 4 3 2 5 6 1 7 8 9
0 3 2 4 5 1 6 7 8 9
0 2 3 4 1 5 6 7 8 9
0 2 3 1 4 5 6 7 8 9
0 2 1 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;

void Bubblesort(int *sq, int len) {
    int end = len - 1;//未排序的结束位置
    bool flag;//是否发生交换
    while (end > 0 && flag){
        flag= false;
        for (int i = 1; i <= end; ++i) {
            if(sq[i]>sq[i+1]){
                int tmp=sq[i];
                sq[i]=sq[i+1];
                sq[i+1]=tmp;
                flag= true;//发生交换
            }
        }
        end--;
        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
    }
}

int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    Bubblesort(sq, cas);
}

8642 快速排序

Description

用函数实现快速排序，并输出每次分区后排序的结果

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出每趟排序的结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

1 4 2 0 3 5 9 6 7 8
0 1 2 4 3 5 9 6 7 8
0 1 2 4 3 5 9 6 7 8
0 1 2 3 4 5 9 6 7 8
0 1 2 3 4 5 8 6 7 9
0 1 2 3 4 5 7 6 8 9
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;

int Part(int *sq, int l, int r) {
    sq[0] = sq[l];
    int piv = sq[l];
    while (l < r) {
        while (sq[r] >= piv && l < r)r--;//从右往左找到第一个小于枢轴的
        sq[l] = sq[r];
        while (sq[l] <= piv && l < r)l++;//左往右找大的
        sq[r] = sq[l];
    }

    sq[l] = sq[0];
    return l;//返回枢轴
}


void Qsort(int *sq, int l, int r,int len) {
    if (l < r) {
        int pivLoc = Part(sq, l, r);
        for (int k = 1; k <= len; ++k)//这里的len只用于打印，可删除
            cout << sq[k] << " ";
        cout << endl;
        Qsort(sq, l, pivLoc - 1,len);
        Qsort(sq, pivLoc + 1, r,len);
    }
}


int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    Qsort(sq,1, cas,cas);
}

8643 简单选择排序

Description

用函数实现简单选择排序，并输出每趟排序的结果

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出每趟排序的结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

0 4 8 5 9 3 2 6 7 1
0 1 8 5 9 3 2 6 7 4
0 1 2 5 9 3 8 6 7 4
0 1 2 3 9 5 8 6 7 4
0 1 2 3 4 5 8 6 7 9
0 1 2 3 4 5 8 6 7 9
0 1 2 3 4 5 6 8 7 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;


void Ssort(int *sq, int len) {
    for (int i = 1; i < len; ++i) {
        int k = i;
        for (int j = i + 1; j <= len; ++j)//找到后面最小的
            if (sq[j] < sq[k])k = j;

        //if (k == i)continue;//如果没有，下一个，题目不需要跳过
        int tmp = sq[k];
        sq[k] = sq[i];
        sq[i] = tmp;

        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
    }
}


int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    Ssort(sq, cas);
}

8644 堆排序

Description

用函数实现堆排序，并输出每趟排序的结果

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

第一行：初始建堆后的结果
其后各行输出交换堆顶元素并调整堆的结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

9 7 8 6 4 3 2 5 0 1
8 7 3 6 4 1 2 5 0 9
7 6 3 5 4 1 2 0 8 9
6 5 3 0 4 1 2 7 8 9
5 4 3 0 2 1 6 7 8 9
4 2 3 0 1 5 6 7 8 9
3 2 1 0 4 5 6 7 8 9
2 0 1 3 4 5 6 7 8 9
1 0 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;

//假设r[s+1..m]已经是堆，将r[s..len]调整为以r[s]为根的大根堆
void Adjust(int *sq, int s, int len) {

    int rc = sq[s];//最初根节点
    int left = 2 * s;
    for (int i = left; i <= len; i *= 2) {
        if (sq[i] < sq[i + 1] && i < len)i++;//取左右节点较大那个
        if (rc < sq[i]) {//筛
            sq[s] = sq[i];//向前换
            s = i;//指针跟进
        }
    }
    sq[s] = rc;//这个替换是个循环
}

void CreatHeap(int *sq, int len) {
    for (int i = len / 2; i > 0; --i)//从下往上，逐个树生成大顶堆
        Adjust(sq, i, len);
}

void StackSort(int *sq, int len) {
    CreatHeap(sq, len);

    //从最后一个节点开始往前换
    for (int i = len; i > 1; --i) {
        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
        int tmp = sq[1];
        sq[1] = sq[i];
        sq[i] = tmp;
        Adjust(sq, 1, i - 1);//每次换后调整为大顶堆
    }
}


int main() {
    int cas;
    int sq[100000];
    cin >> cas;
    for (int i = 1; i <= cas; ++i)
        cin >> sq[i];
    StackSort(sq, cas);
    for (int k = 1; k <= cas; ++k)
        cout << sq[k] << " ";
    cout << endl;
}

8645 归并排序（非递归算法）

Description

用函数实现归并排序（非递归算法），并输出每趟排序的结果

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出每趟排序的结果，数据之间用一个空格分隔

输入样例

10
5 4 8 0 9 3 2 6 7 1

输出样例

4 5 0 8 3 9 2 6 1 7
0 4 5 8 2 3 6 9 1 7
0 2 3 4 5 6 8 9 1 7
0 1 2 3 4 5 6 7 8 9

代码实现

#include <iostream>

using namespace std;
int len;

void Merge(int x[], int l, int m, int r) {
    int *tmp = new int[r - l + 10];//暂存
    int i = l, j = m + 1, k = 0;//i为左半部分索引，j为右半部分，k为y中索引
    while (i <= m && j <= r) {
        if (x[i] >= x[j])tmp[k++] = x[j++];
        else tmp[k++] = x[i++];
    }

    //剩余部分
    while (i <= m)tmp[k++] = x[i++];
    while (j <= r)tmp[k++] = x[j++];
    //返回
    for (i = l, k = 0; i <= r; i++, k++) {
        x[i] = tmp[k];
    }
    delete[]tmp;//释放内存，由于指向的是数组，必须用delete []
}

//两组两组归并
void group_two(int x[], int gap) {
    int i = 1;

    //是否还能划出两组
    while (i + 2 * gap - 1 < len) {
        Merge(x, i, i + gap - 1, i + 2 * gap - 1);
        i += 2 * gap;
    }

    //划不出两组但能划出一组
    if (i + gap - 1 < len) Merge(x, i, i + gap - 1, len);

    //一组也画不出则不管
}

void Msort(int x[])//确定每一次合并的跨度span
{
    for (int gap = 1; gap < len; gap *= 2)//再大就不用分了
    {
        group_two(x, gap);
        for (int k = 1; k <= len; ++k)
            cout << x[k] << " ";
        cout << endl;
    }
}


int main() {
    int sq[100000];
    cin >> len;
    for (int i = 1; i <= len; ++i)
        cin >> sq[i];
    Msort(sq);
}

8646 基数排序

Description

用函数实现基数排序，并输出每次分配收集后排序的结果

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

输出格式

每行输出每趟每次分配收集后排序的结果，数据之间用一个空格分隔

输入样例

10
278 109 063 930 589 184 505 069 008 083

输出样例

930 063 083 184 505 278 008 109 589 069
505 008 109 930 063 069 278 083 184 589
008 063 069 083 109 184 278 505 589 930

代码实现

#include <iostream>
#include <string>
#include <queue>

using namespace std;
#define RADIX 10//基数

int len;//记录数
string sq[1000];//用string方便取一个整数的某一位，此处偷懒了，没有按题目要求用链式，而使用的顺序结构。
queue<string> Bucket[RADIX];//子表，也就是桶排序中的桶

void RDsort() {
    int recLen = sq[1].length();//记录的长度，也就是位数

    //逐个取关键字，即某个位数，从右往左，直到第一个下标为0
    for (int i = recLen - 1; i >= 0; --i) {

        //遍历主表每个记录，分配入桶，主表下标从1开始
        for (int j = 1; j <= len; ++j)
            Bucket[sq[j][i] - 48].push(sq[j]);//字符转整数，供下标使用


        int newLoc = 1;//新主表的下标，表示刚出桶的元素应该插入到哪个位置
        //遍历每个桶，合并出桶，下标从0开始
        for (int j = 0; j < RADIX; ++j) {
            //清空该桶
            while (!Bucket[j].empty()) {
                sq[newLoc++] = Bucket[j].front();//插入回新主表
                Bucket[j].pop();
            }
        }

        for (int k = 1; k <= len; ++k)
            cout << sq[k] << " ";
        cout << endl;
    }
}

int main() {
    cin >> len;//记录数
    for (int i = 1; i <= len; ++i)
        cin >> sq[i];
    RDsort();
}
YelloooBlue
关注
专栏目录
7-2 链式基数排序 (20分)
weixin_46047462的博客
11-23 4262
7-2 链式基数排序 (20分) 实现链式基数排序，待排序关键字n满足1≤n≤1000，最大关键字数位≤5。 输入样例： 第一行输入待排序个数n（1≤n≤1000）,再输入n个数(n的数位≤5)。 10 278 109 63 930 589 184 505 269 8 83 输出样例： 输出每趟分配-收集后链表中的关键字，趟数为序列中最大值的数位（如样例中930的数位为3），每行结尾有空格。 930 63 83 184 505 278 8 109 589 269 505 8 109 930 63 269
2021SCAU数据结构复习 实验六 （各种排序算法）-实验7
weixin_50340097的博客
06-14 2082
题1：8638 直接插入排序 题目描述 Description 用函数实现直接插入排序，并输出每趟排序的结果. 输入格式 第一行：键盘输入待排序关键的个数n 第二行：输入n个待排序关键字，用空格分隔数据 输出格式 每行输出一趟排序结果，数据之间用一个空格分隔 输入样例 10 5 4 8 0 9 3 2 6 7 1 输出样例 4 5 8 0 9 3 2 6 7 1 4 5 8 0 9 3 2 6 7 1 0 4 5 8 9 3 2 6 7 1 0 4 5 8 9 3 2 6 7 1 0 3 4 5 8 9 2
scau数据结构各类排序算法
xuge520的博客
06-17 446
目录8638 直接插入排序8639 折半插入排序8640 希尔(shell)排序8642 快速排序8644 堆排序8645 归并排序（非递归算法）
算法 - C语言实现希尔排序（Shell_sort）
曾铎的博客
07-26 2137
插入排序相比较于冒泡排序和选择排序的优点在于时间复杂度的降低，冒泡排序和选择排序的时间复杂度均为O（n。）～O（n）之间的，所以从时间复杂度上面来看，插入排序总体的效率是要优于冒泡排序的。但是如果我们使用插入排序的话，效率就会大大提高，只需要一趟即可将元素0放在最前面。中讲到过，插入排序是在序列中已经有一部分序列是有序的所进行的排序，希尔排序相当于是对插入排序的优化，在我的上一篇文章。），但是插入排序的时间复杂度是介于O（n。在插入排序中越有序，效率越高。........................
SCAU 数据结构 8639 折半插入排序
m0_62122789的博客
06-11 512
折半插入排序
scau.rar_scau\_培训微信_天气预报 _豆瓣电影_豆瓣电影推荐
09-23
【标题】"scau.rar_scau\_培训微信_天气预报 _豆瓣电影_豆瓣电影推荐" 提供的信息表明，这是一个与华南农业大学（Scau）相关的项目，重点涉及微信小程序的开发，特别是实现了天气预报功能和豆瓣电影推荐功能。...
高级程序语言设计.期末综合性实验.rar
07-15
SCAU的高级程序语言设计，期末综合性实验。 题目是：文件操作与字符处理 资源是一个rar文件，因为里面有两个文件的，用WIN.rar解压了就好。 包括： 实验程序（运行程序，用DEV写的） 综合性实验报告（根据上面的代码...
SCAU_人工智能实验_ai2015.zip
最新发布
09-28
SCAU_人工智能实验_ai2015
SCAU2024面向对象程序设计课后习题
09-24
因为我没报这门课所以这个资料是从别的人那里拿过来的，之后的Java题解就照着这个习题册来，大概也是四十几道题
五彩缤纷的色彩与色彩内涵与意义
03-12
全书内容分为两个方面，一是Photoshop CS2的内容，包括图像基本编辑方法、色彩调整方法、使用Photoshop CS2绘画的方法、文本处理方法、图层、通道和滤镜的运用等。二是CorelDRAW X3的内容，包括绘制各种图形、颜色的...
8640 希尔(shell)排序（c++）
weixin_43692948的博客
06-14 1166
8640 希尔(shell)排序 Description 用函数实现希尔(shell)排序，并输出每趟排序的结果,初始增量d=n/2,其后d=d/2 输入格式 第一行：键盘输入待排序关键的个数n 第二行：输入n个待排序关键字，用空格分隔数据 输出格式 每行输出一趟排序结果，数据之间用一个空格分隔 输入样例 10 5 4 8 0 9 3 2 6 7 1 输出样例 3 2 6 0 1...
直接排序和希尔排序
Ming-Kai
05-19 279
8640 希尔(shell)排序 时间限制:1000MS 代码长度限制:10KB 提交次数:1858 通过次数:1304 题型: 编程题 语言: G++;GCC Description 用函数实现希尔(shell)排序，并输出每趟排序的结果,初始增量d=n/2,其后d=d/2 输入格式 第一行：键盘输入待排序关键的个数n 第二行：输入n个待排序关键字，用空格分隔数据 输出格式 每行输出一趟排序结果，数据之间用一个空格分隔 输入样例 10 5 4 8 0 9 3 2 6 7 1 输出样例 3 2 6 0
希尔（Shell）排序的理解
warmcore的博客
05-04 761
每一次描述也是一次对自己思维的梳理。记录一下对希尔排序的简单理解。通俗点来说，希尔排序就是将一组元素将相隔一定增量的元素抽取出来划为一组，再把这一组里面的元素进行直接插入排序，一般增量的递减次数每次缩小一半，直至为1，排序就完成了。 举个例子，比如3,30,18,250,10,12,8,2,1,4这10个元素，先除以2，得到增量为5，那么3,12为一组，30,8为一组等等。在组内直接插入排序。
快速、冒泡、选择、直接插入C语言实现
lvmengmeng
02-24 1191
#include //快速排序 void quickSort(int a[],int left,int right) { int i,j,temp; i=left; j=right; temp=a[left]; if(left>right) return; while(i!=j) { while(a[j]>temp&&j>i) j--; if(j>i) a[i++]=
插入排序（java）
jeanszu的专栏
10-08 471
插入排序的思想如下： 每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。 　　 第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 第二趟把第三个数据与前两个数从前向后扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。　　 直接插入排序属于稳定的排序，时间复杂性为o(n^2)，空间复杂度为O
8639 折半插入排序
remakeprogramer的博客
06-06 475
8638 直接插入排序 8638 直接插入排序 时间限制:1000MS 代码长度限制:10KB 提交次数:2050 通过次数:1393 题型: 编程题 语言: G++;GCC Description 用函数实现直接插入排序，并输出每趟排序的结果. 输入格式 第一行：键盘输入待排序关键的个数n 第二行：输入n个待排序关键字，用空格分隔数据 输出格式 每行输出一趟排序结果，数据之间用一个空格分隔 输入样例 10 5 4 8 0 9 3 2 6 7 1 输出样例 4 5 8 0 9 3 2 6 7 1 4
白话经典算法系列之二 直接插入排序的三种实现
热门推荐
MoreWindows Blog
08-06 15万+
直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。   设数组为a[0…n-1]。 1.      初始时，a[0]自成1个有序区，无序区为a[1..n-1]。
alanwang[GDOU] 直接插入排序法简单演示
Alan的博客
12-03 115
int main() { int a[10]; int p; printf("input 10 numbers:\n"); for(p=0;p<10;p++) scanf("%d",&a[p]); printf("\n"); int i,j,q; for(i=1; i<11; i++) if(a[i] < a[i-1]) { int X = a[i]; /
直接插入排序和选择排序
小不点的博客
07-24 9387
（一）直接插入排序 思路： （1）用一个临时变量存放待排序的数字； （2）从数组前依次遍历找第一个比待排序数字大的数字的位置； （3）将从待排序的数字位置开始，到找的要插入的数字的位置之间的数字向后挪一位，最后将待排序数字插入到找到的位置； 代码如下： void Insert_Sort( int *arr,int len ) { int tmp = 0;//当作哨兵位 ...
SCAU OJ 数据结构 综合性实验
06-11
SCAU OJ，全称为Shandong University of Architecture and Civil Engineering Online Judge，是中国山东建筑大学的在线编程竞赛平台。这个平台通常提供数据结构和算法相关的综合性实验题目，目的是帮助学生们提升编程技能，特别是对数据结构的理解和应用能力。 在SCAU OJ的综合性实验中，你会遇到各种复杂的数据结构问题，比如链表、树（如二叉搜索树、AVL树、红黑树等）、图、堆、队列、栈、哈希表、并查集、优先队列等。这些题目可能涉及基本操作（如查找、插入、删除），也可能包含高级数据结构的优化问题，或者是结合多种数据结构的综合应用。 实验可能会包括但不限于以下几个方面： 1. **基础操作**：理解如何高效地实现基本的数据结构的操作，如动态数组扩容、链表节点管理等。 2. **高级数据结构**：掌握如何设计和实现高级数据结构，如使用二分查找优化查找时间，或使用平衡树保证插入和删除的性能。 3. **算法与数据结构结合**：将特定算法（如排序、搜索）与数据结构相结合，解决实际问题。 4. **空间效率与时间复杂度**：关注内存管理，理解不同数据结构的空间效率，并分析算法的时间复杂度。 5. **递归和分治**：通过数据结构实现递归或分治算法，解决复杂问题。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值