《程序设计入门——C语言》第七周 翁恺（2023.03.26）

 一、前言：

---

二、知识点：

1.数组运算

• 数组初始化（适合初始数据稀疏的数组，C99 only）:[n]在初始化数据中给出定位，其他位置补零。

int a[10] = { [0] = 2, [2] = 3,6, }; 

• 数组的大小：sizeof给出的是整个数组所占据的内容的大小，单位是字节；sizeof(a[0])给出的是数组中单个元素的大小，两者相除即可得到数组的单位个数。

sizeof(a) / sizeof(a[0]);

• 数组的赋值：数组变量本身不能被赋值；要把一个数组的所有元素交给另一个数组，必须采用遍历。

int a[] = {2, 4, 6, 7, 1, 3, 5, 9, 11, 13, 23, 14, 32};
//错误赋值方式
int b[] = a;
//正确赋值方式
for(i = 0;i<length;i++)
{
    b[i] = a[i];
}

• 遍历数组：通常使用for循环，循环变量i从0到<数组的长度。

常见错误：循环结束条件是<=数组长度；离开循环后，继续使用i的值来做数组元素的下标。

//例
for(i=0;i<length;i++)
{
    if(a[i]==key)
    {
        ret = i;
        break;
    }
}

• 例子：素数

->去掉偶数，从3到x-1，每次加2

->无需到x-1，到sqrt(x)就够了

->判断是否能被已知的且<x的素数整除

->已知范围，去除质数整数倍

//判断是否能被已知的且<x的素数整除
int isPrime(int x, int knownPrimes[], int numberOfPrimes)
{
    int ret = 1;
    int i;
    for(i = 0; i<numberOfPrimes;i++)
    {
        if(x % knownPrimes[i]==0)
        {
            ret = 0;
            break;
        }
    }
}

//已知范围，去除质数整数倍
#include<stdio.h>
int main()
{
    const int maxNumber = 25;
    int isPrime[maxNumber];
    int i, x;
    //初始化
    for(i=0;i<maxNumber;i++)
    {
        isPrime[i]=1;
    }
    //分析
    for(x=2;x<maxNumber;x++)
    {
        if(isPrime[x])
        {
            for(i=2;i*x<maxNumber;i++)
            {
                isPrime[i*x]=0;
            }
        }
    }
    //输出
    for(i=2;i<maxNumber;i++)
    {
        if(isPrime[i])
        {
            printf("%d\t",i);
        }
    }
    printf("\n");
    return 0;
}

2.搜索

• 搜索定义：在一个数组中找到某个数的位置（或确认是否存在）
• 搜索基本方法：遍历
• 线性搜索：

#include<stdio.h>

struct{int amount;char *name;}
coins[]={
    {1,"penny"},
    {5,"nickel"},
    {10,"dime"},
    {25,"quarter"},
    {50,"half-dollar"},
};
//线性搜索
int search(int key, int a[], int length)
{
    int ret = -1;
    int i;
    for(i=0; i<length; i++)
    {
        if(a[i]==key)
        {
            ret = i;
            break;
        }
    }
    return ret;
}
int main()
{
    int k = 10;
    for(int i =0;i<sizeof(coins)/sizeof(coins[0]);i++)
    {
        if(k == coins[i].amount)
        {
            printf("%s\n",coins[i].name);
            break;
        }
    }
}

• 二分搜索：效率更高

• N	log2^N
  10	3
  100	7
  1000	10
  1,000,000	20
  1,000,000,000	30

  //二分搜索
  int search(int k, int a[], int len)
  {
      int ret = -1;
      int left = 0;
      int right =len-1;
      while(right>left)
      {
          int mid = (left + right) / 2;
          if(a[mid] == k)
          {
              ret =mid;
              break;
          }
          else if(a[mid]>k)
          {
              right = mid - 1;
          }
          else
          {
              left = mid + 1;
          }
      }
  
      return ret;
  }

3.排序初步

选择排序：选出最大的，放在合适的位置上

#include<stdio.h>

int max(int a[],int len)
{
    int maxid = 0;
    for(int i=1;i<len;i++)
    {
        if(a[i] > a[maxid])
        {
            maxid = i;
        }
    }
    return maxid;
}
int main()
{
    int a[]={2, 45, 6, 12, 87, 34, 90, 24, 23, 11, 65};
    int len =sizeof(a)/sizeof(a[0]);

    //选择排序
    for(int i = len-1;i>0;i--)
    {
        int maxid = max(a,i+1);
        int t =a[maxid];
        a[maxid]=a[i];
        a[i]=t;
    }
    //遍历输出
    for(int i =0;i<len;i++)
    {
        printf("%d ",a[i]);
    }

    return 0;
}

---

三、注意事项：

• 数组作为函数参数时，往往必须再用另一个参数来传入数组的大小。

数组作为函数的参数时：

        不能在[]中给出数组的大小

        不能再利用sizeof来计算数组的元素个数

int search(int key, int a[], int length)
{
    int ret = -1;
    int i;
    for(i=0; i<length; i++)
    {
        if(a[i]==key)
        {
            ret = i;
            break;
        }
    }
}