1.将两个递增有序的顺序表A,B进行合并，合并后仍然有序，并求中位数。 2.给定一个升序排列的顺序表，请删除重复出现的元素，使每个元素只出现一次，并输出新的顺序表的信息。注:删除元素后顺序表保持升序

1. 合并两个递增有序的顺序表A和B，可以采用双指针法。首先创建一个新的空列表C用于存放结果。设两个指针i和j分别指向A和B的第一个元素。比较这两个元素，将较小的那个添加到C中，并将对应的指针向前移动一位。当其中一个列表遍历完时，只需将另一个未遍历完的列表的所有剩余元素依次添加到C中。最后，C就是合并后的有序列表。中位数的计算取决于合并后的列表长度：如果长度为奇数，中位数就是中间那个元素；如果长度为偶数，中位数则是中间两个元素的平均值。

2. 对于给定的升序排序的顺序表，可以遍历一遍，使用哈希集合（如Python的set或Java的HashSet）存储已经遇到过的元素。每当遇到一个新元素（不在集合中），就将其添加到结果列表并更新集合。这样，遍历结束后，结果列表即为去重后的升序序列。输出结果列表的长度和内容即可。例如，如果你正在使用Python，可以这样做：

def remove_duplicates(order_list):
    unique_list = []
    for item in order_list:
        if item not in unique_list:
            unique_list.append(item)
    return len(unique_list), unique_list

相关问题

请用C语言回答1.将两个递增有序的顺序表A,B进行合并，合并后仍然有序，并求中位数。 2.给定一个升序排列的顺序表，请删除重复出现的元素，使每个元素只出现一次，并输出新的顺序表的信息。注:删除元素后顺序表保持升序

1. 合并两个递增有序的顺序表A和B，可以使用双指针法。首先创建一个新的空表C作为结果。然后设置两个指针i和j分别指向A和B的头部。比较两个指针所指的元素，将较小的那个添加到结果表C，并移动对应的指针。当其中一个列表遍历完后，直接将另一个列表剩余的部分复制到结果表C的剩余位置。最后，对结果表C进行遍历即可得到排序后的顺序表。

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void merge(Node** A, Node** B) {
    Node* C = NULL;
    Node* tail = NULL;
    while (*A && *B) {
        if ((*A)->data <= (*B)->data) {
            if (C == NULL) {
                C = *A;
                tail = C;
            } else {
                tail->next = *A;
                tail = tail->next;
            }
            (*A)++;
        } else {
            if (C == NULL) {
                C = *B;
                tail = C;
            } else {
                tail->next = *B;
                tail = tail->next;
            }
            (*B)++;
        }
    }
    // 如果有一个列表还有剩余元素，直接添加到结果表尾部
    while (*A) {
        tail->next = *A;
        tail = tail->next;
        (*A)++;
    }
    while (*B) {
        tail->next = *B;
        tail = tail->next;
        (*B)++;
    }
}

double findMedianSortedList(Node* list) {
    int length = 0;
    Node* slow = list, *fast = list;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        length++;
    }

    if (length % 2 != 0) {
        return (double)(slow->data);
    } else {
        return (double)(slow->data + fast->data) / 2.0;
    }
}

2. 删除升序顺序表中的重复元素，可以先创建一个新的空表D，然后遍历原表。对于每个元素，如果它比当前表头大或为空，则将其添加到新表D；若相等则跳过。遍历完成后，新表D即为去重后的顺序表。

void removeDuplicates(Node** A) {
    Node* D = NULL;
    Node* D_tail = NULL;
    for (Node* temp = *A; temp != NULL; temp = temp->next) {
        if (D_tail && D_tail->data < temp->data) {
            D_tail->next = temp;
            D_tail = D_tail->next;
        } else if (D == NULL || temp->data > D_tail->data) {
            if (D != NULL) {
                D_tail->next = temp;
            } else {
                D = temp;
            }
            D_tail = temp;
        }
    }
    *A = D;
}

给定一个长度为n的随机序列a[n]；

1. 找出序列中的最大值和最小值

可以使用两个变量分别记录最大值和最小值，遍历一遍序列即可找到最大值和最小值。时间复杂度为O(n)。

2. 统计序列中每个元素的出现次数

可以使用一个哈希表（或字典）来记录每个元素的出现次数，遍历一遍序列即可。时间复杂度为O(n)，但需要额外的空间来存储哈希表。

3. 对序列进行排序

可以使用快速排序、归并排序等排序算法来对序列进行排序。时间复杂度一般为O(nlogn)。如果只需要找到最大值或最小值，则可以使用堆排序，时间复杂度为O(nlogk)，其中k为堆的大小（k=1时即为找最大值，k=n时即为找最小值）。

4. 查找序列中是否存在某个元素

可以使用线性查找或二分查找来查找序列中是否存在某个元素。线性查找的时间复杂度为O(n)，二分查找的时间复杂度为O(logn)。但二分查找要求序列是有序的。

5. 求序列的平均值或中位数

可以遍历一遍序列来求平均值，时间复杂度为O(n)。求中位数可以使用快速选择算法，时间复杂度为O(n)。

6. 删除序列中的某个元素

可以使用线性查找或哈希表来找到需要删除的元素，然后将其从序列中删除。时间复杂度为O(n)。如果需要频繁删除元素，可以使用链表来存储序列，时间复杂度为O(1)。

7. 合并两个序列

可以使用归并排序的思想，将两个序列合并成一个有序序列。时间复杂度为O(nlogn)。

8. 查找序列中的最长递增子序列

可以使用动态规划算法来求解，时间复杂度为O(n^2)。也可以使用二分查找+贪心的算法，时间复杂度为O(nlogn)。