第三关数组(青铜)
1 线性表基础
1.1线性表
线性表就是具有相同特征数据元素的一个有限序列
从不同的角度来看,线性表可以有不同的分类,例如:
从语言实现的角度
线性表分为两种:
一体式:存储表信息的单元与元素存储区以连续的方式安排在一块存储区里面,两部分数据的整体形成一个完整的顺序表对象.
这种结构整体性强,易于管理.但是由于数据元素存储区是表对象的一部分,顺序表创建后,元素存储区就固定了.C和C++都是一体式结构
分离式:表对象只保存与整个表有关的信息(即容量和元素个数),实际数据元素存放在另一个独立的元素存储区里,通过链接与基本表对象关联.java和python是分离式结构
从存储的角度
顺序型:顺序型就是将数据存放在一段固定的区间内,这个时候访问元素的效率非常之高,但是增加和删除元素代价会比较大,如果要扩容的话只能整体搬迁.
链表型:元素之间是通过地址来依次连接的,访问必须从前往后找查询效率低下,但是删除和增加元素比较方便,也不需要考虑扩容问题,链表的常见实现方式有单链表,双链表,双向链表等等
从访问限制的角度
栈和队列又称之为访问受限的线性表,插入和删除受到限制,只能在固定的位置上进行.
从扩容的角度
采用分离式结构的顺序表，若将数据区更换为存储空间更大的区域，则可以在不改变表对象的前提下对其数据存储区进行了扩充，所有使用这个表的地方都不必修改。只要程序的运行环境（计算机系统）还有空闲存储，这种表结构就不会因为满了而导致操作无法进行。人们把采用这种技术实现的顺序表称为动态顺序表，因为其容量可以在使用中动态变化。
扩充的两种策略:
**第一种:**每次扩充增加固定数目的存储位置,如每次扩充增加10个元素位置,这种策略可称之为线性增长.特点:节省空间,但是扩充操作频繁,操作次数多
**第二种:**每次扩充容量加倍,如每次扩充增加一倍存储空间.特点:减少了扩充操作的执行次数,但可能会浪费空间资源.以空间换时间,推荐的方式
具体到每种结构语言中的结构，实现方式千差万别。其中Java基本是扩容时加倍的方式。而在Python的官方实现中，list实现采用了如下的策略：在建立空表（或者很小的表）时，系统分配一块能容纳8个元素的存储区；在执行插入操作（insert或append）时，如果元素存储区满就换一块4倍大的存储区。但如果此时的表已经很大（目前的阀值为50000），则改变策略，采用加一倍的方法。引入这种改变策略的方式，是为了避免出现过多空闲的存储位置。
1.2数组的概念
(1)数组是线性表最基本的结构,特点是元素是一个紧密在一起的序列,相互之间不需要记录彼此的关系就能访问.
(2)数组有两个需要注意的点,一个从0开始记录,也就是第一个存元素的位置是a[0]最后一个是a[length-1].其次,数组的元素在内存中是连续的,且每个元素占用的内存大小是相同的
(3)数字的size和length不一定相同,数组有时候不是满的,所以size也不是一定相同的
1.3数组存储元素的特征
(1)我创建了一个大小为10的数组,此时数组里面是什么?
不同的语言处理会不一样,c语言每个位置都是一个随机数,java都是默认0,python则是直接指定,你指定的是什么就是什么,比如a=[1,2,3,4],再比如a=[0 for i in range(10)]这样定义的数组就是[0,0,0,0,0,0,0,0,0,0]
(2)是否可以指初始化一部分的位置?初始化的本质是什么?
初始化的本质就是覆盖已有的值，用你需要的值覆盖原来的0，因为数组本来是{0,0,0,0,0,0,0,0,0,0}，这里只不过被你替换成了{1,2,3,4,5,0,0,0,0,0}。如果此时你想知道有效元素的个数，就必须再使用一个额外的变量，例如size来标记。
(3)上面已经初始化的元素之间是否可以空着,例如初始化为{1,0,0,4,5,0,2,0,3,0}.其中0位置仍然是未初始化的?
不可以!要初始化就必须从前向后的连续空间初始化，不可以出现空缺的情况，这是违背数组的原则的。你正在进行某种运算期间可以先给部分位置赋值，而一旦稳定了，就不可以再出现空位置的情况。
(4)如果我需要的数据就是在中间某一段该怎么办呢?例如{0,0,3,4,5,6,7,0,0,0},此时该怎么拿到从3到7的元素呢?
你需要使用两个变量,例如left=2,right=6来表示区间[left,right]是有效的
(5)我删除的时候,已经被删除的位置该是什么呢?
例如原始数组为{1,2,3,4,5,6,7,8,0,0},我删除4之后,根据数组的移动原则,从5开始向前移动,变成{1,2,3,5,6,7,8,8,0,0},原来8的位置仍然是8，也就是删除4之后的结构为{1,2,3,5,6,7,8,8,0,0}，此时表示元素数量的size会减1变成7，原来8的位置仍然是8。因为我们是通过size来标记元素数量的，所以最后一个8不会被访问到。
(6)这个8看起来很不爽,是否可以优化?
优化了也没用,习惯就好,不用优化
2 数组基本操作
2.1 数组创建和初始化
2.2 查找一个元素
2.3 增加一个元素
增加和删除元素是数组最基本的操作,看别人的代码非常容易,但是自己写的时候经常bug满天飞.能准确处理游标和边界等情况是数组算法题最基础重要的问题之一.所以务必自己亲手能写一个才可以,不要感觉挺简单就不写,其中涉及的问题在所有与数组有关的算法题中都会遇到.面试冒汗时别怪没提醒!!!
/**
* @param arr
* @param size 数组已经存储的元素数量
* @param element 待插入的元素元素
* @return
*/
public static int addByElementSequence(int[] arr, int size, int element) {
//size和arr.length都表示元素的数量，都是从1开始编号
if (size >= arr.length)
throw new IllegalArgumentException("Add failed. Array is full.");
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]; //index下标开始的元素后移一个位置
}
arr[index] = element;//插入数据
return index;
}
2.4 删除一个元素
对于删除,不能一边从后向前移动一边查找了, 因为元素可能不存在.
所以要分为两个步骤,先从最左侧开始查是否存在元素,如果元素存在,则从该位置执行删除操作.
例如序列是 1 2 3 4 5 6 7 8 9 ，要删除5，则应先遍历，找到5，然后从5开始执行删除操作，也就是从6开始逐步覆盖上一个元素，最终将序列变成 1 2 3 4 6 7 8 9 [9]。
/**
* 遍历数组，如果发现目标元素，则将其删除，
* 数组的删除就是从目标元素开始，用后续元素依次覆盖前继元素
*
* @param arr 数组
* @param size 数组中的元素个数
* @param key 要删除的目标值
*/
public static int removeByElement(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;
}
3 算法热身–单调数组问题
先看个热身问题,我们在写算法的时候,数组是否有序是一个非常重要的前提,有或者没有可能会采用完全不同的策略.
分析：如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。所以遍历数组执行这个判定条件就行了，由于有递增和递减两种情况。于是我们执行两次循环就可以了，代码如下：
/**
* 第一种方法，两次遍历确定，第一次确定是否递增 ，第二次
*
* @param nums
* @return
*/
public static boolean isMonotonic(int[] nums) {
return isSorted(nums, true) || isSorted(nums, false);
}
public static boolean isSorted(int[] nums, boolean increasing) {
int n = nums.length;
for (int i = 0; i < n - 1; ++i) {
if(increasing){
if (nums[i] > nums[i + 1]) {
return false;
}
}else{
if (nums[i] < nums[i + 1]) {
return false;
}
}
}
return true;
}
这样虽然实现功能了，貌似有点繁琐，而且还要遍历两次，能否优化一下呢？假如我们在i和i+1位置出现了nums[i]>nums[i+1],而在另外一个地方j和j+1出现了nums[j]<nums[j+1]，那是不是说明就不是单调了呢？这样我们就可以使用两个变量标记一下就行了，代码如下：
/**
* 第二种方式，一次遍历确定
*如果是递增的就一定不能出现递减的相邻元素，
* 如果出现递减的就一定不能出现递增的相邻元素。
* @param nums
* @return
*/
public static boolean isMonotonic_2(int[] nums) {
boolean inc = true, dec = true;
int n = nums.length;
for (int i = 0; i < n - 1; ++i) {
if (nums[i] > nums[i + 1]) {
inc = false;
}
if (nums[i] < nums[i + 1]) {
dec = false;
}
}
return inc || dec;
}
leetcode35: 给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引.如果目标值不存在于数组中,返回它将会被安顺序插入的位置
public static int searchInsert(int[] nums, int target) {
int n = nums.length;
int left = 0, right = n - 1, ans = n;
while (left <= right) {
int mid = ((right - left) >> 1) + left;
if (target <= nums[mid]) {
ans = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
return ans;
}
4 算法热身–数组合并专题
给你两个按非递减顺序,排列的整数数组nums1和nums2,另有两个整数m和n,分别表示nums1和nums2中的元素数目.请你合并nums2到nums1中,使合并后的数组同样按非递减顺序排列.
/**
* 方法2：两个数组从后向前逐步合并
*
* @param nums1
* @param nums1_len
* @param nums2
* @param nums2_len
*/
public static void merge2(int[] nums1, int nums1_len, int[] nums2, int nums2_len) {
int i = nums1_len + nums2_len - 1;
int len1 = nums1_len - 1, len2 = nums2_len - 1;
while (len1 >= 0 && len2 >= 0) {
if (nums1[len1] <= nums2[len2])
nums1[i--] = nums2[len2--];
else if (nums1[len1] > nums2[len2])
nums1[i--] = nums1[len1--];
}
//假如A或者B数组还有剩余
while (len2 != -1) nums1[i--] = nums2[len2--];
while (len1 != -1) nums1[i--] = nums1[len1--];
}
扫一扫
257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
