已知数组int a[10]={12,3,5,2,80,56,39,47,11,67}，输出数组中所有偶数。

以下是输出数组中所有偶数的C++代码实现：

#include <iostream>
using namespace std;

int main()
{
    int a[10] = {12, 3, 5, 2, 80, 56, 39, 47, 11, 67};

    for (int i = 0; i < 10; i++)
    {
        if (a[i] % 2 == 0) // 判断是否为偶数
        {
            cout << a[i] << " "; // 输出偶数
        }
    }

    return 0;
}

输出结果：

12 2 80 56

相关问题

已知数组A[10] = {10, 2,5,7,11,56,78,1,8,12}请分别使用以下排序方法实现对数组的升序排序 • 冒泡排序 • 堆排序 • 插入排序 • 归并排序 • 选择排序 • 桶排序 java

在Java中，我们可以分别用不同的排序算法来对给定的整数数组`A[10] = {10, 2, 5, 7, 11, 56, 78, 1, 8, 12}`进行升序排序：

1. **冒泡排序**:

void bubbleSort(int[] A) {
   int n = A.length;
   for (int i = 0; i < n - 1; i++) {
       for (int j = 0; j < n - 1 - i; j++) {
           if (A[j] > A[j + 1]) {
               int temp = A[j];
               A[j] = A[j + 1];
               A[j + 1] = temp;
           }
       }
   }
}

2. **堆排序**:

void heapSort(int[] A) {
   // 将数组构建成最大堆
   buildMaxHeap(A);
   for (int i = A.length - 1; i >= 1; i--) {
       // 将最大值放到末尾，然后调整剩余部分成新的最大堆
       swap(A, 0, i);
       siftDown(A, 0, i - 1);
   }
}

3. **插入排序**:

void insertionSort(int[] A) {
   for (int i = 1; i < A.length; i++) {
       int key = A[i];
       int j = i - 1;
       while (j >= 0 && A[j] > key) {
           A[j + 1] = A[j];
           j--;
       }
       A[j + 1] = key;
   }
}

4. **归并排序**:

void mergeSort(int[] A, int left, int right) {
   if (left < right) {
       int mid = (left + right) / 2;
       mergeSort(A, left, mid);
       mergeSort(A, mid + 1, right);
       merge(A, left, mid, right);
   }
}
// 合并方法...

5. **选择排序**:

void selectionSort(int[] A) {
   for (int i = 0; i < A.length - 1; i++) {
       int minIndex = i;
       for (int j = i + 1; j < A.length; j++) {
           if (A[j] < A[minIndex]) {
               minIndex = j;
           }
       }
       swap(A, i, minIndex);
   }
}

6. **桶排序** (适用于特定数据范围，这里简化了示例):

void bucketSort(int[] A, int maxVal) {
   int[] buckets = new int[maxVal + 1];
   for (int num : A) {
       buckets[num]++;
   }

   int index = 0;
   for (int i = 0; i < buckets.length; i++) {
       while (buckets[i] > 0) {
           A[index++] = i;
           buckets[i]--;
       }
   }
}

记得在实际应用中根据需求选择合适的排序算法，因为它们的时间复杂度各不相同。对于小规模数据，简单的插入排序可能足够；大规模数据时，通常会选择快速排序、归并排序或堆排序。

二分查找，必须有序 已知一有序数组 a[] = {50, 51, 52, 53, 54, 55, 56, 57, 58, 59}，输入一个数n，如果数组中有，则输出是第几个，如果没有则输出0 样例：输入：54 输出： 5 输入：59 输出：10 输入60： 输出：0

好的，这道题目可以使用二分查找算法来解决。以下是Python实现的代码：

def binary_search(arr, n):
    """
    在有序数组 arr 中查找元素 n，返回其下标。若不存在，则返回 -1。
    """
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == n:
            return mid
        elif arr[mid] < n:
            left = mid + 1
        else:
            right = mid - 1
    return -1


a = [50, 51, 52, 53, 54, 55, 56, 57, 58, 59]
n = int(input("请输入要查找的数："))
pos = binary_search(a, n)
if pos == -1:
    print("0")
else:
    print(pos+1)

运行结果如下：

请输入要查找的数：54
5

请输入要查找的数：59
10

请输入要查找的数：60
0