（免费）anyview答案 数据结构(C语言版)-广工(第三章）

目录

DC03PE01

DC03PE03

DC03PE06

DC03PE23

---

DC03PE01

计算升序直接插入排序中元素移动的次数

[20240102]对于经典的升序直接插入排序算法，对其进行尽量小的修改，计算元素的移动次数。

顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key; 
   ... 
} RcdType;

typedef struct 
{
    RcdType* rcd;         // 存储空间基址，0号单元未用
    int length;           // 当前长度
    int size;             // 存储容量
} RcdSqList;

实现下列函数：
int conflictsOfInsertSort(RcdSqList* L)
// 返回升序直接插入排序中元素移动的次数

int conflictsOfInsertSort(RcdSqList* L){
    int result = 0;
    int i, j;
    for (i = 1; i < L->length; ++i)    {
        if (L->rcd[i + 1].key < L->rcd[i].key)        {
             L->rcd[0] = L->rcd[i + 1];
             j = i + 1;
             do {
                j--;
                L->rcd[j + 1] = L->rcd[j];
                result++;
             } while (L->rcd[0].key < L->rcd[j - 1].key);
             L->rcd[j] = L->rcd[0];
        }
    }
    return result;
 }

DC03PE03

以L.rcd[L.length+1]作为监视哨，改写直接插入排序算法

【20220422】试以顺序表L的L.rcd[L.length+1]作为监视哨，改写教材3.2节中给出的升序直接插入排序算法。

顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key; 
   ... 
} RcdType;

typedef struct 
{
    RcdType* rcd;         // 存储空间基址，0号单元未用
    int length;           // 当前长度
    int size;             // 存储容量
} RcdSqList;

实现下列函数：
void InsertSort(RcdSqList &L);

void InsertSort(RcdSqList &L){
    int i, j;    // 从第二个元素开始插入
    for (i = 2; i <= L.length; i++) {// 将待插入元素放入监视哨位置
        L.rcd[L.length + 1] = L.rcd[i];
        j = i - 1;        // 寻找插入位置
        while (L.rcd[L.length + 1].key < L.rcd[j].key) {            // 元素后移
            L.rcd[j + 1] = L.rcd[j];
            j--;
        }        // 插入元素
        L.rcd[j + 1] = L.rcd[L.length + 1];
    }
 }

DC03PE06

改进冒泡排序算法

【20220422】改写冒泡排序算法：
将算法中起控制作用的布尔变量change改为一个整型变量，指示每一趟排序中进行交换的最后一个记录的位置，并以它作为下一趟起泡排序循环终止的控制值。

顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key; 
   ... 
} RcdType;

typedef struct {
   RcdType rcd[MAXSIZE+1]; // rcd[0]闲置
   int length;
} RcdSqList2;

实现以下函数：
void BubbleSort(RcdSqList2 &L);
/* 元素比较和交换必须调用以下比较函数和交换函数：*/

以下比较函数和交换函数可供调用：
/* Status LT(RcdType a, RcdType b);   比较："<"  */
/* Status GT(RcdType a, RcdType b);   比较：">"  */
/* void Swap(RcdType &a, RcdType &b); 交换       */

void BubbleSort(RcdSqList2 &L) {
    int lastExchangeIndex = L.length;
    int bound;
    while (lastExchangeIndex > 1) {
        bound = lastExchangeIndex;
        lastExchangeIndex = 1;
        for (int j = 1; j < bound; j++) {
            if (GT(L.rcd[j], L.rcd[j + 1])) {
                Swap(L.rcd[j], L.rcd[j + 1]);
                lastExchangeIndex = j;
            }
        }
    }
}

DC03PE23

计数排序算法

【20220422】已知记录序列L.rcd[1..L.length]中的关键字各不相同，可按如下所述实现计数排序：另设数组c[1..n]，对L.rcd中的每个记录a[i]， 统计序列中关键字比a[i]小的记录个数存于c[i]，则c[i]=0的记录必为关键字最小的记录，然后依c[i]值的大小对序列中记录进行重新排列。试编写算法实现上述排序方法。

注意：请自行定义计数数组c，用于排序辅助。

顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key; 
   ... 
} RcdType;

typedef struct {
   RcdType rcd[MAXSIZE+1]; // rcd[0]闲置
   int     length;
} RcdSqList2;

实现下列函数：
void CountSort(RcdSqList2 &L);
/* 采用顺序表存储结构，在函数内自行定义计数数组c */

void CountSort(RcdSqList2 &L)  {
    if (L.length <= 1) {
        return; 
    }
    int *c = (int *)malloc((L.length + 1) * sizeof(int));
    if (c == NULL) {
        return; 
    }
    for (int i = 1; i <= L.length; i++) {
        c[i] = 0;
    }
    for (int i = 1; i <= L.length; i++) {
        for (int j = 1; j <= L.length; j++) {
            if (L.rcd[j].key < L.rcd[i].key) {
                c[i]++;
            }
        }
    }
    RcdType *temp = (RcdType *)malloc((L.length + 1) * sizeof(RcdType));
    if (temp == NULL) {
        free(c);
        return;
    }
    for (int i = 1; i <= L.length; i++) {
        temp[c[i] + 1] = L.rcd[i];
    }
    for (int i = 1; i <= L.length; i++) {
        L.rcd[i] = temp[i];
    }
    free(c);
    free(temp);
}