Java/Python/Go不同开发语言基础数据结构和相关操作总结-数组篇
Java/Python/Go不同开发语言基础数据结构和相关操作总结
- 1. Java
-
-
- 1.1 静态数组Object[]
-
- 1.1.1 数据结构和定义方式
- 1.1.2 增加
- 1.1.3 修改
- 1.1.4 查询
- 1.1.5 删除
- 1.1.6 获取元素的位置
- 1.1.7 获取总长度
- 1.1.8 正向排序
- 1.1.9 逆向排序
- 1.2 动态列表List\
-
- 1.2.1 数据结构和定义方式
- 1.2.2 增加
- 1.2.3 修改
- 1.2.4 查询
- 1.2.5 删除
- 1.2.6 获取元素的位置
- 1.2.7 获取总长度
- 1.2.8 正向排序
- 1.2.9 逆向排序
- 1.3 常用其他方法
-
- 1.3.1 []Object转List\
- 1.3.2 List\
- 1.3.3 指定元素排序
-
- 2. Go
-
-
- 2.1 静态数组[]Object
-
- 2.1.1 数据结构和定义方式
- 2.1.2 增加
- 2.1.3 修改
- 2.1.4 查询
- 2.1.5 删除
- 2.1.6 获取元素的位置
- 2.1.7 获取总长度
- 2.1.8 正向排序
- 2.1.9 逆向排序
- 2.2 切片
-
- 2.2.1 数据结构和定义方式
- 2.2.1 增加
- 2.2.3 修改
- 2.2.4 查询
- 2.2.5 删除
- 2.2.6 获取元素的位置
- 2.2.7 获取总长度
- 2.2.8 正向排序
- 2.2.9 逆向排序
- 2.3 常用其他方法
-
- 2.3.1 数组转切片
- 2.3.2 切片转数组
- 2.3.3 数组和切片相互拷贝
- 2.3.4 指定元素排序
-
- 3. Python
-
-
- 3.1 列表数据结构和定义方式
- 3.2 增加
- 3.3 修改
- 3.4 查询
- 3.5 删除
- 3.6 获取总长度
- 3.7 正向排序
- 3.8 逆向排序
-
- 5. 参考文档
由于最近频繁在java、python、go三种开发语言中不断切换，有时候针对基础的数据结构和日常操作搞混了，因此本文进行相关梳理。文中涉及的相关数据结构和日常操作并不复杂，权当增强记忆和理解。
1. Java
在这三种语言中，java已经实现的数据结构是最多，功能最丰富的，这归功于java社区的不断发展，相关的开发者能够不断的利用更方便、更使用的数据结构。相应的，在引用一个陌生的数据结构时，应当重视底层的实现，避免有意想不到的情况出现，导致程序的运行不符合预期。
1.1 静态数组Object[]
- 静态数组的长度一旦定义就不能更改，无法动态扩容数组的长度。如果需要更改数组长度，通常的做法是创建一个新的数组，并将相关的数据拷贝到新数据上
- 由于定义了数组长度，因此每个元素可以通过下标获取，读取的成本比较小，时间长度是O(1)
- 如果需要再指定位置增、删元素，需要移动后续的相关元素，因此写的成本较大，时间长度是O(n)
- 返回Go静态数组
- 返回Python静态数组
1.1.1 数据结构和定义方式
# 定义空数据
int[] list = new int[5];
# 初始化定义数组
int[] list = new int[]{1,2,3,4,5,9};
1.1.2 增加
由于数组Object[]在初始化的时候，已经确定了数组的长度，因此不能进行增加操作，只能在现有的数组基础上做数据调整。如果需要添加元素
- 需要复制一个新数据，并且size+1
- 复制原有数组，根据情况拷贝相关的值到新数据中
- 根据需要添加的位置，并将后续的元素进行移动
如下方法可以在指定位置，在list数组中添加新元素，实现的效果等于List
# 指定index后添加元素
int index = 2;
int value = 5;
int[] array = new int[]{1,2,3,4};
int[] newArray = new int[array.length + 1];
for (int i = 0; i < array.length; i++) {
newArray[i] = array[i];
}
# 从后往前移动位置，并在index位置留空，便于后续调整index位置的值
for (int i = newArray.length - 1; i > index; i--) {
newArray[i] = newArray[i - 1];
}
newArray[index] = value;
array = newArray;
1.1.3 修改
# 设置index的值
list[int index] = element;
list[1]=2;
1.1.4 查询
# 获取index的值
list[int index];
list[1];
1.1.5 删除
由于数组Object[]在初始化的时候，已经确定了数组的长度，因此不能进行增加操作，只能在现有的数组基础上做数据调整。如果需要添加元素
- 需要复制一个新数据，并且size-1
- 复制原有数组，根据情况拷贝相关的值到新数据中
- 根据需要删除的位置，并将后续的元素进行移动
如下方法可以在指定位置，在list数组中添加新元素，实现的效果等于List
# 指定index后删除元素
int index = 2;
int value = 5;
int[] array = new int[]{1,2,3,4};
int[] newArray = new int[array.length + 1];
for (int i = 0; i < array.length; i++) {
# 移除index位置的元素
if(i != 2) {
newArray[i] = array[i];
}
}
array = newArray;
1.1.6 获取元素的位置
没有原生的方法能够直接获取元素的位置，需要通过遍历查找的方法进行获取
# 获取object的索引位置,-1表示没有该元素
int index = binarySearch(Object[] list, Object key);
int index = binarySearch(list, Object key)
1.1.7 获取总长度
# 获取list的总长度
int length = list.length
1.1.8 正向排序
Arrays.sort(list);
1.1.9 逆向排序
Arrays.sort(list, Collections.reverseOrder());
1.2 动态列表List
声明不固定长度的列表，因此能够提供更加丰富的api和操作方法，也是最常用的数据结构。
1.2.1 数据结构和定义方式
# 定义空列表
List<Integer> list = new ArrayList<>();
# 初始化定义数组
ArrayList<Integer> obj = new ArrayList<Integer>() {{
add(Object o1);
add(Object o2);
}};
# 初始化定义数组，T对象
ArrayList<T> obj = new ArrayList<T>() {{
add(Object o1);
add(Object o2);
}};
1.2.2 增加
# 指定index后添加元素
void add(int index, E element);
list.add(1,2);
# 默认在最后添加元素
void add(E element);
list.add(1);
1.2.3 修改
# 设置index的值
list.set(int index, E element);
list.set(1, 2);
1.2.4 查询
# 获取index的值
list.get(int index);
list.get(1);
1.2.5 删除
# 指定index后删除元素
list.remove(int index);
list.remove(1);
1.2.6 获取元素的位置
# 获取object的索引位置,-1表示没有该元素
int index = list.indexOf(Object o);
int index = list.indexOf(1);
1.2.7 获取总长度
# 获取list的总长度
int length = list.size();
int length = list.size();
1.2.8 正向排序
Collections.sort(list);
1.2.9 逆向排序
Collections.sort(list,Collections.reverseOrder());
1.3 常用其他方法
1.3.1 []Object转List
String[] strArray = new String[10];
List<String> arrayList = new ArrayList<>(strArray.length);
Collections.addAll(arrayList, strArray);
1.3.2 List
List<String> arrayList = new ArrayList<Integer>() {{
add(String o1);
add(String o2);
}};
String[] strArray = arrayList.toArray(new String[arrayList.size()]);
1.3.3 指定元素排序
# 定义元素类
class User {
String name;
int age;
}
# 定义相关列表
List<User> list = new ArrayList<>();
list.add(new User{"张三", 3});
list.add(new User{"李四", 4});
list.add(new User{"王五", 5});
# 或者使用如下方式进行
List<User> list = new ArrayList<User>(){{
add(new User{"张三", 3});
add(new User{"李四", 4});
add(new User{"王五", 5});
}};;
# 进行排序
Collections.sort(list3, new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
int diff = u1.getAge() - u2.getAge();
if (diff > 0) {
return 1;
} else if (diff < 0) {
return -1;
}
return 0; //相等为0
}
}); // 按年龄排序
2. Go
go语言没有java语言的数据结构丰富，只有简单的几种基础类型，如果希望引入复杂的数据结构实现类似java一样复杂多样的功能，需要引入第三方库。不过，在引入第三方库时，一定要确保对引用的库底层的实现是足够了解的，避免有意想不到的情况出现，导致程序的运行不符合预期。
go语言中在列表是实现上通常是分为数组和切片2种方式。两者在声明上很贴近，差别就是数组声明是指定长度，而切片声明是不指定长度。
2.1 静态数组[]Object
go语言定义的数组特性和java是一样的，可以参考 Java静态数组
2.1.1 数据结构和定义方式
声明时必须指定长度，注意跟切片的区别。 查看Go切片
# 定义空数据
var list [5]int;
# 初始化定义数组
var list = [5]int{1, 2, 3, 4, 5}
2.1.2 增加
由于数组[]Object在初始化的时候，已经确定了数组的长度，因此不能进行增加操作，只能在现有的数组基础上做数据调整。如果需要添加元素
- 需要复制一个新数据，并且size+1
- 复制原有数组，根据情况拷贝相关的值到新数据中
- 根据需要添加的位置，并将后续的元素进行移动
如下方法可以在指定位置，在list数组中添加新元素
# 指定index后添加元素
int index = 2;
int value = 5;
var array = [5]int{1, 2, 3, 4, 5}
var newArray = [len(array)]int{}
for (int i = 0; i < len(array); i++) {
newArray[i] = array[i];
}
# 从后往前移动位置，并在index位置留空，便于后续调整index位置的值
for (int i = newArray.length - 1; i > index; i--) {
newArray[i] = newArray[i - 1];
}
newArray[index] = value;
array = newArray;
2.1.3 修改
# 设置index的值
list[int index] = element;
list[1]=2;
2.1.4 查询
# 获取index的值
list[int index];
list[1];
2.1.5 删除
由于数组[]Object在初始化的时候，已经确定了数组的长度，因此不能进行增加操作，只能在现有的数组基础上做数据调整。如果需要添加元素
- 需要复制一个新数据，并且size-1
- 复制原有数组，根据情况拷贝相关的值到新数据中
- 根据需要删除的位置，并将后续的元素进行移动
如下方法可以在指定位置，在list数组中添加新元素
# 指定index后删除元素
int index = 2;
int value = 5;
var array = [5]int{1, 2, 3, 4, 5}
var newArray = [len(array)]int{}
for (int i = 0; i < len(array); i++) {
# 移除index位置的元素
if(i != 2) {
newArray[i] = array[i];
}
}
array = newArray;
2.1.6 获取元素的位置
没有提供原生的方法，需要自己实现。
var test = [5]int{1,2,3,4,5};
for index, v := range test {
if v == 1 {
return index
}
}
2.1.7 获取总长度
# 获取list的总长度
var length = len(list)
2.1.8 正向排序
没有提供原生的方法，需要自己实现。
// 冒泡正向排序
var test = [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(test)-1; i++ {
for j := i + 1; j < len(test); j++ {
if test[i] > test[j] {
var tmp = test[j]
test[j] = test[i]
test[i] = tmp
}
}
}
2.1.9 逆向排序
没有提供原生的方法，需要自己实现。
// 冒泡逆向排序
var test = [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(test)-1; i++ {
for j := i + 1; j < len(test); j++ {
if test[i] < test[j] {
var tmp = test[j]
test[j] = test[i]
test[i] = tmp
}
}
}
2.2 切片
声明不固定长度的列表，因此能够提供更加丰富的api和操作方法，也是最常用的数据结构。声明不指定长度，注意跟数组的区别。 查看Go静态数组
2.2.1 数据结构和定义方式
# 定义空数据
var list []int;
# 初始化定义数组
var list = []int{1, 2, 3, 4, 5}
2.2.1 增加
# 指定index后添加元素
index := 2 //需要插入的位置
copy(list[index+1:], list[index:])
list[index] = 100
# 默认在最后添加元素
list = append(list, E element)
list = append(list, 1)
# 默认在最后增加一个新的切片
list = append(list, list2)
2.2.3 修改
# 设置index的值
list.set(int index, E element);
list[index] = 100
2.2.4 查询
# 获取index的值
list[index]
2.2.5 删除
没有原生的方法，需要自己实现，巧妙利用append方法
# 指定index后删除元素
list = append(list[:index], list[index+1:]...)
2.2.6 获取元素的位置
没有提供原生的方法，需要自己实现。
var test = []int{1,2,3,4,5};
for index, v := range test {
if v == 1 {
return index
}
}
2.2.7 获取总长度
# 获取list的总长度
int length = len(list)
2.2.8 正向排序
sort.Ints(list)
2.2.9 逆向排序
sort.Sort(sort.Reverse(sort.IntSlice(list)))
2.3 常用其他方法
2.3.1 数组转切片
# 指定index范围
list[index: index2]
list[index]
# 数组拷贝给切片
2.3.2 切片转数组
2.3.3 数组和切片相互拷贝
Copy（dst,src） 将src的值全部复制到dst中。
# 数组拷贝给切片
array:= [3]int{1,2,3}
//如果加入的两个数组切片不一样大，就会按其中较小的那个数组切片的元素个数进行复制所以要先声明slice切片的长度，否则会无法赋值。
s := make([]int, len(array))
copy(s,array[:])
# 切片给数组赋值
copy(array[:],s)
2.3.4 指定元素排序
type aStructure struct {
name string
age int
}
# 指定年龄正向排序
list := []aStructure{}
sort.Slice(list, func(i, j int) bool {
return list[i].age < mySlice[j].age
})
# 指定年龄逆向排序
list := []aStructure{}
sort.Slice(list, func(i, j int) bool {
return list[i].age > mySlice[j].age
})