《算法通关村——数组的增删查改》

数组的概念

        数组是一种数据结构，它可以存储多个相同类型的元素，并根据索引访问这些元素。数组通常在内存中是连续存储的，这样可以实现快速的随机访问。数组的长度是固定的，一旦创建就不能改变。数组可以是一维的、二维的甚至更高维的，可以存储数字、字符、对象等不同类型的数据。在很多编程语言中，数组是基本的数据结构之一，提供了对数据进行操作和存储的方便性。

数组的存储方式

        数组从0开始，也就是说第一个元素是a[0],若长度为length,则最后一个元素为a[length-1]。数组的存储是连续的，每个位置的大小都相同

        需要注意的是，数组的length与size是不同的，例如我们定义数组a[100]={1,6,2,7,8,4,2,3},那么他的实际size应该为8，而不是100

数组的存储元素

初始化

        若我们定义应该a[10]，那么里面的元素，在C/C++中，都是随机数，而在Java中，则全部都是0。同时在定义时，我们也可以部分初始化为如下：

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

但是，我们在初始化时，应该连续从前向后进行，不能以这种方式跳过部分初始化

存储结构

        对于一维数组的任一元素可以直接存取，即一维数组拥有随机存储特性。对于二维数组，存储结构则分为两种，按行优先存储以及按列优先存储，在存储时可以使用如下方法：

按行优先存储：

int a[2][3];
int k=0;
for(int i=0;i<2;i++){
    for(int j=0;j<3;j++){
        a[i][j]=k;
        k++;
    }
}  

按列优先存储：

int a[2][3];
int k=0;
for(int i=0;i<2;i++){
    for(int j=0;j<3;j++){
        a[j][i]=k;
        k++;
    }
}  

数组的基本操作

数组的创建与初始化：

        对于不同数组，初始化的方法也各有不同：对于数据比较少的数组，可以在定义时就初始化，如：  

//对于一维数组
int a[100]={1,2,3,4,5,6};

//对于二维数组
int a[5][5]={{1,2},{5,5,5,1},{2,3,0}};

则二维数组的输出应该为：
    1 2 0 0 0
    5 5 5 1 0
    2 3 0 0 0
    0 0 0 0 0
    0 0 0 0 0

那么对于数据比较大或者有规律的数组，我们一般使用循环赋值：

//一维数组
int a[n];
for(int i=0;i<a.size();i++){
    a[i]=i;
}
二维数组可参考前面内容

查找一个元素 

int main() {
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int target = 5;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (arr[i][j] == target) {
                cout<<i<<j<<endl;
            }
        }  
    } 
    return 0;
}

增加一个元素

        给你一个有序数组，将target插入数组的相应位置

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6,  8, 9};
    int target = 7;
    int ans=arr.size();
    for(int i=0;i<arr.size();i++){
        if(arr[i]>target){
            ans=i;
            break;
        }
    }//找到插入位置
    for(int j=10;j>ans;j--){
        arr[j]=arr[j-1];
    }//将后面元素向后移一个位置
    arr[ans]=target;
    return 0;
}

删除一个元素

        同样也是给你一个有序数组，要求删除一个target

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6,  8, 9};
    int target = 5;
    int ans=-1;
    for(int i=0;i<arr.size();i++){
        if(arr[i]==target){
            ans=i;
            break;
        }
    }//找到删除位置
    if(ans!=-1){
        for(int j=ans+1;j<arr.size();j++){
        arr[j-1]=arr[j];
    }//将后面元素向移一个位置
    arr.size()--;
  }
    return 0;
}

数组单调问题

        

单调分为单增与单减，因此，很简单粗暴的一个方式便是通过两次循环判断，那么有没有更简便的方法呢？请看下面代码

bool isMonotonic(vector<int>& A) {
    bool increasing = true;
    bool decreasing = true;

    for (int i = 1; i < A.size(); i++) {
        if (A[i] > A[i - 1]) {
            decreasing = false;
        } else if (A[i] < A[i - 1]) {
            increasing = false;
        }
    }

    return increasing || decreasing;
}

数组合并问题

 

void merge(int nums1[], int nums1_len, int m,int nums2[],int nums2_len,int n){ 
    int i=m+n-1;
 	int len1=m-1,len2=n-1;	
 	while (len1 >= 0 && len2 >=0){	
 	    if (nums1[len1] <= nums2[len2]){	
 	    nums1[i--]= nums2[len2--];	
   }else{	
 	    nums1[i--]= nums1[len1--];	
 
 	}	
 	//假如A或者B数组还有剩余	
 	while (len2!=-1){	
 	    nums1[i--]= nums2[len2--];	
 	}	
 	while (len1!=-1){	
 	    nums1[i--]=nums1[len1--];	
 	}
}