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\<Object>
- 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\<Object>
- 1.3.2 List\<Object>转[]Object
- 1.3.3 指定元素排序
- 1.3.4 数据拷贝
- 1.3.4.1 赋值实现浅拷贝
- 1.3.4.2 遍历循环复制实现深拷贝
- 1.3.4.3 使用List实现类的构造方法实现深拷贝
- 1.3.4.4 使用list.addAll()方法实现深拷贝
- 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.1.1 数组指针实现浅拷贝
- 2.3.1.2 数组赋值实现深拷贝
- 2.3.1.3 切片赋值实现浅拷贝
- 2.3.1.4 切片赋值实现深拷贝
- 2.3.1.5 指定元素排序
- 3. Python
- 3.1 列表
- 3.1.1 数据结构和定义方式
- 3.1.2 增加
- 3.1.3 修改
- 3.1.4 查询
- 3.1.5 删除
- 3.1.6 获取元素的位置
- 3.1.7 获取总长度
- 3.1.8 正向排序
- 3.1.9 逆向排序
- 3.2 切片
- 3.2.1 数据结构和定义方式
- 2.3 常用其他方法
- 2.3.1 数组扩展另一个数组
- 2.3.2 数组反转
- 2.3.5 指定元素排序
- 2.3.6 sort()和sorted()的区别
- 2.3.7 数据拷贝
- 2.3.7.1 赋值实现浅拷贝
- 2.3.7.2 copy()方法实现浅拷贝
- 2.3.7.3 list()方法实现深拷贝
- 2.3.7.4 索引重新构造实现深拷贝
- 2.3.7.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<Object>的void add(int index, E element);
# 指定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<Object>的void remove(int index);
# 指定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 = Arrays.binarySearch(Object[] list, Object key);
int index = Arrays.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<Object>
声明不固定长度的列表,因此能够提供更加丰富的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<Object>
String[] strArray = new String[10];
List<String> arrayList = new ArrayList<>(strArray.length);
Collections.addAll(arrayList, strArray);
1.3.2 List<Object>转[]Object
List<String> arrayList = new ArrayList<Integer>() {{add(String o1);add(String o2);
}};Strng[] 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>() {@Overridepublic 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}
}); // 按年龄排序
1.3.4 数据拷贝
浅拷贝:只拷贝源对象的地址,所以新对象与老对象共用一个地址,当该地址变化时,两个对象也会随之改变
深拷贝:拷贝对象的所有值,即使源对象发生任何改变,拷贝的值也不会变化。
由于日常使用数组的场景较少,因此在这里不做讨论,只讨论列表的拷贝情况,日常使用比较多是深拷贝,因此需要注意
1.3.4.1 赋值实现浅拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst = src;
1.3.4.2 遍历循环复制实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>(src.size());
for(String s : src){ dst.add(s);
}
1.3.4.3 使用List实现类的构造方法实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>(src);
1.3.4.4 使用list.addAll()方法实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>();
dst.addAll(src);
总结
- 使用赋值操作,此时两个列表将指向同一个列表对象
- 使用遍历、List()构造、list.addAll()等方式时,两个列表将指向不同的列表对象
2. Go
go语言没有java语言的数据结构丰富,只有简单的几种基础类型,如果希望引入复杂的数据结构实现类似java一样复杂多样的功能,需要引入第三方库。不过,在引入第三方库时,一定要确保对引用的库底层的实现是足够了解的,避免有意想不到的情况出现,导致程序的运行不符合预期。
go语言中在列表是实现上通常是分为数组和切片2种方式。两者在声明上很贴近,差别就是数组声明是指定长度,而切片声明是不指定长度。
2.1 静态数组[]Object
go语言定义的数组特性和java是一样的,可以参考 Java静态数组
2.1.1 数据结构和定义方式
声明时必须指定长度,注意跟切片的区别。 查看Go切片
# 定义空数据
var list [5]int;
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;
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 数据拷贝
2.3.1.1 数组指针实现浅拷贝
src := [3]int{1,2,3}
dst := []int// 赋值指针,形成浅拷贝,任意数组调整,都会导致2个数组发生调整
dst := &src
2.3.1.2 数组赋值实现深拷贝
src := [3]int{1,2,3}
dst := [3]int// 赋值数组,形成深拷贝,无论调整s还是dst的值,都会导致2个切片被改变
dst := src
2.3.1.3 切片赋值实现浅拷贝
# 数组拷贝给切片
dst := make([]int)
s:= []int{1,2,3}
# 无论调整s还是dst的值,都会导致2个切片被改变
dst := s
2.3.1.4 切片赋值实现深拷贝
# 注意,拷贝过程以长度小的切片为准,只能拷贝切片长度小的区间,因此需要注意申请切片时设置切片长度,否则会无法赋值
copy(dst,src)dst:= [3]int{1,2,3}
//如果加入的两个数组切片不一样大,就会按其中较小的那个数组切片的元素个数进行复制所以要先声明slice切片的长度,否则会无法赋值。
s := make([]int, len(dst))
copy(s,dst[:])
总结
- 数组实现浅拷贝使用指针,实现深拷贝使用复制
- 切片浅拷贝使用复制,深拷贝使用copy
2.3.1.5 指定元素排序
type aStructure struct {name stringage 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
})
3. Python
python语言中没有定义数组这个数据结构,而是定义了 列表和切片,列表和切片的长度是不固定,因此能够支持很多丰富的api。这个一点跟go、java有区别。
3.1 列表
声明不固定长度的列表,因此能够提供更加丰富的api和操作方法,也是最常用的数据结构。
3.1.1 数据结构和定义方式
list = [1, 2, 3, 4, 5 ]
3.1.2 增加
# 默认在最后添加元素
list.append(self, *args, **kwargs)
list = append(1)# 指定位置增加元素
list.insert(self, *args, **kwargs)
list.insert(3,6)
3.1.3 修改
# 设置index的值
list[index] = 100
3.1.4 查询
# 设置index的值
list[index]
3.1.5 删除
# 删除最后一个元素
list.pop()
# 删除index的值,如果index不存在,会返回报错
list.pop(index)# 删除第一个匹配的元素,如果值不存在,会返回报错
list.remove(object)
list.remove(3)
3.1.6 获取元素的位置
list.index(self, *args, **kwargs)
# 返回第一个匹配的元素的索引值,如果值不存在,会返回报错
index = list.index(3)
3.1.7 获取总长度
len(list)
3.1.8 正向排序
# 逆向排序
list.sort(reverse=True)
3.1.9 逆向排序
# 逆向排序
list.sort(reverse=True)
3.2 切片
在python中,列表已经声明了不固定长度,因此各种丰富的api都能够使用。而切片本质上也是列表,只不过在现有的列表上做数据切分,切分后返回一个新的数组,因此操作的api跟数组是相同的。
3.2.1 数据结构和定义方式
# 定义列表
list = [1, 2, 3, 4, 5 ]# 按照index进行切片
list2 = list[index:index+2]# 从左往右切片
list2 = list[:]
list2 = list[::]# 从右往左切片
list3 = list[::-1]
2.3 常用其他方法
2.3.1 数组扩展另一个数组
list.extend(list)
2.3.2 数组反转
# 使用数组的原始方法
list.reverse()# 使用切片实现
list2 = list[::-1]
2.3.5 指定元素排序
# 按照指定的元素进行排序
list = [{'language': 'Python', 'year': 1991},{'language': 'Swift', 'year': 2014},{'language': 'Java', 'year': 1995},{'language': 'C++', 'year': 1985},{'language': 'Go', 'year': 2007},{'language': 'Rust', 'year': 2010},
]def get_year(element):return element['year']list.sort(key=get_year)
2.3.6 sort()和sorted()的区别
- sort()是列表/切片的2个基础方法,能够进行排序,只针对当前的列表/切片进行排序,操作对象只能是列表。其他类型的数据结构如果不提供sort()方法,则不能操作。
- sorted()是原生的提供的基础方法,也能够实现排序,但是返回排序后的新列表,对原始的列表/切片不造成影响。操作的对象可以是列表或者其他对象
# 使用sort()进行排序
list.sort()# 使用sorted()操作,返回一个新的列表
list2 = sorted(list)
2.3.7 数据拷贝
2.3.7.1 赋值实现浅拷贝
src = {"Name": "HaiCoder", "Age": 100, "Score": 99.5}
dst = src
2.3.7.2 copy()方法实现浅拷贝
src = [1,2,3]
dst=src.copy()
2.3.7.3 list()方法实现深拷贝
src = [1,2,3]
dst=list(src)
2.3.7.4 索引重新构造实现深拷贝
src = [1,2,3]
dst=src[start:end]
2.3.7.5 列表生成实现深拷贝
src = [1,2,3]
dst=[ i for i in src]
总结
- 使用赋值操作,此时两个列表将指向同一个列表对象
- 使用索引,列表构造函数,列表生成式,copy()等方式时,两个列表将指向不同的列表对象