Java/Python/Go不同开发语言基础数据结构和相关操作总结-数组篇

Java/Python/Go不同开发语言基础数据结构和相关操作总结

由于最近频繁在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>() {
    @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
    }
}); // 按年龄排序

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 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
})

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()等方式时,两个列表将指向不同的列表对象
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>