数组与矩阵操作实践
#include <stdio.h>
#define ARRAY_SIZE 4
#define ROWS 2
void test_array() {
int data[ARRAY_SIZE] = {1, 9, 8, 4};
int index;
printf("Array size: %d\n", sizeof(data));
for(index = 0; index < ARRAY_SIZE; ++index) {
printf("%p: %d\n", &data[index], data[index]);
}
printf("Array address: %p\n", data);
}
void test_matrix() {
int matrix[ROWS][ARRAY_SIZE] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
int row, col;
printf("Matrix size: %d\n", sizeof(matrix));
for(row = 0; row < ROWS; ++row) {
for(col = 0; col < ARRAY_SIZE; ++col) {
printf("%p: %d\n", &matrix[row][col], matrix[row][col]);
}
}
printf("Matrix address: %p\n", matrix);
printf("Row 0 address: %p\n", matrix[0]);
printf("Row 1 address: %p\n", matrix[1]);
}
int main() {
printf("Test 1: Integer array\n");
test_array();
printf("\nTest 2: Integer matrix\n");
test_matrix();
return 0;
}#include <stdio.h>
#define MAX_SIZE 100
void read_array(int arr[], int size);
double calculate_avg(int arr[], int size);
int main() {
int nums[MAX_SIZE];
int count;
double result;
while(printf("Enter count: "), scanf("%d", &count) != EOF) {
read_array(nums, count);
result = calculate_avg(nums, count);
printf("Result: %.2f\n\n", result);
}
return 0;
}
void read_array(int arr[], int size) {
for(int i = 0; i < size; ++i) {
scanf("%d", &arr[i]);
}
}
double calculate_avg(int arr[], int size) {
int max_val = arr[0];
int min_val = arr[0];
double total = 0.0;
for(int i = 0; i < size; ++i) {
total += arr[i];
if(arr[i] > max_val) {
max_val = arr[i];
} else if(arr[i] < min_val) {
min_val = arr[i];
}
}
return (total - max_val - min_val) / (size - 2);
}Array element addresses show contiguous memory allocation. Row addresses differ by column size in multi-dimensional arrays.
#include <stdio.h>
#define MAX_DIM 100
void display_matrix(int mat[][MAX_DIM], int dim);
void initialize_matrix(int mat[][MAX_DIM], int dim, int value);
int main() {
int matrix[MAX_DIM][MAX_DIM];
int size, val;
while(printf("Enter size and value: "), scanf("%d%d", &size, &val) != EOF) {
initialize_matrix(matrix, size, val);
display_matrix(matrix, size);
printf("\n");
}
return 0;
}
void display_matrix(int mat[][MAX_DIM], int dim) {
for(int r = 0; r < dim; ++r) {
for(int c = 0; c < dim; ++c) {
printf("%d ", mat[r][c]);
}
printf("\n");
}
}
void initialize_matrix(int mat[][MAX_DIM], int dim, int value) {
for(int i = 0; i < dim; ++i) {
for(int j = 0; j < dim; ++j) {
mat[i][j] = value;
}
}
}Array parameter passing demonstrates memory address relationships. Matrix operations confirm uniform element initialization.
#include <stdio.h>
#define MAX_SIZE 100
void read_values(int arr[], int size);
double find_median(int arr[], int size);
int main() {
int numbers[MAX_SIZE];
int count;
double median_val;
while(printf("Enter count: "), scanf("%d", &count) != EOF) {
read_values(numbers, count);
median_val = find_median(numbers, count);
printf("Median: %g\n\n", median_val);
}
return 0;
}
void read_values(int arr[], int size) {
for(int i = 0; i < size; ++i) {
scanf("%d", &arr[i]);
}
}
double find_median(int arr[], int size) {
for(int i = 0; i < size-1; ++i) {
for(int j = 0; j < size-1-i; ++j) {
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
if(size % 2 == 1) {
return arr[size/2];
} else {
return (arr[size/2 - 1] + arr[size/2]) / 2.0;
}
}#include <stdio.h>
#define MAX_DIM 100
void input_matrix(int mat[][MAX_DIM], int dim);
void output_matrix(int mat[][MAX_DIM], int dim);
void rotate_right(int mat[][MAX_DIM], int dim);
int main() {
int matrix[MAX_DIM][MAX_DIM];
int size;
printf("Enter size: ");
scanf("%d", &size);
input_matrix(matrix, size);
printf("Original matrix:\n");
output_matrix(matrix, size);
rotate_right(matrix, size);
printf("Rotated matrix:\n");
output_matrix(matrix, size);
return 0;
}
void input_matrix(int mat[][MAX_DIM], int dim) {
printf("Enter %dx%d matrix (row-wise):\n", dim, dim);
for(int r = 0; r < dim; ++r) {
for(int c = 0; c < dim; ++c) {
scanf("%d", &mat[r][c]);
}
}
}
void output_matrix(int mat[][MAX_DIM], int dim) {
for(int r = 0; r < dim; ++r) {
for(int c = 0; c < dim; ++c) {
printf("%d ", mat[r][c]);
}
printf("\n");
}
}
void rotate_right(int mat[][MAX_DIM], int dim) {
int temp_col[dim];
for(int i = 0; i < dim; ++i) {
temp_col[i] = mat[i][dim - 1];
}
for(int c = dim - 1; c > 0; --c) {
for(int r = 0; r < dim; ++r) {
mat[r][c] = mat[r][c - 1];
}
}
for(int i = 0; i < dim; ++i) {
mat[i][0] = temp_col[i];
}
}#define MAX_SIZE 100
void dec_to_base(int num, int base);
int main() {
int value;
while(printf("Enter decimal: "), scanf("%d", &value) != EOF) {
dec_to_base(value, 2);
dec_to_base(value, 8);
dec_to_base(value, 16);
printf("\n");
}
return 0;
}
void dec_to_base(int num, int base) {
int remainders[MAX_SIZE];
int index = 0;
int current = num;
if(current == 0) {
printf("0");
return;
}
while(current > 0) {
remainders[index] = current % base;
current = current / base;
index++;
}
for(int i = index - 1; i >= 0; i--) {
if(base == 16 && remainders[i] >= 10) {
printf("%c", 'A' + (remainders[i] - 10));
} else {
printf("%d", remainders[i]);
}
}
printf("\n");
}#include <stdio.h>
#define MAX_DIM 100
void read_grid(int grid[][MAX_DIM], int size);
void print_grid(int grid[][MAX_DIM], int size);
int check_magic(int grid[][MAX_DIM], int size);
int main() {
int matrix[MAX_DIM][MAX_DIM];
int size;
while(printf("Enter size: "), scanf("%d", &size) != EOF) {
printf("Enter square matrix:\n");
read_grid(matrix, size);
printf("Displayed matrix:\n");
print_grid(matrix, size);
if(check_magic(matrix, size))
printf("It's a magic square\n\n");
else
printf("Not a magic square\n\n");
}
return 0;
}
void read_grid(int grid[][MAX_DIM], int size) {
for(int r = 0; r < size; ++r) {
for(int c = 0; c < size; ++c) {
scanf("%d", &grid[r][c]);
}
}
}
void print_grid(int grid[][MAX_DIM], int size) {
for(int r = 0; r < size; ++r) {
for(int c = 0; c < size; ++c) {
printf("%4d", grid[r][c]);
}
printf("\n");
}
}
int check_magic(int grid[][MAX_DIM], int size) {
int magic_sum = size * (size * size + 1) / 2;
int row_sum, col_sum, diag_sum;
for(int r = 0; r < size; ++r) {
row_sum = 0;
for(int c = 0; c < size; ++c) {
row_sum += grid[r][c];
}
if(row_sum != magic_sum) return 0;
}
for(int c = 0; c < size; ++c) {
col_sum = 0;
for(int r = 0; r < size; ++r) {
col_sum += grid[r][c];
}
if(col_sum != magic_sum) return 0;
}
diag_sum = 0;
for(int i = 0; i < size; ++i) {
diag_sum += grid[i][i];
}
if(diag_sum != magic_sum) return 0;
diag_sum = 0;
for(int i = 0; i < size; ++i) {
diag_sum += grid[i][size - 1 - i];
}
if(diag_sum != magic_sum) return 0;
return 1;
}