求解这两个问题，特别是第一个不知道如何去设计编程

img

img


求解这两个问题，特别是第一个不知道如何去设计编程，谢谢啦，谢谢提供一些解题思路

第二题：
二分查找（Binary Search）是一种常见的查找算法，它的思路如下：

  1. 首先指定查找范围，例如一个排好序的数组。

  2. 确定最小值和最大值的位置。

  3. 取数组的中间的值，如果该值等于待查找的值，则查找成功；如果该值大于待查找的值，则将查找范围缩小到左半部分数组中，即将最大值更新为中间值减一；如果该值小于待查找的值，则将查找范围缩小到右半部分数组中，即将最小值更新为中间值加一。

  4. 重复第三步，直到查找成功或者查找范围被缩小为零。

二分查找的时间复杂度为 O(log n)，它比普通的线性查找更加高效。

  • 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7761761
  • 这篇博客也不错, 你可以看下从键盘输入一个字符，判断其是字母字符，还是数字字符，还是其他字符
  • 除此之外, 这篇博客: 数码管的段选和位选是什么中的 初选单片机的时候，数码管是一个绕不过去的弯，对于初学者来说，数码管的段选和位选总是一脸懵。那么数码管的段选和位选是什么呢？ 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

  • 位选，选位置。我要选择哪一位数码管亮。

    段选，选一段。我要选择哪一段LED亮.

     

     

  • 您还可以看一下 陈华祥老师的项目管理从入门到精通：实践经验分享，实用套路讲解，项目规律实训课程中的 课程介绍小节, 巩固相关知识点
  • 以下回答由chatgpt基于相关博客总结生成:

    问题一：

    对于折半查找这个问题，只需要在while循环中对x与v[mid]的大小进行比较，将比较的结果存储在一个标志变量中，然后在循环外根据标志变量的值来判断x是否找到即可。

    代码如下：

    int binsearch(int x, int v[], int n){
    int low, high, mid;
    low=0;
    high=n-1;
    mid=(low+high)/2;
    int flag = 0;   // 标志变量
    while(low<=high){
        if(x == v[mid]){
            flag = 1;
            break;
        }
        else if(x < v[mid])
            high = mid - 1;
        else
            low = mid + 1;
        mid = (low + high)/2;
    }
    if(flag)
        return mid;
    else
        return -1;
}

    问题二：

    对于字符串中字母、数字、空格和其他字符的个数的统计，可以使用一个计数数组count[4]，分别记录字母、数字、空格和其他字符的个数，遍历字符串中的每个字符，根据其ASCII码值的范围判断其属于哪一类，将对应的计数器count[i]加一即可。最后输出count数组中各个计数器的值即可。

    代码如下：

    #include<stdio.h>
void TongJi(char s[])
{
    int count[4] = {0}; //计数数组，分别记录字母、数字、空格和其他字符的个数
    int i;
    for (i = 0; s[i] != '\0'; i++)
    {
        if (s[i] == ' ')
            count[2]++;
        else if ((s[i] >= '0') && (s[i] <= '9'))
            count[1]++;
        else if (((s[i] >= 'a') && (s[i] <= 'z')) || ((s[i] >= 'A') && (s[i] <= 'Z')))
            count[0]++;
        else
            count[3]++;
    }
    printf("空格：%d；数字：%d；字母：%d；其他：%d。\n", count[2], count[1], count[0], count[3]);
}

int main()
{
    char s[100];
    printf("请输入字符串：");
    gets_s(s);
    TongJi(s);
    return 0;
}

    注：gets_s函数是Visual Studio 和Visual C++6.0以上版本标准的安全函数，可以防止输入字符串过长导致的缓冲区溢出等问题。

    如果使用gets函数，代码如下：

    #include<stdio.h>
void TongJi(char s[])
{
    int count[4]={0}; //计数数组，分别记录字母、数字、空格和其他字符的个数
    int i;
    for (i=0;s[i]!='\n';i++)
    {
        if(s[i]==' ')
            count[2]++;
        else if((s[i]>='0')&&(s[i]<='9'))
            count[1]++;
        else if(((s[i]>='a')&&(s[i]<='z'))||((s[i]>='A')&&(s[i]<='Z')))
            count[0]++;
        else
            count[3]++;
    }
    printf("空格：%d；数字：%d；字母：%d；其他：%d。\n", count[2], count[1], count[0], count[3]);
}

int main()
{
    char s[100];
    printf("请输入字符串：");
    gets(s);
    TongJi(s);
    return 0;
}

    段落2：

    对于堆排序这个问题，可以先将数组构建成一个最大堆，然后每次将堆顶元素与最后一个元素交换，将堆的大小减1，再进行自顶向下的自我调整，使其重新成为一个最大堆。重复以上操作，直到堆的大小为1，最终得到的数组即为有序数组。

    代码如下：

    // 堆排序
// 将数组构建成一个最大堆
void heapify(int a[], int i, int n) {
    int left = 2 * i + 1;       // 左子节点
    int right = 2 * i + 2;      // 右子节点
    int largest=i;              // 最大值

    // 找出左右子节点以及根节点之间的最大值
    if (left<n&&a[left]>a[largest])
        largest=left;
    if (right<n&&a[right]>a[largest])
        largest=right;

    // 如果根节点不是最大值，则将其与最大值进行交换，并递归进行调整
    if (largest!=i){
        int tmp=a[i];
        a[i]=a[largest];
        a[largest]=tmp;
        heapify(a,largest,n);
    }
}
// 堆排序
void heapsort(int a[], int n)
{
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(a, i, n);

    for (int i = n - 1; i >= 1; i--)
    {
        int tmp = a[0];
        a[0] = a[i];
        a[i] = tmp;
        heapify(a, 0, i);
    }
}

    段落3:

    对于快速排序这个问题，可以先选择数组中的一个元素作为枢轴元素，然后遍历数组将小于等于枢轴元素的放在左侧，大于枢轴元素的放在右侧，即进行一次划分操作。然后对左右子数组递归地进行相同的划分操作。

    代码如下：

    // 快速排序
void quickSort(int a[], int left, int right)
{
    if (left >= right)  // 递归终止条件为子数组大小为1或0
        return;
    int i = left, j = right;
    int pivot = a[left];  // 将数组的第一个元素作为枢轴元素
    while (i < j)
    {
        // 从数组右侧开始，找到第一个小于枢轴元素的值
        while (i < j && a[j] >= pivot)
            j--;
        if (i < j)
            a[i++] = a[j];  // 将找到的小于枢轴元素的值赋值给左侧的i位置上，并将i指针右移一位

        // 从左侧开始，找到第一个大于枢轴元素的值
        while (i < j && a[i] <= pivot)
            i++;
        if (i < j)
            a[j--] = a[i];  // 将找到的大于枢轴元素的值赋值给右侧的j位置上，并将j指针左移一位
    }
    a[i] = pivot;  // 将枢轴元素放置在合适的位置上
    quickSort(a, left, i - 1);   // 对左侧子数组进行递归划分
    quickSort(a, i + 1, right);  // 对右侧子数组进行递归划分
}

    段落4：

    对于插入排序，可以将数组看成两个部分：有序部分和无序部分。初始时，有序部分只包含一个元素，即第一个元素。然后，将无序部分的第一个元素插入到有序部分的合适位置，使有序部分扩大1个元素，无序部分减少1个元素，再重复上述过程，直到无序部分为空，即完成排序。

    代码如下：

    ```C++ // 插入排序 void insertionSort(int a[], int n) { int i, j, key; for (i = 1; i < n; i++) { key = a[i]; j = i - 1; while (j >= 0 && a[j] > key) { a[j + 1] = a[j]; j--; } a[j + 1] = key; }

第一题：

#include <stdio.h>
int main()
{
    int  st_c[26] = {0}, i, imax;
    char str[1000001];
    gets(str);
    for (i = 0; str[i]; i++){
        if (str[i] >= 'a' && str[i] <= 'z')
            st_c[str[i] - 'a']++;
        else if (str[i] >= 'A' && str[i] <= 'Z')
            st_c[str[i] - 'A']++;
    }
    for (imax = i = 0; i < 26; i++)
        if (st_c[i] > st_c[imax]) imax = i;
    printf("%c %d", 'a' + imax, st_c[imax]);
    return 0;
}

第二题：（图片里看不清，这段代码位置是下标从0开始的）

#include <stdio.h>
int find_x(int *a, int n, int key)
{
    int mid, left = 0, right = n - 1;
    while (left <= right){
        mid = (left + right) / 2;
        if (a[mid] > key)
            right = mid - 1;
        else if (a[mid] < key)
            left = mid + 1;
        else
            return mid;
    }
    return -1;
}
int main()
{
    int a[15] = {1,4,6,9,13,16,19,28,40,100,123,222,236,679,899}, n;
    scanf("%d", &n);
    n = find_x(a,15,n);
    if (n == -1)
        printf("没有找到。");
    else
        printf("找到了，在第%d个。", n);
    return 0;
}