纳新题及详解

一、纳新题

13.用代码实现杨辉三角

二、题目详解

1.不同操作系统下的差异

32位下输出结果为：3，2，指针ptr指向第三个整形指针的地址，再减一后指向第二个数组元素。
64位下输出结果为：3，0，因为对数组取地址指向的是整个数组，因此进行&a+2实际上是指向下一个与原数组所占元素字节相同的一个存储空间，出现了越界，因此结果不确定。

2.ASCII码计算

c1=‘A’+‘5’-‘3’=‘A’+‘2’=‘C’=67
c2=‘A’+‘6’-‘3’=‘A’+‘3’=‘D’

3.++a与a++

操作符一般按照从左往右进行运算，因此++a是将a加一后赋值，a++是将a复制后再对a加一，本题中b=10后a+1=11, c=a+1=12后a+1=12, d=10* a=10*12=120, a=a+1=13.

4.结构体所占空间大小

对于n1，c先占第0，1位空间，接下来a数组占第2-11位空间，int占4字节，因此需要从4的倍数处开始占用，即12，因此b占第12-15位空间，因此n1占了0-15共16位空间。
对于n2,c占0，1位，b从4占到7位，a数组从第10位开始到19位，共占20位空间
使空间浪费最小的办法：把占用空间小的变量放在一起。
strcpy函数实现字符串复制操作，将"abcdefghij"直接赋值给n1.a的数组。
memcpy函数可以将字符串从开始到第index位赋值给指定数组，此题将整个字符串均进行赋值。

5.const用法

int *const p:此处const修饰指针p,p的指向不可以再改变。
const int q:此处const封锁了q,*q是一个常量不可更改，但是变量b不受影响，改变q的指向也不受影响。
代码只需要将两个const修饰去掉即可正常运行。

6.sizeof计算

str[]:其中包含5个字符，但是sizeof计算需要以’\0’为结束标志，因此大小为6.
p:p为64位下的指针，大小为8.
n:n为64位下的整数类型，大小为4.
q:q也为64位下的指针，虽然后面动态分配了100的大小，但未使用。

7.宏定义

宏定义下按照从左到右运算，不考虑括号，因此使用时要极其小心。
r = 2 +1 =3
area = 3* 2+1*2+1 = 6+2+1 = 9

8.实现字符串函数

1.strlen():求字符串长度，直到遇见第一个‘\0’结束，不计算’\0’的大小
代码实现：

size_t my_strlen(const char*string)
{
	assert(string != NULL);//断言，对参数进行有效性检查
	int count = 0;
	while (*string != '\0')
	{
		count++;
		string++;
	}
	return count;
}

2.strcmp():比较两个字符串的大小，相同返回0，s1>s2返回一个大于零的数，s1<s2返回一个小于零的数。
代码实现：

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

3：strcat():在一个字符串后面追加上一个字符串
代码实现：

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest)
		dest++;
	while (*dest++ = *src++)
		;
	return ret;
}

９.交换变量

1.引入第三变量

       int a = 10;
       int b = 20;
       int temp;
       temp = a;
       a = b;
       b = temp;

2.不引入第三变量（记住原理即可）

        int a = 10;
        int b = 20;
        a = a + b;
        b = a - b;
        a = a - b;

3.进行异或操作
异或是对二进制数进行操作，相同为假，不同为真，对a,b进行三次异或即可交换

        int a = 10;
        int b = 20;
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;

4.巧妙运用优先级
'='的优先级高于加减，因此先将a赋值给b，b此时等于10，a+b = 30,减去10等于20，赋值给a便进行了交换。

        int a = 10;
        int b = 20;
        a = a + b - (b = a);

10．找最大值与次大值

#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n); // 输入数组大小n
    int A[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &A[i]); // 输入数组元素
    }
    int max1 = A[0], max2 = A[1]; // 初始化最大值和次大值
    if (max1 < max2) {
        int temp = max1;
        max1 = max2;
        max2 = temp;
    }
    for (int i = 2; i < n; i++) {
        if (A[i] > max1) {
            max2 = max1;
            max1 = A[i];
        } else if (A[i] > max2) {
            max2 = A[i];
        }
    }
    printf("最大值：%d\n次大值：%d\n", max1, max2); // 输出最大值和次大值
    return 0;
}

最坏情况下时间复杂度为O(n)，n为数组大小

11.排序算法

1.冒泡排序
时间复杂度：O(n^2)
空间复杂度：O(1),临时变量不会随算法进行变化，因此为O(1)。

void bubble_sort(int *array,int num)
{
        int i = 0;
        int j = 0;
        int temp;
        for(;j < num;++j)
        {
                for(i= num;i >j ;--i)
                {
                    if(array[i] < array[i-1])
                    {
                        temp =array[i];
                        array[i] = array[i-1];
                        array[i-1] = temp;
                    }
                }
        }
}

2.选择排序
时间复杂度：O(n^2)
空间复杂度：O(1),临时变量不会随算法进行变化，因此为O(1)。

void selectSort(int arr[], int size)
{
	for (int i = 0; i < size; ++i) { // 外层循环遍历 [0, size-1]
		int min = INT_MAX; // 将 min 初始化为一个最大的值
		int min_idx = n; // 标记最小值的下标，用于交换，初始为arr元素个数
		int tmp;
		for (int j = i; j < n; ++j) { // 内层循环找到 arr[i, n-1] 中的最小值
			if (arr[j] < min) {
				min = arr[j];
				min_index = j;
			}
		}
		// 将找到的最小值与 arr[i] 交换
		tmp = arr[min_idx];
		arr[min_idx] = arr[i];
		arr[i] = tmp;
	}
}

3.插入排序
时间复杂度：O(n^2)
空间复杂度：O(1),临时变量不会随算法进行变化，因此为O(1)。

//升序
void InsertSort(int arr[],int len)
{
	for (int i = 1; i < len; ++i)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			int j = i - 1;
			for (; j >= 0 && temp < arr[j]; j --)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

4.快速排序
时间复杂度：
最好情况下（每次选择的基准元素都能将数组分成大小相等的两部分），快速排序的时间复杂度为O(nlogn)。
最坏情况下（每次选择的基准元素都是当前最小或最大的元素），快速排序的时间复杂度为O(n^2)。
平均情况下，快速排序的时间复杂度为O(nlogn)。

空间复杂度：
快速排序的空间复杂度主要取决于递归调用的栈空间。在最坏情况下，递归调用栈的深度可以达到O(n)，所以最坏情况下的空间复杂度为O(n)。
在其他情况下，快速排序的平均空间复杂度为O(logn)。

void quickSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }

    int pivot = arr[left]; // 选择基准元素（这里选择左边第一个元素）
    int i = left, j = right; // 设置两个指针i、j，分别从左右两边扫描

    while (i < j) {
        // 从右往左扫描，找到一个小于等于基准元素的元素
        while (arr[j] > pivot && i < j) {
            j--;
        }
        // 从左往右扫描，找到一个大于基准元素的元素
        while (arr[i] <= pivot && i < j) {
            i++;
        }
        // 交换两个元素的位置
        if (i < j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // 将基准元素放置到正确的位置（分割点）
    arr[left] = arr[i];
    arr[i] = pivot;

    // 递归处理左右两部分
    quickSort(arr, left, i-1);
    quickSort(arr, i+1, right);
}

12.素数

#include <stdio.h>

int is_prime(int number) {
    if (number <= 1) {
        return 0;
    }
    for (int i = 2; i * i <= number; i++) {
        if (number % i == 0) {
            return 0;
        }
    }
    return 1;
}

int main() {
    int count = 0; // 记录素数个数
    for (int i = 0; i <= 200; i++) {
        if (is_prime(i)) {
            count++;
            printf("%d ", i);
        }
    }
    printf("\n共有%d个素数\n", count);
    return 0;
}

13.杨辉三角

/*等腰的杨辉三角*/
#include<stdio.h>
main(){
	int n;
	printf("请输入打印的行数：");
	scanf("%d",&n);
	printf("%d行打印的杨辉三角如下：\n",n);
	int a[n][n];
	int i,j,k;
	for(i=0;i<n;i++){
		for(k=0;k<n-i;k++){
			printf("   ");
		}
		for(j=0;j<=i;j++){
			if(j==0||j==i){
				a[i][j]=1;
			}else{
				a[i][j]=a[i-1][j]+a[i-1][j-1];
			}
			printf("%6d",a[i][j]);
		}
		printf("\n");
	}
}