【数据结构习题】合并两个有序数组和两个有序链表序列的合并

合并两个有序数组

要求实现一个函数merge，将长度为m的升序数组a和长度为n的升序数组b合并到一个新的数组c，合并后的数组仍然按升序排列。

函数接口定义：

void printArray(int* arr, int arr_size);           /* 打印数组,细节不表 */
void merge(int* a, int m, int* b, int n, int* c);  /* 合并a和b为c */

其中a和b是按升序排列的数组，m和n分别为数组a、b的长度；c为合并后的升序数组。

输入样例：

输入包含两行。 第一行为有序数组a，其中第一个数为数组a的长度m，紧接着m个整数。 第二行为有序数组b，其中第一个数为数组b的长度n，紧接着n个整数。

7 1 2 14 25 33 73 84
11 5 6 17 27 68 68 74 79 80 85 87

输出样例：

输出为合并后按升序排列的数组。

1 2 5 6 14 17 25 27 33 68 68 73 74 79 80 84 85 87

代码:

此题来自于PTA题库，提交代码时只需提交merge函数即可。

#include 
#include 

void printArray(int* arr, int arr_size);          /* 打印数组,细节不表 */
void merge(int* a, int m, int* b, int n, int* c); /* 合并a和b为c */

int main(int argc, char const *argv[])
{
    int m, n, i;
    int *a, *b, *c;
    //输入第一个数组
    scanf("%d", &m);
    a = (int*)malloc(m * sizeof(int));
    for (i = 0; i < m; i++) {
        scanf("%d", &a[i]);
    }
    //输入第二个数组
    scanf("%d", &n);
    b = (int*)malloc(n * sizeof(int));
    for (i = 0; i < n; i++) {
        scanf("%d", &b[i]);
    }
    //申请一段空间去
    c = (int*)malloc((m + n) * sizeof(int));
    merge(a, m, b, n, c);
    printArray(c, m + n);

    return 0;
}

/* 请在这里填写答案 */

/*
 * @Description : 合并a和b为c
 * @param - a 	: 数组a
 * @param - m 	: 数组a的长度
 * @param - b 	: 数组b
 * @param - n 	: 数组b的长度
 * @param - c 	: 数组c
 * @return 		: 无
 */
void merge(int* a, int m, int* b, int n, int* c)
{
    int i = 0, j = 0, sum = 0;
    while (i < m && j < n){
        //比较大小并且赋值
        if (a[i] < b[j]){
            //如果a的值小于b的值，将a的值放入c中。
            c[sum] = a[i];
            sum++;
            i++;
        }
        else if (a[i] == b[j]){
            c[sum] = a[i];
            sum++;
            i++;
            c[sum] = b[j];
            sum++;
            j++;
        }
        else{
            c[sum] = b[j];
            sum++;
            j++;
        }
    }
    //如果数组b所有元素已经被并入c
    for (;i < m; i++,sum++){
        c[sum] = a[i];
    }
    //如果数组a所有元素已经被并入c
    for (;j < n; j++,sum++){
        c[sum] = b[j];
    }

}
/*
 * @Description : 打印数组,细节不表
 * @param - arr : 数组
 * @param - arr_size : 数组长度
 * @return 		: 无
 */
void printArray(int* arr, int arr_size)
{
    for (int i = 0; i < arr_size; i++){
        printf("%d ",arr[i]);
    }
}

两个有序链表序列的合并

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。

函数接口定义：

List Merge( List L1, List L2 );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。

输入样例：

3
1 3 5
5
2 4 6 8 10

输出样例：

1 2 3 4 5 6 8 10 
NULL
NULL

代码:

#include 
#include 

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表；空链表将输出NULL */

List Merge( List L1, List L2 );

int main()
{
    List L1, L2, L;
    L1 = Read();
    L2 = Read();
    L = Merge(L1, L2);
    Print(L);
    Print(L1);
    Print(L2);
    return 0;
}

/* 你的代码将被嵌在这里 */

/*
 * @Description : 创建一个用户定义的链表
 * @param       : 无
 * @return 		: 新的的链表
 */
List Read()
{
    int n;
    scanf("%d", &n);
    //为头节点申请空间
    List Head = (List)malloc(sizeof(PtrToNode));
    //防止野指针的出现
    Head->Next = NULL;
    //当n不是0的时候
    if (n != 0){
        //创建一个指针
        List p = Head;
        for (int i = 0; i < n; i++){
            //创建一个中间节点
            List Var = (List)malloc(sizeof(PtrToNode));
            //尾插法
            scanf("%d", &(Var->Data));
            //p的指针指向新的元素
            p->Next = Var;
            //p后移动
            p = Var;
        }
        //安全起见，尾指针为空
        p->Next = NULL;
    }
    return Head;
}


/*
 * @Description : 打印链表
 * @param  -L   : 需要打印的链表
 * @return 		: 无
 */
void Print( List L )
{
    //先找到第一个结点，判断是不是空
    L = L->Next;
    if (L == NULL){
        printf("NULL");
    }
    else{
        while (L){
            printf("%d ",L->Data);
            L = L->Next;
        }
    }
    printf("\n");
}


/*
 * @Description : 合并两个链表
 * @param - L1  : 链表1
 * @param - L2  : 链表2
 * @return 		: 合并后的链表
 */
List Merge( List L1, List L2 )
{
    //创建头节点
    List Head = (List)malloc(sizeof(PtrToNode));
    //创建中间节点
    List p = Head;
    //找到第一节点，便于顺序操作
    List p1 = L1->Next;
    List p2 = L2->Next;

    while (p1 != NULL && p2 != NULL){
        //谁小谁在前
        if (p1->Data <= p2->Data){
            //尾插法
            p->Next = p1;
            p = p1;
            //后移
            p1 = p1->Next;
        }
        else{
            //尾插法
            p->Next = p2;
            p = p2;
            //后移
            p2 = p2->Next;
        }
    }
    //若L2中所有元素被并入
    if (p1 != NULL){
        p->Next = p1;
    }
    else{
        p->Next = p2;
    }
    //防止野指针
    L1->Next = NULL;
    L2->Next = NULL;

    return Head;
}