C语言的数组笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_73796066/article/details/127518551

1 。sizeof（）是计算元素所占的空间------------ 是运算字符，后面有\0

strlen ( )是求字符串的长度--------------------- 是库函数，要引头文件

打印地址用%p

数组在输入时需要一个定义，之后还需要一个for循环

int arr[100000] for(i=0 ; i<n根据题意来确定n ; i++) scanf("%d",&arr[ i ])

数组的初始化--------------------------------------------------------------------------------------------------------------

在创建数组的同时给数组的内容一些初始化

如int arr[10]={1,2,3}数组里面有10个整数型，其中第一个是1，第二个是2，第三个是3.

可以char arr【abc】,也可以char arr“abcdef” sizeof（arr“abcdef”）=7,因为后面有\0;

strlen(arr"abcdef")=6,因为只是求字符串的长度

当char arr【】arr的中间没有数的时候，必须要给这个数组初始化，去定义有几个元素，如char arr【】={abcdef}，这个数组是7个元素，

二维数组 arr【可省略】【不可省略】

行可以省略，但是列不可以省略。

arr 【】={1,2,3,4}

#include<stdio.h>
int main()
{
	int arr[3][4]={{1,2,3},{4,5}};
	int i;
	for(i=0;i<=3;i++)
	{
		int j;
		for(j=0;j<=4;j++)
		{
			printf("%d",arr[i][j]); //这个[i]和[j]是下标，是1,2,3,4,5对应的下标 
		}
		printf("\n");              //当j=5 的时候，对应的是0 
	}
	return 0;
}

arr[i ][j ]的[ ]里对应的是数组中的下标，当j= 5 时对应的是0；

利用数组去解决冒泡思想

//对arr进行升序排列
#include<stdio.h>
void bulbbe_sort(int arr[],int sz)
{
	//先确定冒泡的趟数，就是几个元素冒几-1次泡 
	int i;
	int j;
	for(i=0;i<=sz-1;i++)
	{
		//再去确定一次的冒泡的思路
		 for(j=0;j<=sz-1-i;j++)
		 {
		 	if(arr[j]>arr[j+1])
		 	{
		 		int tmp;          // 9 10 8 7 6 5 4 3 2 1 
		 		tmp=arr[j];       // 9 8 10 7 6 5 4 3 2 1
		 		arr[j]=arr[j+1];
		 		arr[j+1]=tmp;
			 }
		 } 
	} 
}
int main()
{
	int arr[10]={10,9,8,7,6,5,4,3,2,1};
	int sz=sizeof(arr)/sizeof(arr[0]);
	bulbbe_sort(arr,sz);
	int k;
	for(k=0;k<=sz;k++)
	{
		printf("%d ",arr[k]);
	}
	return 0;
 }

将 10 9 8 7 6 5 4 3 2 1这一组数排成升序

先判断一更要进行多少趟

比如 10 9 8 7 6 5 4 3 2 1

9 10 8 7 6 5 4 3 2 1 //先两对两对的比较，10 和9，之后再10 和8，一更要进行9次比较

由此也可以看出，一更要进行9趟冒泡（先把10挪到后面，再9挪到后面......）

第一趟，需要比上9对之后10 就到了本来该在的位置了所以第二趟的时候要比上8对就可以了

第二趟 9 8 7 6 5 4 3 2 1 10

8 9 7 6 5 4 3 2 1 10 所以要 j < = sz - 1 - i

//你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
//输入: [3,2,1,5,6,4], k = 2
//输出: 5
#include<stdio.h>     //返回第三个最大的值 
int main()
{
	int arr[10]={23, 99, 50, 15, 55, 38, 99, 76, 52, 8};
	int i;
	int j;
	for(i=0;i < 10;i++)
	{
		for(j=0;j < 10-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				int tmp;
				tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
			}
		}
	//	printf("%d ",arr[j]);
	}
	scanf("%d",&i);
	printf("%d ",arr[10-i]);
	
	return 0;
}

---------------------------------------------------------------------------------------------------------------------------------

主函数中的bulbbe_sort(arr,sz)这个实参的arr传到形参的arr中，所传的其实是arr 数组中第一个元素的地址如第一个数 9 的地址

sizeof(arr) 在主函数里使用时是一组数组（能计算整个数组的大小），如果传到形参里去时，只传了arr的第一个元素，

当&arr 的时候，取出得是整个数组的地址

#include <stdio.h>
int main()
{
	int arr[]={1,2,3,4,5,6,7,8};
	printf("%p\n",arr);     // =地址
	printf("%p\n",&arr[0]);  //=地址
	printf("%p\n",&arr);     //=地址(所有元素的地址，但是这个只输出元素的开头地址）
    printf("%d\n",*arr);    // =1    //这个指针是arr在指针的第一个元素的内容，指针是内容。 
	return 0;
}

&arr 是输出所有数组的的地址，但是，这个只是输出第一的元素的地址，也就是表示元素的开始的地址

//对arr进行升序排列
#include<stdio.h>
void bulbbe_sort(int arr[],int sz)
{
	//先确定冒泡的趟数，就是几个元素冒几-1次泡 
	int i;
	int j;
	int flat=1;
	for(i=0;i<=sz-1;i++)
	{
		//再去确定一次的冒泡的思路
		 for(j=0;j<=sz-1-i;j++)
		 {
		 	if(arr[j]>arr[j+1])
		 	{
		 		int tmp;          // 9 10 8 7 6 5 4 3 2 1 
		 		tmp=arr[j];       // 9 8 10 7 6 5 4 3 2 1
		 		arr[j]=arr[j+1];
		 		arr[j+1]=tmp;
		 		flat=0;
			 }
		 } 
		 if(flat==1)
		 {
		 	break;
		 }
	} 
}
int main()
{
	int arr[10]={9,0,1,2,3,4,5,6,7,8};
	int sz=sizeof(arr)/sizeof(arr[0]);
	bulbbe_sort(arr,sz);
	int k;
	for(k=0;k<=sz;k++)
	{
		printf("%d ",arr[k]);
	}
	return 0;
 }

当然这个冒泡的思想最好还是加上个状态 flag 这样就不会当数组是升序的，程序还是一遍一遍的进行了。！上文中的break，是跳出的for循环，和if语句没有任何关系

首元素地址

#include <stdio.h>
int main()
{
	int arr[]={1,2,3,4,5,6,7,8};
	printf("%p\n",arr);
	printf("%p\n",&arr[0]);
    printf("%p\n",&arr);    //表示的是取整个数组的地址，但是这个的意思是数组的开头地址
	return 0;
}

当这个结果运行出来时，我会发现，printf的输出都是一样的，但是第三个是首元素开头的地址（取出的是整个元素的地址），并不是只有一个元素的地址，而是代表数组是从这里开始的看下面的代码，就可以看出，&arr+1 是整个数组的+1

#include <stdio.h>
int main()
{
	int arr[]={1,2,3,4,5,6,7,8};
	printf("%p\n",arr);                         //000000000062FE00
	printf("%p\n",arr+1);                       //000000000062FE04
	
	printf("%p\n",&arr[0]);                     //000000000062FE00
	printf("%p\n",&arr[0]+1);                   //000000000062FE04
	
	printf("%p\n",&arr);//表示数组从这里开始      //000000000062FE00
	printf("%p\n",&arr+1);                      //000000000062FE20
	return 0;
}

通常情况下，数组名都是首元素地址

1.但当sizeof（）内部单独放一个数组名，数组名表示整个数组（为了计算的是整个数组的大小单位是字节）

2.&arr的时候，数组名（arr）代表整个数组（为了取整个数组的地址） //除了sizeof（数组名），&数组名，其他遇到的数组名都是数组首元素的地址。

#include<stdio.h>
int blubbe_sort(int arr[],int sz)
{
	int i;
	int j;
	int flat=1;
	for(i=0;i<=sz-1;i++) //因为是数组，0代表下标 
	{
		for(j=0;j<=sz-1-i;j++)
		{
	       if(arr[j]<arr[j-1])
		   {
		   	 int tmp;
		   	 tmp = arr[j];
		   	 arr[j] = arr[j-1];
		   	 arr[j-1] = tmp;
		   	 flat=0;
			} 
		}
		if(flat==1)
		{
			break;
		}
	}
	return 0;
}
int main()
{
	int arr[]={1,4,2,5,7,9,6,4};
	int sz=sizeof(arr)/sizeof(arr[0]);
	blubbe_sort(arr,sz);
	int k;
	for(k=0;k<sz;k++)
	{
		printf("%d ",arr[k]);//这个是下标代表数组 
	}
	return 0;
}

注意注意是下标代表数组啊！！！