数组基本概念
int main(int argc, const char * argv[]) {
/*
// 当需要保持很多"相同类型"的数据时就可以使用数组来保持
// 因为如果使用变量, 那么将变得非常复杂, 并且非常没有技术含量
int score = 99;
int score1 = 98;
...
int score998 = 88;
printf("%i\n", score);
*/
/*
数组的定义格式:
数据类型 变量名称;
数据类型 数组名称[数据的个数];
元素类型 数组名称[元素个数];
元素类型: 就是数组中需要存储的数据类型, 一旦指定, 数组中就只能存储该类型的数据
元素个数: 就是数组中能够存储的数据(元素)的个数
*/
int num;
num = 12;
printf("num = %i\n", num);
int scores[3]; // 定义了一个名称叫做scores的数组, 数组中可以存放3个int类型的数据
// scores = 12; // 系统搞不清楚应该赋值给谁
// 只要定义一个C语言的数组, 系统就自动会给数组中的每一块小得存储空间一个编号
// 这个编号从0开始, 一次递增
// 数组中系统自动绑定的编号, 我们称之为 索引
scores[0] = 12;
scores[1] = 66;
scores[2] = 59;
printf("scores[0] = %i\n", scores[0]);
return 0;
}
数组的初始化
int main(int argc, const char * argv[]) {
// 需求保持全班101个人的分数
// 元素类型 数组名称[元素个数];
/*
// 先定义再初始化
int scores[5];
scores[0] = 99;
scores[1] = 88;
scores[2] = 77;
scores[3] = 66;
scores[4] = 100;
*/
/*
int num;
num = 10;
int num1 = 10;
*/
// 依次将{}中的每一个值赋值给数组中的每一个元素
// 并且从0开始赋值
// 也称之为数组的初始化(完全初始化)
int scores[5] = {99,88,77,66,100};
// 部分初始化
// 默认从0开始初始化, 依次赋值
// 注意: 如果"在部分初始化中"对应的内存没有被初始化, 那么默认是0
int scores1[3] = {11, 22};
printf("0 = %i\n", scores1[0]);
printf("1 = %i\n", scores1[1]);
printf("2 = %i\n", scores1[2]);
printf("-------\n");
// 注意: 如果没有对数组进行初始化(完全和部门), 那么不要随便使用数组中的数据, 可能是一段垃圾数据(随机值)
int scores2[3];
printf("0 = %i\n", scores2[0]);
printf("1 = %i\n", scores2[1]);
printf("2 = %i\n", scores2[2]);
printf("-------\n");
// 注意: 定义数组的时候, 数组的元素个数不能使用变量, 如果使用变量, 那么数组中是一些随机值
int num = 10;
int scores3[num];
printf("0 = %i\n", scores3[0]);
printf("1 = %i\n", scores3[1]);
printf("2 = %i\n", scores3[2]);
// 注意: 不建议使用变量定义数组, 如果使用了变量定义数组, 作为数组的元素个数, 不初始化的情况下是随机值, 如果初始化会直接报错
// int num2 = 10;
// int scores4[num2] = {11, 12};
printf("-------\n");
// 注意: 如果定义的同时进行初始化, 那么元素的个数可以省略
// 省略之后, 初始化赋值几个数据, 那么数组的长度就是几. 也就是说数组将来就能存储几个数据
int scores5[] = {1, 3};
printf("0 = %i\n", scores5[0]);
printf("1 = %i\n", scores5[1]);
printf("-------\n");
// 注意; 如果定义数组时没有进行初始化, 那么不能省略元素个数
// int scores6[];
// 0 1 2 3 4
// int socres7[101] = {0, 0, 0, 1, 3};
// int socres7[101];
// socres7[99] = 1;
// socres7[100] = 3;
// 可以通过[索引] = 的方式, 给指定索引的元素赋值
int socres7[101] = {[99] = 1, [100] = 3};
printf("3 = %i\n", socres7[99]);
printf("4 = %i\n", socres7[100]);
// 注意: 只能在定义的同时利用{}进行初始化, 如果是先定义那么就不能使用{}进行初始化
// 如果先定义那么就不能再进行整体赋值, 只能单个赋值
// int scores8[3];
// scores8 = {1 , 4, 19};
// scores8[0] = 1;
return 0;
}
数组的遍历
int main(int argc, const char * argv[]) {
// 取出数组中所有的值, 称之为遍历
int scores[6] = {1, 23, 44, 66, 71, 88, 99 , 2};
/*
printf("scores[0] = %i\n", scores[0]);
printf("scores[1] = %i\n", scores[1]);
printf("scores[2] = %i\n", scores[2]);
printf("scores[3] = %i\n", scores[3]);
printf("scores[4] = %i\n", scores[4]);
printf("scores[5] = %i\n", scores[5]);
*/
// 注意: 在遍历数组的时候, 尽量不要把遍历的次数写死
// 遍历多少次应该由数组来决定, 也就是说遍历多少次应该通过数组计算得出
/*
printf("scores = %lu\n", sizeof(scores)); // 计算出数组占用的总字节数
printf("scores[0] = %lu\n", sizeof(scores[0])); // 计算出数组中某一个元素占用的字节数
printf("一个有多少个元素 : %lu\n", sizeof(scores) / sizeof(scores[0]));
*/
// 动态计算数组的元素个数
int length = sizeof(scores) / sizeof(scores[0]);
for (int i = 0; i < length; i++) {
printf("scores[%i] = %i\n", i,scores[i]);
}
return 0;
}
int main(int argc, const char * argv[]) {
// 变量在内存中的存储
// 由于变量的内存寻址是从大到小, 所以存储数据时会从高字节开始存储
int num = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
// 注意: 数组的存储和变量有点不一样, 数组存储元素, 是从所占用的低字节开始存储
char charValues[4] = {'l', 'u', 'c', 'k'};
/*
charValues[0] = 0x7fff5fbff7c8
charValues[1] = 0x7fff5fbff7c9
charValues[2] = 0x7fff5fbff7ca
charValues[3] = 0x7fff5fbff7cb
*/
printf("charValues[0] = %p\n", &charValues[0]);
printf("charValues[1] = %p\n", &charValues[1]);
printf("charValues[2] = %p\n", &charValues[2]);
printf("charValues[3] = %p\n", &charValues[3]);
// &charValues == &charValues[0] == charValues
printf("&charValues = %p\n", &charValues);
// 其实数组名就是数组的地址
printf("charValues = %p\n", charValues);
// 00000000 00000000 00000000 00000101
// 00000000 00000000 00000000 00000110
int nums[2] = {5, 6};
return 0;
}
数组的注意点
int main(int argc, const char * argv[]) {
char nums[2] = {1, 5};
// 0 , 1 , 2
char values[3] = {7, 8, 9};
// 注意点: 在使用数组的时候, 一定不要访问不属于字节的存储空间, 这样会导致数据混乱
// 有时候如果访问了不属于自己的存储空间, 程序会报错
// values[3] = 44;
// printf("values[3] = %i\n", values[3]);
// printf("nums[0] = %i\n", nums[0]);
nums[-1] = 88;
printf("values[2] = %i\n", values[2]);
return 0;
}
数组练习1
int main(int argc, const char * argv[]) {
// 从键盘录入当天出售BTC的价格并计算出售的BTC的总价和平均价(比如说一天出售了3个比特币)
// 1.接收数据
/*
printf("请输入第1个比特币的价格\n");
int value1 = -1;
scanf("%i", &value1);
printf("请输入第2个比特币的价格\n");
int value2 = -1;
scanf("%i", &value2);
printf("请输入第3个比特币的价格\n");
int value3 = -1;
scanf("%i", &value3);
*/
// int value3 = -1;
/*
int sum = 0;
int value = -1;
for (int i = 0; i < 3; i++) {
printf("请输入第3个比特币的价格\n");
scanf("%i", &value);
sum += value;
}
*/
// 1.1定义数组保存每个比特币的价格
int values[4] = {-1};
// 1.2动态计算数组的元素个数
int length = sizeof(values) / sizeof(values[0]);
// 1.3定义变量保存总和
int sum = 0;
for (int i = 0; i < length; i++) {
printf("请输入第%i个比特币的价格\n", i + 1);
scanf("%i", &values[i]);
sum += values[i];
}
/*
// 2.计算总和
// int sum = value1 + value2 + value3;
int sum = 0;
for (int i = 0; i < length; i++) {
sum += values[i];
}
*/
// 3.计算平局值
int average = sum / length;
// 4.输出结果
printf("sum = %i, average = %i\n", sum, average);
return 0;
}
数组和函数
// 基本数据类型作为函数的参数是值传递
// 如果形参是基本数据类型, 在函数中修改形参的值不会影响到实参的值
void change(int value)
{
value = 55;
}
// 注意: 数组名作为函数的参数传递, 是传递的数组的地址
// 因为数组名就是数组的地址 &number = &number[0] == number
// 注意: 如果数组作为函数的形参, 元素的个数可以省略
// 如果形参是数组, 那么在函数中修改形参的值, 会影响到实参的值
//void change2(int values[2])
void change2(int values[])
{
// values[0] = 88;
values[1] = 99;
}
int main(int argc, const char * argv[]) {
/*
int num = 10;
change(num);
printf("num = %i\n", num);
*/
int nums[2] = {1, 5};
/*
change2(nums); // 相当于传递了数组的地址
printf("nums[1] = %i\n", nums[1]);
*/
change(nums[0]);
printf("nums[0] = %i\n", nums[0]);
return 0;
}
数组和函数2
void printArray(int values[5], int length);
int main(int argc, const char * argv[]) {
// 要求定义一个函数, 实现遍历数组. (只要别人传递数组给函数, 就要求输出数组中所有元素的值)
int nums[3] = {1 , 3 , 5};
// printf("size = %i\n", sizeof(nums));
int length = sizeof(nums) / sizeof(nums[0]);
printArray(nums, length); // 数组名称就是数组的地址
return 0;
}
// 如果传递的数组的名称, 其实传递的是地址
// 如果传递的是地址, 其实传递的是指针
// 指针在64位编译环境占8个字节
// 注意: 如果数组作为形参, 那么在函数中就不能通过数组的名称计算出数组元素的个数
// 因为系统会自动将数组形参转换为指针, 指针占用8个字节
void printArray(int values[5], int length)
{
// printf("size = %i\n", sizeof(values));
// 1.动态计算数组的元素个数
// int length = sizeof(values) / sizeof(values[0]);
// 2.遍历数组
for (int i = 0; i < length; i++) {
printf("values[%i] = %i\n", i,values[i]);
}
}
数组练习2
int arrayMax(int values[], int length);
int arrayMax2(int values[], int length);
int main(int argc, const char * argv[]) {
// 设计一个函数int arrayMax(int a[], int count)找出数组元素的最大值
int nums[5] = {-99, -188, -5, -100, -77};
int length = sizeof(nums) / sizeof(nums[0]);
// int max = arrayMax(nums, length);
int max = arrayMax2(nums, length);
printf("max = %i\n", max);
return 0;
}
int arrayMax2(int values[], int length)
{
// 1.定义变量, 保存数组中最大值的角标(索引)
int max = 0;
// 2.遍历数组
for (int i = 1; i < length; i++) {
// 3.取出数组中对应角标的元素的值进行比较
if (values[max] < values[i]) {
// 如果当前遍历到的角标对应的元素的值大于max这个角标对应元素的值
// 那么就将当前的角标最为最大值的角标
max = i;
}
}
return values[max];
}
int arrayMax(int nums[], int length)
{
// 1.定义一个变量, 假设为最大值
// int max = 0; // 注意: 不能假设一个不是数组中的值最为最大
int max = nums[0];
// 2.遍历数组
for (int i = 1; i < length; i++) {
// 3.依次取出数组中每一个元素的值, 和假设的最大值进行比较
// 如果数组的元素大于假设的最大值, 就让当前元素的值作为最大值
if (max < nums[i]) {
max = nums[i];
}
}
return max;
}
数组练习3
int main(int argc, const char * argv[]) {
// 从键盘输入3个0~9的数字,然后输出0~9中哪些数字没有出现过
// 从键盘输入100个0~2000的数字,然后输出0~2000中哪些数字没有出现过
/*
输入: 1, 3 ,5
输出: 0, 2, 4, , 6, 7, 8, 9
*/
/*
// 1.接收用户输入的数据
int num1, num2, num3;
printf("输入三个整数, 用逗号隔开\n");
scanf("%i,%i,%i", &num1, &num2, &num3);
// 2.遍历打印0~9
for (int i = 0; i <= 9; i++) {
// 3.判断当前打印的值是否是用户输入的值, 如果是就不打印
if (num1 != i &&
num2 != i &&
num3 != i) {
printf("%i\n", i);
}
}
*/
// 空间换时间
// 1.定义数组保存所有用户输入的数
int nums[10] = {0};
// 2.接收用户输入的数据
int value = -1;
for (int i = 0; i < 3; i++) {
printf("请输入%i个整数\n", i+1);
scanf("%i", &value);
nums[value] = 1;
}
for (int i = 0; i < 10; i++) {
// printf("nums[%i] = %i\n", i , nums[i]);
if (nums[i] != 1) {
printf("%i\n", i);
}
}
return 0;
}
数组练习4
int main(int argc, const char * argv[]) {
// 要求从键盘输入6个0~9的数字,排序后输出
// 0~9999
// 1.定义数组保存用户输入的数据
int nums[10] = {0};
// 2.接收用户的数据
int value = -1;
for (int i = 0; i < 6; i++) {
printf("请输入第%i个数据\n", i + 1);
scanf("%i", &value); // 2, 2, 1, 2
// 7, 3, 6, 1
// nums[value] = 1;
nums[value] = nums[value] + 1;
}
for (int i = 0; i < 10; i++) { // i == 7
// printf("nums[%i] = %i\n", i , nums[i]);
/*
if (nums[i] != 0) {
printf("%i\n", i); // 1, 2, 2, 2
}
*/
for (int j = 0; j < nums[i]; j++) { // j == 1
printf("%i\n", i); // 1, 1, 2, 3, 3, 6
}
}
return 0;
}
选择排序
int main(int argc, const char * argv[]) {
// 已知一个无序的数组, 里面有5个元素, 要求对数组进行排序
int nums[8] = {99, 12, 88, 34, 5, 44, 12, 100};
/*
int a = 10;
int b = 12;
int c = 5;
printf("%i, %i, %i\n", a, b, c);
if (a > b) {
int temp = a;
a = b;
b = temp;
}
if (a > c)
{
int temp = a;
a = c;
c = temp;
}
if (b > c) {
int temp = b;
b = c;
c = temp;
}
printf("%i, %i, %i\n", a, b, c);
*/
int length = sizeof(nums) / sizeof(nums[0]);
printf("length = %i\n", length);
for (int i = 0; i < length; i++) {
printf("nums[%i] = %i\n", i, nums[i]);
}
// length - 1是为了防止角标越界
// length - 1因为最后一个元素已经没有可以比较的了
// 0, 1, 2, 3, 4
for (int i = 0; i < length - 1; i++) {
for (int j = i+1; j < length; j++) {
// printf("*");
// printf("i = %i, j = %i\n", i, j);
if (nums[i] > nums[j]) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
// printf("\n");
}
printf("--------------\n");
for (int i = 0; i < length; i++) {
printf("nums[%i] = %i\n", i, nums[i]);
}
return 0;
}
选择排序
int main(int argc, const char * argv[]) {
/*
思路:
1.先分析如何比较
2.找出比较的规律比较完一次之后第二次比较会少一次
3.打印倒三角
4.打印需要比较的角标
5.比较并交换位置
6.将常量替换为变量(length)
*/
// 已知一个无序的数组, 里面有5个元素, 要求对数组进行排序
int nums[6] = {99, 12, 88, 34, 5, 7};
int length = sizeof(nums) / sizeof(nums[0]);
for (int i = 0; i < length; i++) {
printf("nums[%i] = %i\n", i, nums[i]);
}
for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - 1 - i; j++) {
// printf("*");
// printf("%i == %i\n", j, j+1);
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
// printf("\n");
}
printf("----------\n");
for (int i = 0; i < length; i++) {
printf("nums[%i] = %i\n", i, nums[i]);
}
return 0;
}
选择-冒泡排序优化
void selectSort(int nums[], int length);
void printArray(int nums[], int length);
//void swap(int v1, int v2);
void swap(int nums[], int i, int j);
void bubbleSort(int nums[], int length);
int main(int argc, const char * argv[])
{
// 已知一个无序的数组, 里面有5个元素, 要求对数组进行排序
int nums[8] = {99, 12, 88, 34, 5, 44, 12, 100};
int length = sizeof(nums) / sizeof(nums[0]);
printArray(nums, length);
// selectSort(nums, length);
bubbleSort(nums, length);
printf("----------------\n");
printArray(nums, length);
return 0;
}
// 遍历数组
void printArray(int nums[], int length)
{
for (int i = 0; i < length; i++) {
printf("nums[%i] = %i\n", i, nums[i]);
}
}
void bubbleSort(int nums[], int length)
{
for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
swap(nums, j, j+1);
}
}
}
}
// 选择排序
void selectSort(int nums[], int length)
{
for (int i = 0; i < length - 1; i++) {
for (int j = i+1; j < length; j++) {
if (nums[i] > nums[j]) {
/*
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
*/
// swap(nums[i], nums[j]);
swap(nums, i, j);
}
}
}
}
// 基本数据类型作为函数的参数, 是值传递, 在函数中修改形参不会影响实参的值
/*
void swap(int v1, int v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}
*/
// 交换两个数的值
void swap(int nums[], int i, int j)
{
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
折半查找
#include <stdio.h>
#include <time.h>
int findKey(int nums[], int key, int length);
int findKey2(int nums[], int length, int key);
int findKey3(int nums[], int length, int key);
int main(int argc, const char * argv[]) {
// 现在已知一个有序的数组, 和一个key. 要求从数组中找到key对应的索引的位置
// 对该方法进行封装, 要求找到就返回对应的索引, 找不到就返回-1
int nums[500000] = {1, 3, 5, 7, 9, [499999] = 99};
int key = 99;
int length = sizeof(nums) / sizeof(nums[0]);
/*
// 消耗了多少1181毫秒
clock_t startTime = clock();
int index = findKey(nums, key, length);
clock_t endTime = clock();
printf("消耗了多少%lu毫秒\n", endTime - startTime);
printf("index = %i\n", index);
*/
// 消耗了多少1毫秒
clock_t startTime = clock();
// int index = findKey2(nums, length, key);
// 消耗了多少2毫秒
int index = findKey3(nums, length, key);
clock_t endTime = clock();
printf("消耗了多少%lu毫秒\n", endTime - startTime);
printf("index = %i\n", index);
return 0;
}
int findKey3(int nums[], int length, int key)
{
int min, max, mid;
min = 0;
max = length - 1;
// 只要还在我们的范围内就需要查找
while (min <= max) {
// 计算中间值
mid = (min + max) / 2;
if (key > nums[mid]) {
min = mid + 1;
}else if (key < nums[mid])
{
max = mid - 1;
}else
{
return mid;
}
}
return -1;
}
int findKey2(int nums[], int length, int key)
{
int min, max, mid;
min = 0;
max = length - 1;
mid = (min + max) / 2;
while (key != nums[mid]) {
// 判断如果要找的值, 大于了取出的值, 那么min要改变
if (key > nums[mid]) {
min = mid + 1;
// 判断如果要找的值, 小雨了取出的值, 那么max要改变
}else if (key < nums[mid])
{
max = mid - 1;
}
// 超出范围, 数组中没有需要查找的值
if (min > max) {
return -1;
}
// 每次改变完min和max都需要重新计算mid
mid = (min + max) / 2;
}
// printf("aaaaaa\n");
return mid;
}
int findKey(int nums[], int key, int length)
{
for (int i = 0; i < length; i++) {
if (nums[i] == key) {
// printf("%i\n", i);
return i;
}
}
return -1;
}
折半查找练习
#include <stdio.h>
int insertValue(int nums[], int length, int key);
int main(int argc, const char * argv[]) {
// 现有一个有序的数组, 要求给定一个数字, 将该数字插入到数组中, 还要保证数组是有序的
// 其实就是找到需要插入数字的位置
// 其实这个位置就是min的位置
/*
min = 0
max = 4
mid = 2
*/
// 0 1 2 3 4 5
int nums[5] = {1, 3, 5, 7,9};
int key = 4;
int length = sizeof(nums) / sizeof(nums[0]);
printf("需要插入的位置是%i\n", insertValue(nums, length, key));
return 0;
}
int insertValue(int nums[], int length, int key)
{
int min , max, mid;
min = 0;// 1 2
max = length - 1;// 4 1
while (min <= max) {
mid = (min + max) / 2; // 2 0 1
if (key > nums[mid]) {
min = mid + 1;
}else if (key < nums[mid])
{
max = mid - 1;
}
}
return min;
}
进制查表法
#include <stdio.h>
void printfBinary(int value);
void printfBinary2(int value);
void printOct(int value);
void printfHex(int value);
void printfHex2(int value);
void printfOct2(int value);
void printfBinary3(int value);
int main(int argc, const char * argv[]) {
/*
0000000000000000000000000000
00000000000000000000000000000111
*/
int num = 10;// 1010;
// printfBinary2(num);
// printOct(num);
// printfHex2(num);
// printfOct2(num);
printfBinary3(num);
return 0;
}
void printfBinary3(int value)
{
// 1.定义一个数组, 用于保存二进制中所有的取值
char charValues[] = {'0', '1'};
// 2.定义一个数组, 用于保存查询后的结果
char results[32] = {'0'};
// 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
int pos = 32;
while (value != 0) {
// 1.取出1位的值
int res = value & 1;
// 2.利用取出来得值到表中查询对应的结果
char c = charValues[res];
// 3.存储查询的结果
results[--pos] = c;
// 4.移除二进制被取过的1位
value = value >> 1;
}
// 4.打印结果
for (int i = pos; i < 32; i++) {
printf("%c", results[i]);
}
printf("\n");
}
void printfOct2(int value)
{
// 1.定义一个数组, 用于保存八进制中所有的取值
char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7'};
// 2.定义一个数组, 用于保存查询后的结果
char results[11] = {'0'};
// 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
int pos = 11;
while (value != 0) {
// 1.取出3位的值
int res = value & 7;
// 2.利用取出来得值到表中查询对应的结果
char c = charValues[res];
// 3.存储查询的结果
results[--pos] = c;
// 4.移除二进制被取过的三位
value = value >> 3;
}
// 4.打印结果
for (int i = pos; i < 11; i++) {
printf("%c", results[i]);
}
printf("\n");
}
void printfHex2(int value)
{
// 1.定义一个数组, 用于保存十六进制中所有的取值
// 规律: 取出的4个二进制位得到的值, 正好是数组中角标对应的值
char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
// '', '', '', '', '', '', '', ''
char results[8] = {'0'};
int pos = 8;
while (value != 0) {
// 取出4位的值
int res = value & 15;
// 利用这个值作为索引去数组中查询对应的十六进制的值
char c = charValues[res];
// printf("%c", c);
// 将取出来得值放到用于存储结果数组中
results[--pos] = c;
// 每取完一次就干掉它最低的4位
value = value >> 4;
// printf("pos = %i\n", pos);
}
for (int i = pos; i < 8; i++) {
printf("%c", results[i]);
}
printf("\n");
}
void printfHex(int value)
{
for (int i = 0; i <= 8; i++) {
int res = value & 15; // 1111
// 对十六进制进行特殊处理
if (res > 9) {
// 11 - 10 1 + a
char c = res - 10 + 'a';
printf("%c", c);
}else
{
printf("%i", res);
}
value = value >> 4;
}
}
void printOct(int value)
{
for (int i = 0; i <= 11; i++) {
int res = value & 7; // 111
printf("%i", res);
value = value >> 3;
}
}
void printfBinary2(int value)
{
for (int i = 0; i <= 32; i++) {
int res = value & 1;
printf("%i", res);
value = value >> 1;
}
printf("\n");
}
void printfBinary(int value)
{
// int offset = sizeof(value) * 8 - 1;
int offset = (sizeof(value) << 3) - 1;
while (offset >= 0) {
int res = (value >> offset) & 1;
printf("%i", res);
offset--;
}
printf("\n");
}
进制查表法优化
#include <stdio.h>
void total(int value, int base, int offset);
void ptintBinary(int num);
void printfOct(int num);
void printfHex(int num);
int main(int argc, const char * argv[]) {
// insert code here...
// ptintBinary(10);
// printfOct(10);
printfHex(10);
return 0;
}
void printfHex(int num)
{
total(num, 15, 4);
}
void printfOct(int num)
{
total(num, 7, 3);
}
void ptintBinary(int num)
{
total(num, 1, 1);
}
// 转换所有的进制
// value就是需要转换的数值
// base就是需要&上的数
// offset就是需要右移的位数
void total(int value, int base, int offset)
{
// 1.定义一个数组, 用于保存十六进制中所有的取值
char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
// 2.定义一个数组, 用于保存查询后的结果
char results[32] = {'0'};
// 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
int pos = sizeof(results)/ sizeof(results[0]);
while (value != 0) {
// 1.取出1位的值
int res = value & base;// 1 7 15
// 2.利用取出来得值到表中查询对应的结果
char c = charValues[res];
// 3.存储查询的结果
results[--pos] = c;
// 4.移除二进制被取过的1位
value = value >> offset;// 1 3 4
}
// 4.打印结果
for (int i = pos; i < 32; i++) {
printf("%c", results[i]);
}
printf("\n");
}
