顺序表上的一些常见算法

昨天我们学习了顺序表的实现，今天我们通过顺序表上的三个简单常见算法来巩固一下知识

1. void verge(seqlist  *L)    

    将顺序表L就地转置，即借助于O（1）的辅助空间。

void verge(seqlist* L)
{
	int start = 0;
	int end = L->length - 1;
	while (start < end) {
		int temp = L->data[start];
		L->data[start] = L->date[end];
		L->data[end] = temp;
		start++;
		end--;
	}
}

完整代码如下;

#include <stdio.h>

#define MAX_SIZE 100  // 定义顺序表的最大长度

// 定义顺序表的结构体
typedef struct {
    int data[MAX_SIZE];  // 存储元素的数组
    int length;          // 顺序表的当前长度
} SeqList;

// 函数声明
void verge(SeqList *L);
void printList(SeqList *L);

// 顺序表就地转置的函数
void verge(SeqList *L) {
    int start = 0;
    int end = L->length - 1;

    while (start < end) {
        // 交换 start 和 end 位置的元素
        int temp = L->data[start];
        L->data[start] = L->data[end];
        L->data[end] = temp;

        // 移动 start 和 end 指针
        start++;
        end--;
    }
}

// 打印顺序表元素的函数
void printList(SeqList *L) {
    for (int i = 0; i < L->length; i++) {
        printf("%d ", L->data[i]);
    }
    printf("\n");
}

int main() {
    // 创建并初始化顺序表
    SeqList L;
    L.length = 6;  // 顺序表的长度

    // 初始化顺序表元素
    for (int i = 0; i < L.length; i++) {
        L.data[i] = i + 1;
    }

    printf("Original List: ");
    printList(&L);

    // 调用 verge 函数进行就地转置
    verge(&L);

    printf("Reversed List: ");
    printList(&L);

    return 0;
}

运行结果如下：

2. void sprit(seqlist *l1,seqlist *l2, seqlist *l3)        

    将有序顺序表l1分裂成两个线性表l2与l3，l2由表中所奇数组

成，l3由所有偶数组成。

函数实现代码：

void split(SeqList *l1, SeqList *l2, SeqList *l3) {
    for (int i = 0; i < l1->length; i++) {
        if (l1->data[i] % 2 == 0) {
            l3->data[l3->length++] = l1->data[i];
        } else {
            l2->data[l2->length++] = l1->data[i];
        }
    }
}

完整代码如下：

#include <stdio.h>

#define MAX_SIZE 100  // 定义顺序表的最大长度

// 定义顺序表的结构体
typedef struct {
    int data[MAX_SIZE];  // 存储元素的数组
    int length;          // 顺序表的当前长度
} SeqList;

// 函数声明
void split(SeqList *l1, SeqList *l2, SeqList *l3);
void printList(SeqList *L);

int main() {
    // 创建并初始化顺序表 l1
    SeqList l1;
    l1.length = 8;  // 初始化长度
    for (int i = 0; i < l1.length; i++) {
        l1.data[i] = i + 1;  // 用 1 到 8 填充 l1.data
    }

    // 创建并初始化顺序表 l2 和 l3
    SeqList l2;
    l2.length = 0;  // 初始化长度为0
    for (int i = 0; i < MAX_SIZE; i++) {
        l2.data[i] = 0;  // 初始化数据
    }

    SeqList l3;
    l3.length = 0;  // 初始化长度为0
    for (int i = 0; i < MAX_SIZE; i++) {
        l3.data[i] = 0;  // 初始化数据
    }

    // 调用 split 函数
    split(&l1, &l2, &l3);

    // 打印结果
    printf("Odd List: ");
    printList(&l2);

    printf("Even List: ");
    printList(&l3);

    return 0;
}

// 将有序顺序表 l1 分裂成两个线性表 l2 和 l3
void split(SeqList *l1, SeqList *l2, SeqList *l3) {
    for (int i = 0; i < l1->length; i++) {
        if (l1->data[i] % 2 == 0) {
            l3->data[l3->length++] = l1->data[i];
        } else {
            l2->data[l2->length++] = l1->data[i];
        }
    }
}

// 打印顺序表元素的函数
void printList(SeqList *L) {
    for (int i = 0; i < L->length; i++) {
        printf("%d ", L->data[i]);
    }
    printf("\n");
}

3. void merge(seqlist *l1,seqlist *l2, seqlist *l3)          

      将有序顺序表L1与L2合并成有序顺序表L3。

函数实现代码：

void merge(SeqList* l1, SeqList* l2, SeqList* l3) {
    int i = 0, j = 0, k = 0;

    // 合并两个有序顺序表
    while (i < l1->length && j < l2->length) {
        if (l1->data[i] < l2->data[j]) {
            l3->data[k++] = l1->data[i++];
        } else {
            l3->data[k++] = l2->data[j++];
        }
    }

    // 将 l1 中剩余的元素复制到 l3
    while (i < l1->length) {
        l3->data[k++] = l1->data[i++];
    }

    // 将 l2 中剩余的元素复制到 l3
    while (j < l2->length) {
        l3->data[k++] = l2->data[j++];
    }

    // 更新 l3 的长度
    l3->length = k;
}

完整代码如下：

#include <stdio.h>

#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];  // 存储元素的数组
    int length;          // 顺序表的当前长度
} SeqList;

// 合并两个顺序表 l1 和 l2 到 l3
void merge(SeqList* l1, SeqList* l2, SeqList* l3) {
    int i = 0, j = 0, k = 0;

    // 合并两个有序顺序表
    while (i < l1->length && j < l2->length) {
        if (l1->data[i] < l2->data[j]) {
            l3->data[k++] = l1->data[i++];
        } else {
            l3->data[k++] = l2->data[j++];
        }
    }

    // 将 l1 中剩余的元素复制到 l3
    while (i < l1->length) {
        l3->data[k++] = l1->data[i++];
    }

    // 将 l2 中剩余的元素复制到 l3
    while (j < l2->length) {
        l3->data[k++] = l2->data[j++];
    }

    // 更新 l3 的长度
    l3->length = k;
}

void printList(SeqList* l) {
    for (int i = 0; i < l->length; i++) {
        printf("%d ", l->data[i]);
    }
    printf("\n");
}

int main() {
    SeqList l1 = {
   
   {1, 3, 5, 7，13}, 5}; // 第一个顺序表
    SeqList l2 = {
   
   {2, 4, 6, 8}, 4}; // 第二个顺序表
    SeqList l3 = {
   
   {0}, 0};          // 用于存储合并结果的顺序表

    merge(&l1, &l2, &l3);

    printf("Merged List: ");
    printList(&l3);

    return 0;
}