【BIG_FG_CSDN】C++ 数组与指针 （个人向——学习笔记）

一维数组

在内存占用连续存储单元的相同类型数据序列的存储。

数组是静态存储器的块；在编译时确定大小后才能使用；

其声明格式如下：

元素类型 数组名[常量]；

元素类型：数组中元素的数据类型；
常量：数组的长度，即数组中存放数据的最大个数；可以是数，也可以是自己的常量；
如：

const int MaxSize=100;int a[MaxSize];

数组定义后，编译系统为其分配地址连续的一段内存空间.

数组名即是所分配内存的首地址，也称为数组的首地址；

数组声明时为其初始化赋值

格式为： 元素类型 数组名[常量]={初值 1,初值 2,...,初值 n};

初始化时，元素的个数应该小于等于数组的长度；

例如：

int a[10]={1,2,3}; //定义数组长度为 10，前 3 个元素初始化为 1,2,3，其它元素为 0；
int a[]={1,2,3}; //定义数组，长度省略，则长度等于初始化数据的实际个数 3。
int a[100]={0}; //数组中的值全部为0，只有{0}可以全部初始化；在做true与false时非常有用；

使用数组

数组元素通过下标来访问，每个元素均可视为一个变量来使用，

元素的访问方式为： 数组名[下标]；

下标值的有效范围是 0~数组长度-1；如果越界了，编译器是可以正常运行的，但是会出错；

除字符数组外，其它类型的数组不允许整体访问，也就是数组的输入输出需要对各个元素进行，也就是    数组名[下标]   这种方式使用；

访问数组元素的地址格式为：

&数组名[下标]或数组名+下标

数组的内存形象展示

例如：

int a[10];

声明了一个长度为 10 的 int 型一维数组，

系统需要为 a 分配连续的 40B 的内存空间，

元素的访问方式为 a[i]，

地址访问方式为&a[i]或 a+i，i 值的有效范围是 0~9。

数组在函数中的使用

数组做形参时，可以不写下标，如a[] 表示a[]的地址（指针）

        做实参时，不写[] 只写名；如 a

但是类型不要忘了啊！！！

viod f(int a[])//因为是地址传递，所以一般不要返回值；
{}
int main()
{int a[100];f(a);return 0;
}

数组的传递方式为地址传递，也就是说在自定义函数进行更改后，在主函数中也将其更改；因为地址传递，传过去的是地址位置，而你在使用时，只是改变了它的值；

数组中的一下典型例子：

数组的输入赋值与输出：

	int a[10], i;       //这两变量实现了数组的输入输出；for (i = 0; i < 10; i++) //i<10:输入十个数 这里10可以换成一个变量，可达到更多可能；cin >> a[i];for (i = 0; i < 10; i++)cout << a[i]<<" ";

输入10个整数，存入一堆数组中，求最大值及下标；

	int a[10], i,m=0;     //m用来确定最大值的下标for (i = 0; i < 10; i++) cin >> a[i];for (i = 0; i < 10; i++)if(a[i]>a[m])   //这里的比大小：说明了数组的使用与变量没有什么不同；m=i;      //数组与下标的运用；cout<<a[m]<<" "<<m;

从键盘输入n个整数（n<100），存放在一个一维数组中，以0结束；

int a[100],i=0;//a[]为存放的数组；i为循环的走下标的一个工具变量；//i=0因为数组的一个地址从开始；
cin >> a[i];//先输入一个数组；若一个数组是0就没有存放的数，进不了循环；
while (a[i]){   //用来判断是否结束；i++;        //i++ 使数组下标向下一位移动；cin >> a[i];}//再次存放，记住顺序不要搞反了；

从键盘输入n（n<100），再存放n个数在一维数组中；

int a[100],i,n;
cin >> n;
for (i = 0; i < n; i++){     //i<n：因为i从0开始,如是=n了就会多加一个数组；所有不能i<=ncin >> a[i];}

逆序输出

将数组下标从后往前走；

for (i = n - 1; i >= 0; i--)cout << a[i] << " ";

逆序存储

需要两数组，一个是正序，一个逆序；

for(int i=0;i<n;i++)//n为数组的长度b[i]=a[n-1-i];    //a[n-1]才是a数组的最后一个值；

排序

将原数组从小到大排序；

普通版，有小的我就换；

//运用了两个下标，i下标为选取的下标，j下标为与i下标比较的
for(i=0;i<n-1;i++)  //n-1因为第n项为最后一位不用再往后比了；for (j = i+1; j < n; j++)   //i+1从i后一个开始比较；{if (a[j] < a[i])    //要小的{int t = a[i];    //三位转换法a[i] = a[j];a[j] = t;}}

高效版，只换了最小的；

//m起到了高效的作用 
for(i=0;i<n-1;i++){m=i;for (j=i+1;j<n;j++)if (a[j]<a[m])  m=j; //只最从i往后的最小的数；所以只换了i的循环只转了一次；if (m!=i){t=a[i];a[i]=a[m];a[m]=t;}}

奇偶排序

将数组按奇数在前、偶数在后，同为奇数或偶数的按从小到大的顺序排序；

在一个数组里有两个要求的排序；

普通版：一个一个要求的做；

先选取从小到大的要求一直跟着当条件，再先将奇放前，然后偶放后面；

//从a[]的第一个值往后一点一点的满足条件；
//i为所选，为偶时就往后放，比比较的大时并且为奇时也往后放；
//前头的我只要小的奇数；所以偶数都要放后面；
for (i = 0; i < n; i++)//要是i走到了全是偶数时，不用管，等i走完了在偶数的循环时再解决
{for (x = i + 1; x < n; x++){if ((a[i] >= a[x] && a[x] % 2 != 0) || a[i] % 2 == 0){t = a[x];a[x] = a[i];a[i] = t;}}
}for (i = n - 1; i >= 0; i--)//奇牌完，剩偶没有排，偶都让我放后面了，所以这回i从后开始
{for (x = i - 1; x >= 0; x--){if (a[x] % 2 != 0)//当比较下标走到奇时，就不用走了；{break;}if (a[x] >= a[i] && a[x] % 2 == 0){t = a[x];a[x] = a[i];a[i] = t;}}
}

简化版：

只需要将条件都列出就好，但是不方便理解；

for(i=0;i<n-1;i++)for(j=i+1;j<n;j++)if((s[i]%2<s[j]%2)||(s[i]%2==s[j]%2)&&(s[i]>s[j])) {t=a[i],a[i]=a[j],a[j]=t}
// &&的优先级大于||  &&两边的式子不用加上()；
// s[i]%2<s[j]%2 表示前标为偶，后标为奇，  将偶放前，奇放后；
// 偶数=0 奇数=1
//s[i]%2==s[j]%2 表示同为偶||同为奇
//s[i]>s[j]  相同时，而且前标大就换；    ||后边的式子达到了从小到大；

数组筛选法 

在面对下标的判断，而数组没有任何要求时，将数组的值当做判断标志；

不满足就挖去，最后只要满足的；

int a[100] = { 0 };//将数组初始化成0，成为了中间变量，要求只与下标有关；
f(a);              //进行了一列的判断；将不满足的数组值变成非0数；
for (i = 0; i < n; i++)if (a[i] == 0) cout << i << " ";

例如：输入m、n（m，n<100），输出[m,n]之间的素数。

#include <iostream>
using namespace std;
int h(int n) //判断i是否为素数
{if (n == 2 || n == 3 || n == 5 || n == 7) return 0;if (n == 1 || n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return 1;return 0;
}void f(int a[], int m, int n)  //不满足条件的变成非0
{int i;for (i = m; i <= n; i++){if (h(i) == 1) a[i] = 1;}
}int main()              //0为满足条件的
{int n, a[101] = {0}, i, m;cin >> m >> n;f(a, m, n);for (i = m; i <= n; i++)if (a[i] == 0) cout << i << " ";return 0;
}

数组插入

插入，相当于排队，这时来了个老登来插排；

插排者要想插入队伍当中，必须先有人往后去，才能给老登留出位置；

位置怎么留呢？是被插的人先往后串一下就行了吗？肯定不啊，那样被插者的后一位的数据就被插者给覆盖了；所以要想完成插队，必须先从最后一位开始往后串一位，一次到被查的位置；

for(i=n-1;i>=x;i--)//x为被插的位置a[i+1]=a[i];
cin>>a[x];          //老登来也
n++;            //n为人数 因为来了个老登所以要++；

删除指定元素

删掉当指定元素相当于一堆人正在排队，突然有个人走掉了，这样现在这个队伍，从走掉者的后面一位开始往前串一个位置；

for(i=x+1;i<n;i++){a[i-1]=a[i];}n--;     

删除所有指定元素

//x为所要删除的指定元素；j=0;            //j最后呈现的数组，做到了一个数组干了两个数组的活；for(i=0;i<n;i++){if(a[i]!=x)    //i一直在进行循环，而相同时j不动，这样就将所删的元素给越了过去；{a[j]=a[i];j++;  }}n=j;          //n为数组长度，因为删除了一些元素，长度发生了变化

二维数组

声明格式为：

元素类型 数组名[常量1][常量2]

常量1 ：数组的最大行数，常量 2 ：数组的最大列数；

C++中，二维数组中各个元素按行优先规则在内存占用连续的一段存储空间；

就是每行存完，再存下一行；

如：int a[3][4]     // [3][4]代表最大长度，但是在使用时，还是从[0][0]开始从的，与一维数组类似；

二维数组初始化

如：2行3列二维数组的初始化

int a[2][3]={{1,2,3},{4,5,6}};
int a[ ][3]= {{1,2,3},{4,5,6}};
int a[ ][3]={1,2,3,4,5,6}; 

二维的使用

访问格式为：数组名[行下标][列下标]

二维数组例题：

二维输入输出

因为是二维，所以一个i用来走下标是不够用，所有需要两个工具变量，一个走行，一个走列；

int i,j,a[4][5];
for (i=0;i<4;i++)   //因为c++为行优先存储，所以一般地将代表行的变量放上面for (j=0;j<5;j++)cin>>a[i][j];
for (i=0;i<4;i++){for (j=0;j<5;j++)cout<<a[i][j]<<" ";cout<<endl;          //达到了行满换行的效果}

二维中寻找特定值

二维需要两个变量来存储最大值；

如：最大值

maxi=0;   
maxj=0;for (i=0;i<4;i++)for (j=0;j<5;j++)if (a[i][j]>a[maxi][maxj]){maxi=i;maxj=j;}
cout<<a[maxi][maxj];

二维数组求和

1.矩阵各行、列求和：

因为是各，所以将一个二维数组的行列存放在两个数组中一个代表行一个代表列；

求行用行的变量下标走，求列用列的变量下标走；

for(i=0;i<n;i++)        for(j=0;j<m;j++)b[i]+=a[i][j];
for(i=0;i<n;i++)for(j=0;j<m;j++)c[j]+=a[i][j];
for(i=0;i<n;i++)cout<<b[i]<<" ";cout<<endl;
for(j=0;j<m;j++)cout<<c[j]<<" ";

2.对角线元素之和：重复部分不相加 ，一个矩阵拥有两条对角线，一撇一捺；

矩阵为正方形时

for(i=0;i<n;i++)m+=b[i][i]+b[i][n-1-i];
if(n%2==1)                 //需要处理情况；m-=b[n/2][n/2];  //n为int；//常规的两个变量走；不需要考虑重复部分，因为if里用的是||
for(i=0;i<n;i++)for(j=0;j<n;j++)if(i==j||i=n-1-j)m+=a[i][j]; 

3.周边求和；

//普通低效版
for(i=0;i<n;i++)for(j=0;;j<m;j++)if(i==0||j==0||i==n-1||j==m-1)s+=a[i][j]; //高效进阶版   使计算机少跑几行
for(i=0;i<n;i++)          //因为走的是行，所以列不动  s+=b[i][0]+[i][n-1];   //将第一列与最后一列加满
//这里的j要是继续从0开始走到m的话，需要在后面的s减掉四个重复的角；
for(j=1;j<m-1;j++)        //因为走的是列，所以行不动 s+=b[0][j]+[n-1][j];   //将第一行与最后一行加满

参考文献：

[1]

[2]

[3]

[4]