w16 <<
Previous Next >> c_ex
ANSIC
檢查給定的數字是否為醜數
# include <stdio.h>
# include <string.h>
int main()
{
int n,x=0;
printf("\n\n Check whether a given number is an ugly number:\n");
printf("----------------------------------------------------\n");
printf("Input an integer number: ");
scanf("%d",&n);
if (n <= 0) {
printf("Input a correct number.");
}
while (n != 1)
{
if (n % 5 == 0)
{
n /= 5;
}
else if (n % 3 == 0)
{
n /= 3;
}
else if (n % 2 == 0)
{
n /= 2;
}
else
{
printf("It is not an ugly number.\n");
x = 1;
break;
}
}
if (x==0)
{
printf("It is an ugly number.\n");
}
}
列印您的姓名、出生日期和手機號碼
#include <stdio.h>
int main()
{
// 列印姓名
printf("Name : Alexandra Abramov\n");
// 列印出生日期
printf("DOB : July 14, 1975\n");
// 列印手機號碼
printf("Mobile : 99-9999999999\n");
// 表示執行成功
return(0);
}
反轉給定整數的數字
#include <stdio.h>
int reverse(int n) {
int d, y = 0;
while (n) {
d = n % 10;
if ((n > 0 && y > (0x7fffffff - d) / 10) ||
(n < 0 && y < ((signed)0x80000000 - d) / 10)) {
return 0;
}
y = y * 10 + d;
n = n / 10;
}
return y;
}
int main(void)
{
int i = 123;
printf("Original integer: %d ",i);
printf("\nReverse integer: %d ",reverse(i));
i = 208478933;
printf("\nOriginal integer: %d ",i);
printf("\nReverse integer: %d ",reverse(i));
i = -73634;
printf("\nOriginal integer: %d ",i);
printf("\nReverse integer: %d ",reverse(i));
return 0;
}
將字串轉換為無符號長整型
#include<stdio.h>
#include<stdlib.h>
int main ()
{
char buffer[123]; //定義一個字元數組“buffer”來儲存使用者輸入
unsigned long ul; // 定義一個unsigned long變數'ul'來儲存轉換後的值
// 列印一則訊息，要求使用者輸入
printf ("\nInput an unsigned number: ");
// 從標準輸入讀取使用者輸入並將其儲存在“緩衝區”中
fgets (buffer,123,stdin);
// 使用基數 0 將「buffer」中的字串轉換為無符號長整數（自動偵測）
ul = strtoul (buffer,NULL,0);
// 列印轉換後的值
printf ("Output: %lu\n\n",ul);
return 0; // 表明程式執行成功
}
將字串轉換為雙精度
#include<stdio.h> // 包括標準輸入/輸出頭檔。
#include<stdlib.h> // 包含標準庫頭檔。
int main () // 主函數開始。
{
char input[] = "8.0 2.0"; // 聲明一個字元數組“input”並用“8.0 2.0”對其進行初始化。
char * ptr_end; //聲明一個指向字元“ptr_end”的指標。
double x, y; // 聲明兩個雙精確度變數“x”和“y”。
x = strtod (input,&ptr_end); //將“input”的第一部分轉換為雙精度型，儲存在“x”中，並更新“ptr_end”。
y = strtod (ptr_end,NULL); // 將“input”的剩餘部分轉換為雙精度型，儲存在“y”中。
printf ("\nOutput= %.2lf\n\n", x/y); // 印出 x/y 的結果，保留兩位小數。
return 0; // 返回0表示程式執行成功。
} // 主函數結束。
產生一個隨機數
#include<stdio.h> // 包括標準輸入/輸出頭檔。
#include<stdlib.h> // 包含標準庫頭檔。
#include<time.h> // 包含用於產生隨機數的時間頭檔。
int main () // 主函數開始。
{
int number, input; // 宣告兩個整數變數「number」和「input」。
srand ( time(NULL) ); // 使用當前時間初始化隨機種子。
number = rand() % 10 + 1; // 產生 1 到 10 之間的隨機數並將其儲存在「number」中。
do { // do-while 循環的開始。
printf ("\nGuess the number (1 to 10): "); // 列印一則訊息，提示使用者猜測數字。
scanf ("%d",&input); // 讀取用戶的輸入並將其儲存在“input”中。
if (number > input) // 如果隨機數大於使用者輸入。
printf ("The number is higher\n"); // 列印一條訊息，表示該數字更大。
} while (number!=input); // 只要使用者的輸入不等於隨機數就繼續循環。
printf ("That is correct!\n\n"); // 列印一條訊息，表示用戶猜對了。
return 0; // 返回0表示程式執行成功。
} // 主函數結束。
簡單的函數結構
#include <stdio.h>
int sum (int, int);//函數聲明
int main (void)
{
int total;
printf("\n\n Function : a simple structure of function :\n");
printf("------------------------------------------------\n");
total = sum (5, 6);//函數呼叫
printf ("The total is : %d\n", total);
return 0;
}
int sum (int a, int b) //函數定義
{
int s;
s=a+b;
return s; //函數傳回一個值
}
顯示前 10 個自然數
#include <stdio.h> // 包括標準輸入/輸出頭檔。
int main() {
int i;
// 列印一條訊息，表示程式的意圖
printf("The first 10 natural numbers are:\n");
// 循環遍歷前 10 個自然數並列印每個自然數
for (i = 1; i <= 10; i++) {
printf("%d ", i);
}
// 返回0表示執行成功
return 0;
}
列印前 50 個自然數
#include<stdio.h>
int numPrint(int);
int main()
{
int n = 1;
printf("\n\n Recursion : print first 50 natural numbers :\n");
printf("-------------------------------------------------\n");
printf(" The natural numbers are :");
numPrint(n);
printf("\n\n");
return 0;
}
int numPrint(int n)
{
if(n<=50)
{
printf(" %d ",n);
numPrint(n+1);
}
}
檢查兩個整數是否相等
#include <stdio.h> // 包括標準輸入/輸出頭檔。
void main()
{
int int1, int2; // 宣告兩個整數變數“int1”和“int2”。
printf("Input the values for Number1 and Number2 : "); // 提示使用者輸入 Number1 和 Number2 的值。
scanf("%d %d", &int1, &int2); // 讀取使用者的輸入並將其儲存在“int1”和“int2”中。
if (int1 == int2) // 檢查 Number1 是否等於 Number2。
printf("Number1 and Number2 are equal\n"); // 如果 Number1 和 Number2 相等，則列印一則訊息。
else
printf("Number1 and Number2 are not equal\n"); //如果 Number1 和 Number2 不相等，則列印一則訊息。
}
刪除字串中的所有空格
#include <stdio.h>
#include <string.h>
#include <ctype.h>
// 移除字串中的空白字符，同時使用回調函數進行額外的修改
void remove_whitespace(char *str, void (*modify)(char *)) {
int i, j = 0;
for (i = 0; str[i] != '\0'; i++) {
if (!isspace(str[i])) {
str[j] = str[i];
j++;
} else {
modify(&str[i]);
}
}
str[j] = '\0';
}
// 將空白字符替換為 '\0' 的回調函數
void remove_space(char *ch) {
*ch = '\0';
}
int main() {
char str[100];
printf("輸入一個字串：");
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0'; // 移除換行符號
printf("原始字串：%s\n", str);
// 使用回調函數移除空白字符
remove_whitespace(str, remove_space);
printf("沒有空白字符的字串：%s\n", str);
return 0;
}
基本堆操作 - 插入、刪除、顯示
#include <stdio.h> // 包含 printf 函數的標準輸入/輸出庫
#include <stdlib.h> // 包含動態記憶體分配的標準庫
#define MAX_HEAP_SIZE 100 // 定義堆的最大大小
// 表示堆的結構
struct Heap {
int arr[MAX_HEAP_SIZE]; // 儲存堆元素的數組
int size; // 堆的當前大小
};
// 交換堆中兩個元素的函數
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 插入元素後維護最大堆屬性的函數
void heapifyUp(struct Heap *heap, int index) {
int parent = (index - 1) / 2; // 計算父索引
// 向上移動堆，直到恢復最大堆屬性
while (index > 0 && heap->arr[index] > heap->arr[parent]) {
swap(&heap->arr[index], &heap->arr[parent]); // 將目前節點與其父節點交換
index = parent;
parent = (index - 1) / 2; // 更新父索引
}
}
// 在堆中插入元素的函數
void insert(struct Heap *heap, int key) {
if (heap->size >= MAX_HEAP_SIZE) {
printf("Heap overflow\n"); // 如果堆已滿，則顯示錯誤訊息
return;
}
heap->arr[heap->size] = key; // 將鍵插入堆的末尾
heap->size++; // 增加堆的大小
heapifyUp(heap, heap->size - 1); // 恢復最大堆屬性
}
// 刪除元素後維護最大堆屬性的函數
void heapifyDown(struct Heap *heap, int index) {
int leftChild = 2 * index + 1; // 計算左子索引
int rightChild = 2 * index + 2; // 計算右子索引
int largest = index; // 假設當前節點是最大的
// 求當前節點、左子節點、右子節點中最大的元素
if (leftChild < heap->size && heap->arr[leftChild] > heap->arr[largest]) {
largest = leftChild;
}
if (rightChild < heap->size && heap->arr[rightChild] > heap->arr[largest]) {
largest = rightChild;
}
// 如果最大的元素不是當前節點，則與最大的子節點交換並繼續向下堆
if (largest != index) {
swap(&heap->arr[index], &heap->arr[largest]);
heapifyDown(heap, largest);
}
}
// 從堆中刪除根元素（最大元素）的函數
int deleteMax(struct Heap *heap) {
if (heap->size <= 0) {
printf("Heap underflow\n"); // 如果堆為空，則顯示錯誤訊息
return -1; // 返回-1表示錯誤或空堆
}
int maxElement = heap->arr[0]; // 儲存最大元素
heap->arr[0] = heap->arr[heap->size - 1]; // 將根替換為最後一個元素
heap->size--; // 減小堆的大小
heapifyDown(heap, 0); // 從根恢復最大堆屬性
return maxElement; // 傳回刪除的最大元素
}
// 顯示堆元素的函數
void display(struct Heap *heap) {
printf("Heap elements: ");
for (int i = 0; i < heap->size; i++) {
printf("%d ", heap->arr[i]); // 列印堆中的每個元素
}
printf("\n");
}
int main() {
struct Heap heap; // 聲明堆結構
heap.size = 0; // 初始化堆大小
// 測試插入操作
insert(&heap, 100);
insert(&heap, 200);
insert(&heap, 150);
insert(&heap, 400);
insert(&heap, 500);
// 顯示堆疊
display(&heap);
// 測試刪除操作
int maxElement = deleteMax(&heap);
if (maxElement != -1) {
printf("Deleted max element: %d\n", maxElement);
}
// 顯示更新後的堆
display(&heap);
return 0; // 返回0表示執行成功
}
從隨機數組和排序數組構造最大堆
#include <stdio.h> // 包含 printf 函數的標準輸入/輸出庫
#include <stdlib.h> // 包含動態記憶體分配的標準庫
#define MAX_HEAP_SIZE 100 // 定義堆的最大大小
// 交換堆中兩個元素的函數
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 插入元素後維護最大堆屬性的函數
void heapifyDown(int arr[], int size, int index) {
int leftChild = 2 * index + 1; // 計算左子索引
int rightChild = 2 * index + 2; // 計算右子索引
int largest = index; // 假設當前節點是最大的
// 求當前節點、左子節點、右子節點中最大的元素
if (leftChild < size && arr[leftChild] > arr[largest]) {
largest = leftChild;
}
if (rightChild < size && arr[rightChild] > arr[largest]) {
largest = rightChild;
}
// 如果最大的元素不是當前節點，則與最大的子節點交換並繼續向下堆
if (largest != index) {
swap(&arr[index], &arr[largest]);
heapifyDown(arr, size, largest);
}
}
// 從數組建立最大堆的函數
void buildMaxHeap(int arr[], int size) {
// 從最後一個非葉節點開始，向下堆化到根
for (int i = size / 2 - 1; i >= 0; i--) {
heapifyDown(arr, size, i);
}
}
// 顯示數組元素的函數
void display(int arr[], int size) {
printf("Array elements: ");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]); // 列印數組中的每個元素
}
printf("\n");
}
int main() {
// 使用隨機數組進行測試
int randomArray[] = {6, 8, 12, 7, 1}; // 聲明一個隨機數組
int randomSize = sizeof(randomArray) / sizeof(randomArray[0]); // 計算數組的大小
printf("Original Random Array:\n");
display(randomArray, randomSize); // 顯示原始隨機數組
// 從隨機數組建立最大堆
buildMaxHeap(randomArray, randomSize);
printf("Max Heap from Random Array:\n");
display(randomArray, randomSize); // 顯示隨機數組中的最大堆
// 使用排序數組進行測試
int sortedArray[] = {19, 12, 8, 6, 2}; // 聲明一個排序數組
int sortedSize = sizeof(sortedArray) / sizeof(sortedArray[0]); // 計算數組的大小
printf("\nOriginal Sorted Array:\n");
display(sortedArray, sortedSize); // 顯示原始排序數組
// 從排序數組建立最大堆
buildMaxHeap(sortedArray, sortedSize);
printf("Max Heap from Sorted Array:\n");
display(sortedArray, sortedSize); // 顯示排序數組中的最大堆
return 0; // 返回0表示執行成功
}
從隨機數組和排序數組構造最小堆
#include <stdio.h>
// 用於堆化以節點 i 為根的子樹的函數，該節點是 arr[] 中的索引
void minHeapify(int arr[], int n, int i) {
int smallest = i; // 將最小的初始化為 root
int left = 2 * i + 1; // 左子節點
int right = 2 * i + 2; // 右子節點
// 如果左子節點小於根
if (left < n && arr[left] < arr[smallest])
smallest = left;
// 如果右子節點小於目前為止最小的子節點
if (right < n && arr[right] < arr[smallest])
smallest = right;
// 如果最小的不是根
if (smallest != i) {
// 將找到的最小元素與根交換
int temp = arr[i];
arr[i] = arr[smallest];
arr[smallest] = temp;
// 遞歸地堆化受影響的子樹
minHeapify(arr, n, smallest);
}
}
// 從數組建立最小堆的函數
void buildMinHeap(int arr[], int n) {
// 從最後一個非葉子節點開始，以相反的順序堆疊所有節點
for (int i = n / 2 - 1; i >= 0; i--)
minHeapify(arr, n, i);
}
// 列印數組的函數
void printArray(int arr[], int n) {
for (int i = 0; i < n; ++i)
printf("%d ", arr[i]);
printf("\n");
}
// 測試堆構造函數
int main() {
// 使用隨機數組進行測試
int randomArray[] = {4, 10, 3, 5, 1};
int n1 = sizeof(randomArray) / sizeof(randomArray[0]);
printf("Original Random Array: ");
printArray(randomArray, n1);
// 建構堆
buildMinHeap(randomArray, n1);
printf("Min Heap from Random Array: ");
printArray(randomArray, n1);
printf("\n");
// 使用排序數組進行測試
int sortedArray[] = {8, 7, 5, 4, 2};
int n2 = sizeof(sortedArray) / sizeof(sortedArray[0]);
printf("Original Sorted Array: ");
printArray(sortedArray, n2);
// 建構堆
buildMinHeap(sortedArray, n2);
printf("Min Heap from Sorted Array: ");
printArray(sortedArray, n2);
return 0;
}
使用最大堆實現堆排序
#include <stdio.h>
// 用於堆化以節點 i 為根的子樹的函數，該子樹是 arr[] 中的索引
void maxHeapify(int arr[], int n, int i) {
int largest = i; // Initialize largest as root
int left = 2 * i + 1; // left child
int right = 2 * i + 2; // right child
// 如果左子節點大於根
if (left < n && arr[left] > arr[largest])
largest = left;
// 如果右子節點大於迄今為止最大的子節點
if (right < n && arr[right] > arr[largest])
largest = right;
// 如果最大的不是根
if (largest != i) {
// Swap the found largest element with the root
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
// 遞歸地堆化受影響的子樹
maxHeapify(arr, n, largest);
}
}
// 對數組執行堆排序的函數
void heapSort(int arr[], int n) {
// 建造最大堆
for (int i = n / 2 - 1; i >= 0; i--)
maxHeapify(arr, n, i);
// 從堆中一一提取元素
for (int i = n - 1; i > 0; i--) {
// 將根（最大元素）與最後一個元素交換
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 在減少的堆上呼叫 maxHeapify
maxHeapify(arr, i, 0);
}
}
// 列印數組的函數
void printArray(int arr[], int n) {
for (int i = 0; i < n; ++i)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
// 測試陣列
int array[] = {14, 10, 0, 9, 15, 5, 7};
int n = sizeof(array) / sizeof(array[0]);
printf("Original Array: ");
printArray(array, n);
// 執行堆疊排序
heapSort(array, n);
printf("Sorted Array: ");
printArray(array, n);
return 0;
}
實作並測試Heapify功能
#include <stdio.h>
// 用於堆化以節點 i 為根的子樹的函數，該節點是 arr[] 中的索引
void heapify(int arr[], int n, int i) {
int largest = i; // Initialize largest as root
int left = 2 * i + 1; // left child
int right = 2 * i + 2; // right child
// 如果左子節點大於根
if (left < n && arr[left] > arr[largest])
largest = left;
// 如果右子節點大於迄今為止最大的子節點
if (right < n && arr[right] > arr[largest])
largest = right;
// 如果最大的不是根 if (largest != i) {
// 將找到的最大元素與根交換
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
// 遞歸地堆化受影響的子樹
heapify(arr, n, largest);
}
}
// 列印數組的函數
void printArray(int arr[], int n) {
for (int i = 0; i < n; ++i)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
// 測試陣列
int array[] = {14, 10, 18, 7, 5};
int n = sizeof(array) / sizeof(array[0]);
printf("Original Array: ");
printArray(array, n);
// 使用堆中的不同位置測試 heapify 函數
for (int i = n / 2 - 1; i >= 0; i--) {
printf("Heapify at position %d: ", i);
heapify(array, n, i);
printArray(array, n);
}
return 0;
}
鏡像的二元樹鏡像
// 包括必要的頭文件
#include <stdio.h>
#include <stdlib.h>
// 二元樹節點的結構
struct TreeNode {
int data;
struct TreeNode* left;
struct TreeNode* right;
};
// 建立新節點的函數
struct TreeNode* createNode(int value) {
struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
if (newNode != NULL) {
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
}
return newNode;
}
// 向二元樹插入節點的函數
struct TreeNode* insertNode(struct TreeNode* root, int value) {
if (root == NULL) {
return createNode(value);
}
if (value < root->data) {
root->left = insertNode(root->left, value);
} else if (value > root->data) {
root->right = insertNode(root->right, value);
}
return root;
}
// 執行有序遍歷和列印元素的函數
void inOrderTraversal(struct TreeNode* root) {
if (root != NULL) {
inOrderTraversal(root->left);
printf("%d ", root->data);
inOrderTraversal(root->right);
}
}
// 建立二元樹鏡像的函數
struct TreeNode* mirrorTree(struct TreeNode* root) {
if (root == NULL) {
return NULL;
}
// 交換左右子樹
struct TreeNode* temp = root->left;
root->left = mirrorTree(root->right);
root->right = mirrorTree(temp);
return root;
}
// 釋放為二元樹分配的記憶體的函數
void freeTree(struct TreeNode* root) {
if (root != NULL) {
freeTree(root->left);
freeTree(root->right);
free(root);
}
}
int main() {
struct TreeNode* root = NULL;
int nodeValue;
char choice;
// 將節點插入二元樹
do {
printf("Input a value to insert into the binary tree (enter 0 to stop): ");
scanf("%d", &nodeValue);
if (nodeValue != 0) {
root = insertNode(root, nodeValue);
}
} while (nodeValue != 0);
//列印原始二元樹
printf("\nOriginal Binary Tree (In-order Traversal): ");
inOrderTraversal(root);
printf("\n");
// 建立並列印二元樹的鏡像
struct TreeNode* mirroredRoot = mirrorTree(root);
printf("\nMirrored Binary Tree (In-order Traversal): ");
inOrderTraversal(mirroredRoot);
printf("\n");
// 釋放分配的記憶體
freeTree(root);
freeTree(mirroredRoot);
return 0;
}
Postfix 表達式和求值的表達式樹
// 包括必要的頭文件
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
// 表達式樹中節點的結構
struct TreeNode {
char data;
struct TreeNode* left;
struct TreeNode* right;
};
// 建立新節點的函數
struct TreeNode* createNode(char value) {
struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
if (newNode != NULL) {
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
}
return newNode;
}
// 檢查字元是否為運算符的函數
int isOperator(char c) {
return (c == '+' || c == '-' || c == '*' || c == '/');
}
// 從後綴表達式建立表達式樹的函數
struct TreeNode* buildExpressionTree(char postfix[]) {
struct TreeNode* stack[100];
int top = -1;
for (int i = 0; postfix[i] != '\0'; i++) {
struct TreeNode* newNode = createNode(postfix[i]);
if (isdigit(postfix[i])) {
stack[++top] = newNode;
} else if (isOperator(postfix[i])) {
newNode->right = stack[top--];
newNode->left = stack[top--];
stack[++top] = newNode;
}
}
return stack[top];
}
// 計算表達式樹的函數
int evaluateExpressionTree(struct TreeNode* root) {
if (root->data == '+') {
return evaluateExpressionTree(root->left) + evaluateExpressionTree(root->right);
} else if (root->data == '-') {
return evaluateExpressionTree(root->left) - evaluateExpressionTree(root->right);
} else if (root->data == '*') {
return evaluateExpressionTree(root->left) * evaluateExpressionTree(root->right);
} else if (root->data == '/') {
return evaluateExpressionTree(root->left) / evaluateExpressionTree(root->right);
} else {
return root->data - '0'; // Convert character to integer
}
}
// 執行表達式樹中序遍歷的函數
void inOrderTraversal(struct TreeNode* root) {
if (root != NULL) {
inOrderTraversal(root->left);
printf("%c ", root->data);
inOrderTraversal(root->right);
}
}
// 釋放為表達式樹分配的記憶體的函數
void freeExpressionTree(struct TreeNode* root) {
if (root != NULL) {
freeExpressionTree(root->left);
freeExpressionTree(root->right);
free(root);
}
}
int main() {
char postfixExpression[100];
// 輸入後綴表達式
printf("Enter a postfix expression: ");
scanf("%s", postfixExpression);
// 建構表達式樹
struct TreeNode* root = buildExpressionTree(postfixExpression);
// 顯示表達式樹的中序遍歷
printf("In-order Traversal of the Expression Tree: ");
inOrderTraversal(root);
printf("\n");
// 評估並顯示結果
int result = evaluateExpressionTree(root);
printf("Result: %d\n", result);
// 釋放分配的記憶體
freeExpressionTree(root);
return 0;
}
找出兩個數字之間的最大數字
#include <stdio.h>
#include <stdlib.h>
int main() {
int fno, sno, *ptr1 = &fno, *ptr2 = &sno;
printf("\n\n Pointer : Find the maximum number between two numbers :\n");
printf("------------------------------------------------------------\n");
printf(" Input the first number : ");
scanf("%d", ptr1); // 讀取使用者的第一個數字並使用 ptr1 儲存它
printf(" Input the second number : ");
scanf("%d", ptr2); // 從用戶那裡讀取第二個數字並使用 ptr2 儲存它
// 比較ptr1和ptr2指向的值，找出最大數
if (*ptr1 > *ptr2) {
printf("\n\n %d is the maximum number.\n\n", *ptr1); // 列印最大數量
} else {
printf("\n\n %d is the maximum number.\n\n", *ptr2); //列印最大數量
}
return 0;
}
儲存和檢索數組中的元素
#include <stdio.h>
int main() {
int arr1[25], i, n;
printf("\n\n Pointer : Store and retrieve elements from an array :\n");
printf("------------------------------------------------------------\n");
printf(" Input the number of elements to store in the array :");
scanf("%d", &n); // 讀取要儲存在數組中的元素數量
printf(" Input %d number of elements in the array :\n", n);
for (i = 0; i < n; i++) {
printf(" element - %d : ", i);
scanf("%d", arr1 + i); // 使用指標算術讀取並儲存數組 arr1 中的“n”個元素
}
printf(" The elements you entered are : \n");
for (i = 0; i < n; i++) {
printf(" element - %d : %d \n", i, *(arr1 + i)); // 使用指標顯示儲存在陣列中的元素
}
return 0;
}
使用動態記憶體分配查找最大元素
#include <stdio.h>
#include <stdlib.h>
int main() {
int i, n;
float *element; // 指向float類型的指標來儲存元素
printf("\n\n Pointer : Find the largest element using Dynamic Memory Allocation :\n");
printf("-------------------------------------------------------------------------\n");
// 輸入元素總數
printf(" Input total number of elements (1 to 100): ");
scanf("%d", &n);
element = (float *)calloc(n, sizeof(float)); // 為“n”個元素分配內存
if (element == NULL) {
printf(" No memory is allocated."); // 如果記憶體分配失敗
exit(0);
}
printf("\n");
// 輸入“n”個數字並將它們動態儲存在分配的記憶體中
for (i = 0; i < n; ++i) {
printf(" Number %d: ", i + 1);
scanf("%f", element + i);
}
// 求'n'個元素中最大的元素
for (i = 1; i < n; ++i) {
if (*element < *(element + i)) {
*element = *(element + i); // 將最大元素儲存在第一個記憶體位置
}
}
printf(" The Largest element is : %.2f \n\n", *element); // 顯示找到的最大元素
return 0;
}
w16 <<
Previous Next >> c_ex