16.二维数组A[15][20]，已知A[10][10]的存储地址为3000，每个数组元素占有4个存储单元，若按照行主序存储则A[13][18]的地址为 ；若按照列主序存储为 。

按照行主序存储时，我们可以计算出A[13][18]的存储地址为：

A[13][18] = A[10][10] + (13-10)*20 + (18-10)
          = 3000 + 60 + 8
          = 3068

其中，(13-10)*20表示行数之差乘以每行的元素个数，(18-10)表示列数之差。因为每个数组元素占4个存储单元，所以需要加上相应的偏移量。

按照列主序存储时，我们可以计算出A[13][18]的存储地址为：

A[13][18] = A[10][10] + (18-10)*15 + (13-10)
          = 3000 + 120 + 3
          = 3123

其中，(18-10)*15表示列数之差乘以每列的元素个数，(13-10)表示行数之差。因为每个数组元素占4个存储单元，所以需要加上相应的偏移量。

相关问题

二维数组A[15][20]，已知A[10][10]的存储地址为3000，每个数组元素占有4个存储单元，若按照行主序存储则A[13][18]的地址为

按照行主序存储，数组A[13][18]的地址可以通过以下计算得出：

首先，A[10][10]的地址为3000，它在二维数组中的行下标为10，列下标为10。每个数组元素占有4个存储单元，因此A[10][10]的结束地址为3000 + 4 = 3004。

接下来，我们需要计算A[13][18]在内存中的地址。它在二维数组中的行下标为13，列下标为18。根据行主序存储的规则，每一行的元素都是连续存储的，所以A[13][18]的地址应该比A[10][10]的地址大。

首先计算A[10][0]的地址，它的行下标为10，列下标为0。根据行主序存储的规则，它的地址应该比A[10][10]的地址小，因此可以通过以下公式计算出A[10][0]的地址：

A[10][0]的地址 = 3000 - 10 * 20 * 4 = 2200

接下来计算A[13][0]的地址，它的行下标为13，列下标为0。根据行主序存储的规则，它的地址应该比A[10][0]的地址大，因此可以通过以下公式计算出A[13][0]的地址：

A[13][0]的地址 = 2200 + 13 * 20 * 4 = 3880

最后，计算A[13][18]的地址，它的行下标为13，列下标为18。根据行主序存储的规则，它的地址应该比A[13][0]的地址大，因此可以通过以下公式计算出A[13][18]的地址：

A[13][18]的地址 = 3880 + 18 * 4 = 3952

因此，按照行主序存储，二维数组A[13][18]的地址为3952。

已知一个二维数组，如何去重

你可以使用哈希表来去重二维数组。具体步骤如下：

1. 创建一个空的哈希表。
2. 遍历二维数组中的每个元素。
3. 对于每个元素，检查它是否在哈希表中存在。
4. 如果元素不存在于哈希表中，则将其添加到哈希表中，并标记为已存在。
5. 如果元素已经存在于哈希表中，则忽略它，继续遍历下一个元素。
6. 完成遍历后，哈希表中存储的就是去重后的二维数组。

以下是一个示例代码，演示如何使用哈希表去重二维数组（假设二维数组为matrix）：

def remove_duplicates(matrix):
    seen = set()
    result = []
    for row in matrix:
        new_row = []
        for element in row:
            if element not in seen:
                new_row.append(element)
                seen.add(element)
        result.append(new_row)
    return result

# 示例用法
matrix = [[1, 2, 3], [4, 2, 6], [1, 2, 3]]
unique_matrix = remove_duplicates(matrix)
print(unique_matrix)

该代码将输出`[[1, 2, 3], [4, 6]]`，即去重后的二维数组。