C语言算法和数据存储

Posted 2021-12-03 jienow

求最大公约数

第一种暴力解题

int main()
{
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int max = a > b? a : b;//三目操作符使用方法
  while (1)
  {
    if (max % a == 0 && max % b == 0)
    {
      printf("%d\\n", max);
      break;
    }
    max++;
  }
  return 0;
}

第二种算法解题（简化）

int main()
{
  /*int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int i = 0;*/
  for (i = 1;;i++)
  {
    if (a * i % b == 0)//a和b最小的公约数必定是a的倍数，所以用a的背书来除b取余就可以
    {
      printf("%d\\n", a * i);
      break;
    }
  }
  return 0;
}

第三种用辗转相除法求解

原理：最大公倍数一定等于两个数相乘除以最小公约数

(a*k)*(b*k)/k=a*b*k

int main()
{
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int i = 0;
  int c = 0;
  int max = a > b ? a : b;
  int min = a < b ? a : b;
  while(1)
  {
    c = max % min;
    if (0 == c)
      break;
    max = min;
    min = c;
    
  }
  printf("%d\\n", a * b / min);
  return 0;
}

输入字符串并且将他不完全倒置

I love beijing ->beijing love I

原理:将他全部倒置，再将每个空格相隔的字符串在进行倒置

int main()
{
  char arr[100] = { 0 };
  gets(arr);
  int len = strlen(arr);
  //接受大字符串
  
  
  reverse(arr,arr+len-1);
  //倒置字符串

  //倒置单个字符串
  char* start = arr;
  while (*start)
  {
    char* end = start;
    //判定结束的指针
    while (*end != \\0&&*end!= )//这里应该用循环，直到end指向空格才罢休
    {
      end++;
    }
    //倒置单个字符串
    reverse(start, end - 1);

    //跳到下一个字符串
    if (*end ==  )
      start = end + 1;
    else if (*end == \\0)//这里判不判断无所谓，在大的字符串中里面只有 和字符没有0
      break;
  }
  //打印字符串
  printf("%s\\n", arr);
  return 0;
}

普通数据存储

int main()

{

int a = -1;

//负数在内存中存贮方是有三种

//1、原码10000000 00000000 00000000 00000001

//2、反码11111111 11111111 11111111 11111110

//3、补码11111111 11111111 11111111 11111111

//由于在CPU种不存在减法器，所以1-1被分解成1+(-1)

//所以用负数的反码与正数相加11111111 11111111 11111111 11111111

// 00000000 00000000 00000000 00000001

// 00000000 00000000 00000000 00000000//正好是结果

int b = -10;//在内存中的存储方式是f6 ff ff ff是倒着存储的因为采用小端存储的方式

//大端存储：把高位字节序得地址放在高地址处

//小端存储：把低位字节序得地址放在低地址处

//char类型在内存中是ASCII码值进行存储的，它本身是整数，所以归类到整型类型里面

//整型类型;char short int long可以有无符号和有符号两种

//结构体类型：结构体 struct 枚举enum 联合体union struct (数组也符合自定义结构体类型)

//指针也可以标明是void类型

return 0;

}

用函数来实现判定内存中的存储结构

int check()
{
  int i = 1;
  char* p = (char*)&i;
  /*if (*p == 1)
    return 1;
  else if (*p == 0)
    return 0;*/
  return *p;
}
int main()
{
  int ret = check();
  if (ret == 1)
  {
    printf("小端\\n");
  }
  else if (ret == 0)
    printf("大端\\n");
  return 0;
}

C语言里面并没有规定char的类型：unsigned 和signed，根据编译器的不同

但是int 等是有规定的是signed是

char和int无符号类型的使用

1、介绍

int main()
{
  char a = -1;
  //-1原码10000000 00000000 00000000 00000001
  //  反码11111111 11111111 11111111 11111110
  //  补码11111111 11111111 11111111 11111111
  //char截断11111111
  //打印的是原码,这里的编译器是signed
  //11111111 11111111 11111111 11111111
  //变成原码10000000 00000000 00000000 00000001所以是-1
  signed char b = -1;
  //同上
  unsigned char c = -1;
  //-1原码10000000 00000000 00000000 00000001
  //  反码11111111 11111111 11111111 11111110
  //  补码11111111 11111111 11111111 11111111
  //char截断11111111，无符号前面补0
  //00000000 00000000 00000000 11111111
  //原码打印,由于是正数，补码就是原码，直接打印
  printf("%d %d %d", a, b, c);
  return 0;
}

题目理解

int main()
{
  char a = -128;
  //10000000 00000000 00000000 10000000
  //11111111 11111111 11111111 01111111
  //11111111 11111111 11111111 10000000打印
  printf("%u", a);
  return 0;
}

int main()
{
  char a = 128;//二进制10000000截断和-128一样，字符类型的内没有128，
  printf("%u", a);
  return 0;
}

int main()
{
  char i = -20;
  unsigned char j = 10;
  printf("%u\\n", i + j);//在这里int类型会整型提升为unsigned在高位的符号位会直接转换成数字
  printf("%d\\n", i + j);//这里的最高位是符号位，不会加上去
  return 0;
}

#include<string.h>
int main()
{
  char a[1000];
  int i = 0;
  for (i = 0; i < 1000;i++)
  {
    a[i] = -1 - i;
    //这里a是char类型只能存放八位，所以从-1减到-128减到127减到0，在回到-1如此往复,最终填满
  }
  printf("%d\\n", strlen(a));//在这里如果到0就会判定字符串结束
  return 0;
}

float类型的存贮方式

理解浮点数在内存中的存储方式

float在内存中存储方式是32位，double在内存中的存贮方式是64位

0  0000000 000000000000000000000000（与下面一一对应）

S    E              M

（(-1)^s）*M*2^E

s是正负号，E是二进制指数，M是真正数字

这里的小数先转换成二进制小数0.5=0.1

9.0=1001=1.001*（2^3）,这里的指数2代表的是小数点向左移动的位数

注：

1、这里的E在存储的时候需要加上127，因为如果0到-1的话需要从前面拿一个1过来，容易影响前面符号位的值

在读取的时候再减去127

2、M的大小在1到2之间，M的值是永远不会变的，所以在储存M的时候把1减去，这样就能存除24位空间

在读取的时候再把1加上

3、当E-127的时候如果最后的值是-127的话，即E等于0

那么M最开始的1就不会再加上了，因为这里已经趋向于0了，并且很有可能是错误的，所以直接把1删掉

在计算E-127的时候，此时的E是从M那里来的1，结果就是-126

4、E等于255，同理如果E-127的时候值是128的话，就是趋向于无穷

题目讲解

int main()
{
  int n = 9;
  float* nFloat = (float*)&n; 
  //这里的n的地址是一个整数类型的需要转换乘float类型才能被float类型的指针指向
  printf("%d\\n", n);//意思是把整形用整形进行读取
  
  //00000000 00000000 00000000 00001001
  printf("%f\\n", *nFloat);//意思是把整形用float类型进行读取
  //00000000 00000000 00000000 00001001用float进行读取时E是0，0.00000000 00001001*2^-126直接等于0

  *nFloat = 9.0;
  printf("%d\\n", n);//意思是把float类型用整形进行读取
  //9=1001=1.001*2^3//3+127=130
  //0 10000000 00100000000000000000因为是一个正数，所以在读取的时候直接打印
  printf("%f\\n", *nFloat);//意思是把float类型用float类型进行读取
  //9=1001=1.001*2^3=9.0000000
  //3+127=130
  return 0;
}