【C语言数组】数组的创建和初始化 内存中的存储 冒泡排序 sizeof 数组名

最新推荐文章于 2023-03-04 17:29:58 发布
最新推荐文章于 2023-03-04 17:29:58 发布
阅读量3.1k 收藏 2
点赞数 2
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56884023/article/details/119121396
版权

test

一、一维数组的创建和初始化

1、数组的创建

数组是一组相同类型元素的集合

#include <stdio.h>

int main()
{
	int arr[20];

	return 0;
}

数组创建 []中要给一个常量才可以 不能使用变量

2、数组初始化

2.1、不完全初始化

int main()
{
	int arr1[20] = { 1, 2, 3 }; // 不完全初始化，剩余的默认初始化为0
	int arr2[] = { 1, 2, 3 }; // 没有指定大小 根据初始化内容确定

	char arr3[] = "abc"; // a b c \0  -- 4个字节
	char arr4[] = { 'a', 'b', 'c' }; // a b c
	char arr5[] = { 'a', 98, 'c' }; // a b c

	return 0;
}

2.2、不初始化

int arr[5]; // 全局变量不初始化 默认放0

int main()
{
	int arr1[5];
	// 局部变量不初始化 放的是随机值

	return 0;
}

3、一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。

3.1、用下标打印1-10

#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int i = 0; //做下标

	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

3.2、sizeof 计算数组的元素个数

#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

// float sc[5] = { 0.0f, 3.0f };
// 结构体数组业可以创建

总结：
1.数组是使用下标来访问的，下标是从0开始。
2.数组的大小可以通过计算得到。

4、一维数组在内存中的存储

4.1、连续递增

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);

	for (i = 0; i < sz; i++)
	{
		printf("%p\n", &arr[i]); // 连续递增4  一个int4个字节的地址 10个
	}

	return 0;
}

随着数组下标的增长，元素的地址，也在有规律的递增。 由此可以得出结论：数组在内存中是连续存放的
数组随着下标的增长，地址是由低到高变化的

4.2、 整形指针加1是4个字节

int main()
{
	int a = 10;
	int* p = &a;

	printf("%p\n", p);
	printf("%p\n", p+1);

	return 0;
}

在这里插入图片描述

二、二维数组的创建和初始化

1、二维数组的创建

int main()
{
	int arr[3][4];
	char arr[3][5];
	double arr[2][4];

	return 0;
}

2、二维数组的初始化

整形数组

int main()
{
	int arr1[3][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 三行五列 一行放满换下一行
	int arr2[3][5] = { {1, 2}, {3, 4}, {5, 6} }; // 第一行1 2 0 0 0  第二行3 4 0 0 0  第三行5 6 0 0 0

	return 0;
}

在这里插入图片描述

行列省略

int main()
{
	int arr3[][5] = { {1, 2}, {3, 4}, {5, 6} };
	// 二维数组初始化可以省略行，但必须有列

	return 0;
}

字符数组

int main()
{
	char ch1[4][6] = { 'a', 'b' }; // 第一行"ab" 而三行没有
	char ch2[4][6] = { {'a'}, {'b'} }; // 第一行"a" 第二行"b" 第三四行没有
	char ch3[4][6] = { "abc", "def", "qwe" }; // 第一行"abc" 第二行"def" 第三行"qwe" 第四行没有

	return 0;
}

在这里插入图片描述

3、二维数组的使用

二维数组的使用也是通过下标的方式

#include <stdio.h>

int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9, 10} };
	int i = 0;
	for (i = 0; i < 3; i++) // 0~2
	{
		int j = 0;
		for (j = 0; j < 5; j++) // 0~4
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	// 1 2 3 0 0
	// 4 5 0 0 0
	// 6 7 8 9 10
	return 0;
}

4、二维数组在内存中的存储

#include <stdio.h>

// 打印第i行第j列的地址
int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9, 10} };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]); 
		}
	}

	return 0;
}

相差4 -> 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
在这里插入图片描述

5、连续存放

5.1、一维数组

#include <stdio.h>

int mian()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int* p = arr; // arr数组名是首元素的地址
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *p);
		p++;
	}
	printf("\n");
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

5.2、二维数组也是连续存放的

#include <stdio.h>

int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9, 0} };
	int* p = &arr[0][0]; // 第一行第一列的数组
	int i = 0;
	for (i = 0; i < 15; i++)
	{
		printf("%d ", *p); // 1 2 3 0 0 4 5 0 0 0 6 7 8 9 0
		p++;
	}

	return 0;
}

三、数组越界

数组的下标是有范围的，规定从0开始，假设有n个元素，最后一个元素的下标就是n-1
数组的下标如果小于0，或大于n-1，就是越界访问，超出了数组合法空间的访问
C语言本身是不做数组下标的越界检查，编译器也不一定会报错，所以写代码时，最好自己做越界的检查

int main()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int i = 0;
	for (i = 0; i <= 5; i++)
	{
		printf("%d ", arr[i]); // 1 2 3 4 5 -858993460 
		// 超出了0-4的范围 随机值
	}

	return 0;
}

四、数组作为函数参数

冒泡排序

1、什么是冒泡排序

冒泡排序的核心思想：两两相邻的元素进行比较 排成升序
一趟冒泡排序 可以搞定一个数字 让它来到最终应该出现的位置上
10个元素最多进行9趟冒泡排序可以完成升序 -> n个元素n-1趟

2、冒泡排序函数的错误设计

#include <stdio.h>

void Sort(int arr[])
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序
	Sort(arr);
	
	//Print(arr);

	return 0;
}

数组传参拿指针接收，void Sort(int arr[])本质上是void Sort(int* arr)整形指针
arr是指针，那么sizeof(arr)算出的指针大小是4。sizeof(arr[0])第一个元素是整形，大小是4。4/4=1

3、冒泡排序函数的正确设计

#include <stdio.h>

// void Sort(int arr[], int sz)
void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参，单独放在sizeof内部的时候，如：sizeof(arr)，这里的arr表示整个数组，不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int* arr 。
那么，函数内部的 sizeof(arr) 结果是4。

4、加上print函数

#include <stdio.h>

void Print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
		// printf("%d ", *(p + i));
		// printf("%d ", *p++); // 先简引用再++
	}
}

void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参，单独放在sizeof内部的时候，如：sizeof(arr)，这里的arr表示整个数组，不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

4、优化 flag 提高效率

#include <stdio.h>

void Print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
		// printf("%d ", *(p + i));
		// printf("%d ", *p++); // 先简引用再++
	}
}

void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		
		int flag = 1; // 假设已有序

		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0; // 如果发现有交换 就把flag设为0 本次排序无序
			}
		}

		if (flag == 1) // 如果没有交换 说明已有序 break跳出 提高效率
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参，单独放在sizeof内部的时候，如：sizeof(arr)，这里的arr表示整个数组，不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

五、数组名是什么？

数组名是数组首元素的地址（有两个例外）

// 如果数组名是首元素地址，那么：
// int arr[10] = { 0 };
// printf("%d\n", sizeof(arr));
// 为什么输出的结果是：40？

数组名是数组首元素的地址（有两个例外）:
1.sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小。
2.&数组名，这里的数组名表示整个数组，取出的是数组的地址。

#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5 };

	printf("%p\n", arr); // 首元素的地址
	printf("%p\n", &arr[0]); // 首元素的地址
	printf("%p\n", &arr); // 数组的地址

	printf("------------------------------------------\n");

	printf("%p\n", arr + 1); // 差4
	printf("%p\n", &arr[0] + 1); // 差4
	printf("%p\n", &arr + 1); //差40  因为此数组是10个元素 一个元素是一个整形 10个元素就是10个整形 大小是40 

	return 0;
}

指向元素的指针+1会跳过一个元素
指向数组的指针+1会跳过一个数组

三春去后诸芳尽
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
创建数组，完成初始化，赋值，排序，清空，逆转操作（C语言）
zz070的博客
10-25 888
题目要求： 创建一个数组， 实现函数init（）初始化数组、 实现函数input（）给数组赋值、 实现函数swap（）给数组排序、 实现reverse（）函数完成数组元素的逆置、 实现empty（）清空数组。 要求：自己设计函数的参数，返回值。 思路： 在main()函数中,调用有不同功能的函数完成相应的功能；通过switch语句进行分支，通过while循环控制不断进行不同操作。 创建Menu（）...
Java中对象数组初始化和排序
爱你の大表哥的博客
09-26 1516
java中对象数组初始化和排序由于今天上机的一道题感觉比较坑，所以总结一下。
定义一个数组，并对这个数组进行动态初始化，使用sort方法进行排序后，再将数组中的元素倒置过来。...
牧牛人Alec
06-17 714
Sort方法，生序排序 package com.fs.array; import java.util.Arrays; public class ArraySort { public static void main(String[] args) { //对数值型数组进行排序 int[] a = {5,45,71...
Java一维数组：创建、初始化；增强for循环；冒泡排序
小枯林的博客
07-31 825
1.一维数组的创建 public class TestDemo { public static void main(String[] args) { int[] myIntArray = new int[10]; // 创建数组时，必须同时声明数组长度 // int myIntArrays[] = new int[10];这种方式也可以，其他语言习惯于将'[]'放在变量名后； } } （1）数组创建后，数组的各元素均会有一个默认值； int型数组默认值：0； String：nu
#数组初始化方法##c99定位初始化###sizeof计算数组元素个数####注意事项
weixin_51676760的博客
11-14 576
数组的初始化方法 1. 2. 给第一个单元赋值，其余初始化为0 3.c99可以定位初始化值 数组的大小sizeof （sizeof的用法见收藏夹，这里只简单用一下） sizeof 给出整个数组所占的内容的大小，单位是字节 54/4=13 数组的元素数量=整个数组大大小/第一个单元的大小 sizeof(a)/sizeof(a[0]) 这样写 for(i=0;i<sizeof(a)/sizeof(a[0]);i++) 数组作为函数的参数时，不能在[]中给出数组的大小，也不能利用sizeof来计
c语言数组冒泡排序
03-07
1. **初始化**：设定一个n长度的数组，n为待排序元素的数量。 2. **外层循环**：进行n-1次遍历，因为每次遍历都能确保一个最大的元素被放到正确的位置。 3. **内层循环**：在当前未排序的元素中，从第一个元素开始，...
c语言编程题之数组操作非递减序列.zip
最新发布
03-30
在C语言编程中，数组是一种基本的数据结构，用于存储同类型的数据集合。本题目的核心是处理非递减序列，即数组中的元素按照从小到大的顺序排列，不允许有连续的降序。以下将详细讲解与题目相关的C语言知识点，包括...
C语言数组，数组是一种基本的数据结构
01-10
1. **声明和初始化数组**：在C语言中，你可以声明一个数组并同时初始化它的所有元素。例如，`int numbers[5] = {1, 2, 3, 4, 5}` 创建了一个包含5个整数的数组，而 `char name[] = "Achilles"` 创建了一个字符串...
冒泡排序优化算法_C语言_冒泡排序法_优化算法_
10-01
在C语言中，冒泡排序的实现通常涉及到指针操作和循环控制。 传统的冒泡排序算法时间复杂度为O(n^2)，其中n是待排序序列的长度。这种效率在数据量较大的情况下显得较低。为了优化冒泡排序，我们可以引入两个关键策略...
冒泡法排序（直接给出数组）.zip
01-04
1. **初始化**：首先，我们需要一个未排序的数组。在C语言中，可以声明一个整型数组并赋值。 ```c int arr[] = {5, 3, 8, 4, 2}; int n = sizeof(arr) / sizeof(arr[0]); ``` 2. **外层循环**：外层循环控制排序的...
Java 数组：数组声明创建与初始化、数组内存分析、多维数组、冒泡排序、二分查找法
turbo小世界
04-28 199
文章目录Java数组1、数组声明创建与初始化2、内存分析3、多维数组4、Arrays类5、冒泡排序 面试常遇见6、稀疏数组 重点 压缩数组7、二分查找法(折半查找法) 面试常见 Java数组 数组是相同类型数据的有序集合。每个数据称一个数组元素，每个元素可通过下标来进行访问。 1、数组声明创建与初始化 语法： dataType[] arrayRefVar; // 首选，推荐使用 dataType...
数组学习（一）——数组的定义，数组的初始化，数组的常用操作，数组的排序
weixin_52725999的博客
02-24 802
数组 数组是一种引用类型 数组是一种线性的数据结构 数组是能够保存相同类型的数据的一块连续的内存空间，数组一旦创建，长度就不可变 什么时候使用数组呢？ 例子：有一个班级，10名同学，每一位同学都有一个成绩， 一名同学的成绩，定义一个变量进行保存 int score; 所以： int score1; int score2; ... int score10; 使用数组简化定义过程 int[] score; 数组的定义 语法： 数据类型[] 数组名；//推荐使用第一种，方便读 数据类型 数组名[]; //是
memset(a,b,sizeof(a))初始化数组
qq_42263272的博客
01-28 1556
#include<bits/stdc++.h> using namespace std; int main() { char s[50]="asdasdasdasdads"; memset(s,'q',1); printf("%s",s); getchar(); return 0; }
(C语言)字符数组初始化与sizeof()与strlen()
weixin_53112343的博客
12-31 462
权当笔记。 看官能看懂最好，看不懂的话可以拿源码去运行下。 #include<stdio.h> #include<string.h> /* "he"看着只有两个字符，但是只用2个字节是没法存下去的。 如果是ch3[2]="he"，这样会报错。因为没有给\0留地方 得用ch3[3]="he"; ch2[]={'h','e'};这种定义方法相当于就是放了一个'h'和一个'e'在ch2后面没有主动放\0，所以空间占用两个字节 但是strlen()是读到\0才终止的，然后计算\0之
sizeof("string") 以及字符数组使用字符串初始化
junyidcf的专栏
01-01 774
1. sizeof 对于常量字符串求字节长度时，注意C会对常量字符串追加‘\0’这样一个NUL字符(末尾已经有NUL字符)，所以会比所见常量字串长度大1 2. 在声明字符数组中使用常量字符串string初始化时，如果声明中未指定数组长度，注意数组长度为sizeof("string") 3. 在声明字符数组中使用常量字符串string初始化时，如果声明中指定了数组长度，且长度大于字符串长度，则剩
【Java基础02】数组及其排序
aoweijia2416的博客
09-14 83
LInk：【01】Java程序基本结构、表达式、语句与运算符 --> https://www.cnblogs.com/discoverspace/p/11509577.html 1.数组概念 1.1数组用一个标识符和下标来表示，下标可以区分数组中不同的元素。如果一个数组只有一个下标，则称为一维数组。有两个下标，则为二维数组。一般只用到三维数组，而一维和二维数组较常用。 ...
C语言_0304笔记_数组：数组运算/初始化/sizeof/数组里有几个数/新素数判断/二维数组/3*3井字棋
Shmily_as33的博客
03-04 386
计科人的回炉重造
一维数组 | 二维数组 | 内存解析
星海IT学习之路
07-01 757
好了，我亲爱的读者朋友，以上就是本文的全部内容了！！！ 觉得有点用记得给我点赞哦！ 通过坚持不懈地学习，持续不断地输出，你的编程基本功算得上是突飞猛进。 为了帮助更多的程序员，专注于分享有趣的 Java 技术编程和有益的程序人生。一开始，阅读量寥寥无几，关注人数更是少得可怜。但随自己的不断努力，阅读量和关注人都在猛烈攀升。 绝对不容错过，期待与你的不期而遇。 ...
java学习笔记十，数组创建过程及使用
竹狼的博客
02-09 394
数组的创建过程 在定义数组的时候，往往分为好几个过程 数组的定义 定义数组的时候，一般是先声明数组的类型，如 int[] a; 表示声明一个整型数组，数组名为a，此时在堆空间中会存放一个变量a 数组的赋值 当数组声明以后，就是给数组赋值，可以直接给数组赋值，也可以通过new给数组指定大小，再赋值 直接给数组赋值 a={1,2，3,4，5} 这种方式是直接给数组赋值，一旦赋值完毕后，数组的长度大小就被确定 直接给数组赋值 a=new int[10];此时会在堆空间中创造出一片空间，该空间可以存储
C语言冒泡排序与数组操作实践
总结来说，这份PPT覆盖了数组的基础概念、定义、初始化、访问方法，以及重要的排序算法——冒泡排序，适合计算机科学和编程入门者学习C语言中的数组操作和数据处理。通过理解和掌握这些内容，程序员可以更好地管理和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三春去后诸芳尽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值