算法设计学习1

实验目的及要求：

1.复习C语言中函数的定义与调用，指针的实验，结构的定义等；了解学习数据结构的意义和基本概念；
2.了解抽象数据类型和软件构造方法；了解算法效率的度量。

实验设备环境：
微型计算机
DEV C++(或其他编译软件)

实验步骤：
任务一

（1）设计一个把存储在数组中的有个抽象数据元素逆置的算法。逆置就是把数据元素序列变换为数据元素序列, 并要求原数组中的数据元素不被改变。
解题思路：
逆置就是把数组元素序列变换为。这里假设要求原数组中的数据元素不被改变。这个算法的参数应该包括三个：表示原数组的输入参数，表示数据元素个数的输入参数, 表示逆置后数组的输出参数。
算法代码如下：

#include <iostream>
typedef int DataType;
void Reverse(DataType a[], int n, DataType b[] ){
    for(int i = 0; i < n; i++) {
        b[i] = a[n - 1 - i];
    }
}
int main() {
    const int n = 5; 
    DataType a[n] = {1, 2, 3, 4, 5}; 
    DataType b[n]; 
    Reverse(a, n, b); 
    for(int i = 0; i < n; i++) {
        std::cout << b[i] << " ";
    }
    return 0;
}

（2）设计一个把存储在数组中的有个抽象数据元素逆置的算法。逆置就是把数据元素序列变换为数据元素序列, 并要求原数组中的数据元素不被改变。
解题思路：
逆置就是把数组元素序列变换为。这里在数组内部更改。这个算法的参数应该包含数组与数组大小。
算法代码如下：
 

#include <iostream>
typedef int DataType;
void Reverse(DataType a[], int n) {
    int m = n / 2;
    DataType temp;
    for(int i = 0; i < m; i++) {
        temp = a[i];
        a[i] = a[n - 1 - i];
        a[n - 1 - i] = temp;
    }
}
int main() {
    const int n = 5; 
    DataType a[n] = {1, 2, 3, 4, 5}; 
    Reverse(a, n); 
    for(int i = 0; i < n; i++) {
        std::cout << a[i] << " ";
    }
    return 0;
}

（3）设表示阶矩阵的数组和在前边部分已赋值，求实现两个阶矩阵相乘运算的算法的时间复杂度。
解题思路：
设基本语句的执行次数为,有，因为,其中均为常数，所以该算法的时间复杂度为。
算法代码如下：

#include <iostream>
#include <iomanip>
using namespace std;
const int MAX_SIZE = 100; 
void MatrixMultiply(int a[][MAX_SIZE], int b[][MAX_SIZE], int c[][MAX_SIZE], int n) {
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            c[i][j] = 0; 
            for(int k = 0; k < n; k++) {
                c[i][j] += a[i][k] * b[k][j]; 
            }
        }
    }
}
int main() {
    const int n = 3; 
    int a[n][MAX_SIZE] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[n][MAX_SIZE] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}}; 
    int c[n][MAX_SIZE];
    MatrixMultiply(a, b, c, n);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
               cout << setw(5) << c[i][j];
        }
        cout << endl;
    }
    return 0;
}

（4）本例的算法采用冒泡排序法对数组中的个整数类型的元素 (a[0]~a[n-1])从小到大进行排序，求该算法的时间复杂度。
解题思路：
这个算法的时间复杂度随待排序数据的不同而不同。当某次排序过程中没有任何两个数组元素交换位置时，表明数组元素已排序完毕，此时算法将因标记 flag=0 不满足循环条件而结束。但是，在最坏情况下，每次排序过程中都至少有一对数组元素交换位置，因此，最坏情况下该算法的时间复杂度分析如下。设基本语句的执行次数为,则在最坏情况下有 因为,其中为常数，所以该算法的最坏时间复杂度为 。
算法代码如下：

#include <iostream>
void BubbleSort(int a[], int n) {
    int i, j, flag = 1;
    int temp;
    for(i = 1; i < n && flag == 1; i++) {
        flag = 0;
        for(j = 0; j < n - i; j++) {
            if(a[j] > a[j + 1]) {
                flag = 1;
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}
int main() {
    const int n = 5;
    int a[n] = {5, 2, 8, 1, 6};
    BubbleSort(a, n); 
    for(int i = 0; i < n; i++) {
        std::cout << a[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}