数据结构学习(Java版)——数组

普通数组

数组的定义:

数组是相同类型的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们

数组的基本特点:

  1. 其长度在创建是就确定,并且不能修改。
  2. 其元素的类型必须相同。
  3. 其元素可以是任何数据,包括基本类型和医用类型。
  4. 数组的索引可以有含义,比如可以是学号等。

数组的创建和初始化

声明数组

// 阿里巴巴强制规范
type[] arr_name;


type arr_name[];

初始化数组

1. 静态初始化

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

Man[] mans = {
new Man(1, 1);
new Man(2, 2);
};

2. 动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

3. 数组的默认初始化

// {0, 0}
int[] a = new int[2];
// {false, false}
boolean[] b = new boolean[2];
// {null, null}
String[] s = new String[2];

4. 数组的界限

下标的合法区间[0, length-1]

动态数组

动态数组的定义:

    Java中的ArrayList就是动态数组,提供了动态的增加和减少元素。

动态数组的基本特点:

  1. 数组大小可随元素多少自动调整。
  2. 不能存储基本数据类型。

动态数组的创建和初始化

声明初始化动态数组

ArrayList<type> arr_name = new ArrayList<>();

数组的界限:下标的合法区间[0, size-1]

方法摘要:

boolean add(E e)
          将指定的元素添加到此列表的尾部。
 void add(int index, E element)
          将指定的元素插入此列表中的指定位置。
 boolean addAll(Collection<? extends E> c)
          按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到此列表的尾部。
 boolean addAll(int index, Collection<? extends E> c)
          从指定的位置开始,将指定 collection 中的所有元素插入到此列表中。
 void clear()
          移除此列表中的所有元素。
 Object clone()
          返回此 ArrayList 实例的浅表副本。
 boolean contains(Object o)
          如果此列表中包含指定的元素,则返回 true。
 void ensureCapacity(int minCapacity)
          如有必要,增加此 ArrayList 实例的容量,以确保它至少能够容纳最小容量参数所指定的元素数。
 E get(int index)
          返回此列表中指定位置上的元素。
 int indexOf(Object o)
          返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1。
 boolean isEmpty()
          如果此列表中没有元素,则返回 true
 int lastIndexOf(Object o)
          返回此列表中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1。
 E remove(int index)
          移除此列表中指定位置上的元素。
 boolean remove(Object o)
          移除此列表中首次出现的指定元素(如果存在)。
protected  void removeRange(int fromIndex, int toIndex)
          移除列表中索引在 fromIndex(包括)和 toIndex(不包括)之间的所有元素。
 E set(int index, E element)
          用指定的元素替代此列表中指定位置上的元素。
 int size()
          返回此列表中的元素数。
 Object[] toArray()
          按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组。
<T> T[]
toArray(T[] a)
          按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
 void trimToSize()
          将此 ArrayList 实例的容量调整为列表的当前大小。

 

例题:

数组:力扣-题号-1313-https://leetcode-cn.com/problems/decompress-run-length-encoded-list/submissions/

 

给你一个以行程长度编码压缩的整数列表 nums 。

考虑每对相邻的两个元素 [a, b] = [nums[2*i], nums[2*i+1]] (其中 i >= 0 ),每一对都表示解压后有 a 个值为 b 的元素。

请你返回解压后的列表。

示例:

输入:nums = [1,2,3,4]
输出:[2,4,4,4]
解释:第一对 [1,2] 代表着 2 的出现频次为 1,所以生成数组 [2]。
第二对 [3,4] 代表着 4 的出现频次为 3,所以生成数组 [4,4,4]。
最后将它们串联到一起 [2] + [4,4,4,4] = [2,4,4,4]。

提示:

2 <= nums.length <= 100
nums.length % 2 == 0
1 <= nums[i] <= 100

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/decompress-run-length-encoded-list
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

(这里注意下,实际上这种方式很麻烦,只是为了写一个数组应用的例子)

class Solution {
    public int[] decompressRLElist(int[] nums) {
		int size = 0;
		for (int i = 0; i < nums.length; i+=2) {
			size+=nums[i];
		}
		int[] res = new int[size];
		int pointer = 0;
		for (int i = 0; i < res.length; i+=2) {
			if(i<nums.length) {
				for (int j = 0; j < nums[i]; j++) {
					res[pointer] = nums[i+1];
					pointer++;
				}
			}
		}
        return res;
    }
}

动态数组

class Solution {
    public int[] decompressRLElist(int[] nums) {
		ArrayList<Integer> a = new ArrayList<>();
		for (int i = 0; i < nums.length; i+=2) {
			for (int j = 0; j < nums[i]; j++) {
				a.add(nums[i+1]);
			}
		}
		int[] res = new int[a.size()];
		for (int i = 0; i < a.size(); i++) {
			res[i] = a.get(i);
		}
        return res;
    }
}

 

 
发布了33 篇原创文章 · 获赞 22 · 访问量 6737

猜你喜欢

转载自blog.csdn.net/qq_42909053/article/details/104301726