算法通关村第三关——不简单的数组增删改查（青铜）-CSDN博客

本文链接：https://blog.csdn.net/weixin_62986364/article/details/133955275

概念

线性表

语言实现角度：一体式、分离式
储存角度：顺序型、链表型
访问限制：受限
扩容角度：固定扩容、倍数扩容
注意：

这里java是加倍的方式
python是偏动态的方式，当小于50000时，是一次性换四倍的储存区。大于50000时，就是加倍

数组

概念都懂就记录一下注意事项：

因为储存原因，数组空间不一定是满的，size和length长度不一样

数组储存元素的特征

基本操作

初始化

java:

int[] arr =new int[10]

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

python:

list = []

查找元素

函数参数说明：
arr：查找的数组
size：已经存放的元素个数
key：查找的元素
java：

public static int findByElement(int[] arr,int size, int key){
	for(int i = 0;i<size;i++){
		if(arr[i]==key) return i;
	}
	return -1;
}

python:

def findByElement(arr，size,key):
	for i in range(size):
		if arr[i]==key :return i
return -1

int findByElement(int arr[],int size,int key){
	for(int i=0;i<size;i++){
		if(arr[i]==key){
			return i;
		}
	}
	return -1;
}

增加一个元素

流程：找到要添加的位置，其后元素都往后移，然后插入到空出来的位置上。

参数说明：
arr
size：数组已经储存的元素数量，从1开始,就是说这里不是☞索引
element：待插入的元素
思考：

为什么是size>=arr.length?
答：因为数组索引开始是从零开始

java：

public static int addByElementSequence(int[] arr, int size, int elemnet){
	if(size>=arr.length) return -1;
	int index =size;
	for (int i = 0;i<size;i++){
		if(element<arr[i]){
			index = i;
			break;
		}
	}
	
	for(int j=size;j>index;j--){
		arr[j]=arr[j-1];
	}
	arr[index]=element;
	return index;
}

python:

def addByElementSequence(arr,size,element):
	if size >= len(arr)
		return -1
	index =size
	# 先查找和上文查找一样
	for i in range(size):
		if element < arr[i]:
			index = i
			break
	#从arr[size]开始循环，因为开始时，索引只是从0到size，并没有arrp[size]，这里便完成创造
	for  j in range(size,index,-1):
		arr[j]=arr[j-1]
	arr[index]=element

	return index

C：

int addByElementSequence(int arr[],int size, int element){
	if (size >= sizeof(arr)/sizeof(arr[0])){
		return -1;

		int index =size;
		for(int i = 0;i<size;i++){
			if(element<arr[i]){
				index =i;
				break;
			}
		}
		for(int j =size;j>index;j--){
			arr[i]=arr[i-1];
		}
	}
}

其他方法

删除一个元素

思路：还是老规矩，先查后每一个向前移动一个
参数说明：
arr：数组
size：数组的元素个数（从1开始）
key：要删除的目标值
Java：

public int removerByEelement(int[] arr,int size,int key){
	int index = -1;
	for(int i=0;i<size;i++){
		if(arr[i] == key){
			index = i;
			break;
		}
	}
	if (index!=-1){
		for(int i = index+1;i<size;i++){
		arr[i-1]=arr[i];
		size--;	
		}
		return size;
	}
}

int removeByElement(int arr[],int size,int key{
	int index = - 1;//未找到返回-1
	for (int i =0;i<size;i++){
		if(arr[i]==key){
			index = i;
			break;
		}
	}
	
	if (index!=-1){
		for(int i=index+1;i<size;i++){
			arr[i-1]=arr[i];
		}
		size--;
	}
	
	return size;
}

算法热身

1.1单调数组问题

问题描述：LeetCode 896 判断一个给定数组是否单调？
分析：按照单调的概念，我们进行两次判断即可，第一次判断是否
Java：

public boolean isMonotonic(int[] nums){
	return isSorted(nums,ture) || isSorted(num,false);
}

public boolean isSored(int[] nums,increasing){
	int n = nums.length;
	for(i=1;i<n;i++){
	//如果increasing为真就是递增
		if(increasing){
			if (nums[i]<nums[i-1]) {
				return false;
			}
		}else{
			if(nums[i]>nums[i-1]) return false;
		}
	}
	return ture;
}

bool isSorted(int* nums,int numsSize,bool increasing){
	for(int i=0;i<numsSinze-1;i++){
		if(increasing){
			if(nums[i]>nums[i+1]){
				return false;
			}
		}else{
			if(nums[i]<nums[i+1]){
				return false;
			}
		}
	}
	return true;
}
bool isMonotonic(int* nums,int numsSize){
	return isSorted(nums,numsSize,true)||isSorted(nums,numsSize,false);
}

python

def isSorted(nums,incearsing):
	n = len(nums)
	for i in range(n-1):
		if incearsing:
			if nums[i] < num[i+1]:
				return 0
		else :
			if nums[i] > num[i+1]:
				return 0
	return 1

这里分析后可以简化代码（只记录python了）
思路：既然单调，那么说明数组只存在递增或递减，于是我们可以用两个符号来标记，开始让两个符号都为1，这里是还没有开始判断大小。之后我们开始循环数组，让每个相邻的元素比较一次，如果有前一个大于后一个的就让inc变成0，这样的话，因为dec表示前一个小于后一个，所以我们就只用确保dec不变成0就可以判断是否单调了；同理dec，也是。

def isMonotonic(nums):
	inc ,dec = 1,1
	n= len(nums)
	for i in range(n-1):
		if nums[i]>nums[i+1]:
			inc = 0
		if nums[i]<nums[i+1]:
			dec = 0
		return dec or inc