python列表的增删查改,已经冒泡,选择,快速排序

列表

定义列的格式：[元素1, 元素2, 元素3, ..., 元素n]

空列表可以直接使用[]

列表是一个类似于字符串的数据结构
数据结构:用来存储数据的不同的形式
字符串  字符串一旦被创建  就不可再发生改变,所有对字符串的操作,比如切片啥的,都是创建了一个新的字符串,改变的是新的字符串,而不是原串
列表在添加和删除之后,地址值是不会发生改变的,但是要记住不能重新定义(就是在重新写一遍)
需要注意:列表的定义不能出现重复名称  不然会出现重复名称对应不同的地址值
        列表一旦定义完毕之后  区间内的值可以随意改变  但是地址值不会发生改变
        
字符串  元祖  int  float的地址是不会发生改变的
列表  是一个可以改变的数据结构  内部元素可以随意发生改变   允许重复元素出现

tmp = ['xiaoWang',180, 65.0]

列表中可以存放不同类型的值

下标获取元素

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

增删查改 调用!!!

插入

"""      调用!!!!!!!!!!!!
添加元素有一下几个方法:
	x.append(目标列表) 在末尾添加元素
	x.insert(目标位置, 插入的元素 ) 在指定位置插入元素  insert(index, object)   如果位置为-1,插入后则在			都入第二个位置
	x.extend(目标列表) 合并两个列表,,在x中加入目标列表   当然也可以用+号
	"""
	#append
    A = ['xiaoWang','xiaoZhang','xiaoHua']   #定义变量A，默认有3个元素
    print("-----添加之前，列表A的数据-----A=%s" % A)
    temp = input('请输入要添加的学生姓名:')   #提示、并添加元素
    A.append(temp)
    print("-----添加之后，列表A的数据-----A=%s" % A)
    
    # insert
    strs = ['a','b','m','s']
	strs.insert(3,'h')
	print(strs)  # ['a', 'b', 'm', 'h', 's']
    
    # extend
    a = ['a','b','c']
	b = ['d','e','f']
	a.extend(b)
	print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
	print(b) # ['d','e','f'] b的内容不变
	
	

修改

我们是通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可

直接覆盖即可 列表名[索引值] = 新值

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----修改之前，列表A的数据-----A=%s" % A)
#修改元素
A[1] = 'xiaoLu'
print("-----修改之后，列表A的数据-----A=%s" % A)

查找

看指定的元素是否存在，以及查看元素所在的位置 # 可以直接用 name_list[下标],你存的什么类型,取出来就是啥类型

​ 可以通过索引值直接获取元素

• in 和 not in

• in（存在）,如果存在那么结果为true，否则为false

• not in（不存在），如果不存在那么结果为true，否则false

#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
#可以直接用 name_list[下标]
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:     #这里也可以写not in
    print('在列表中找到了相同的名字')
else:
    print('没有找到')

index 和 count

index用来查找元素所在的位置，如果未找到则会报错；

count用来计算某个元素出现的次数。它们的使用和字符串里的使用效果一致。

删除

列表元素的常用删除方法有：

• x.del：根据下标进行删除 这个的用法有点点特殊 暴力删除,内存都直接删除了,不仅仅只删除元素
• x.pop：弹出最后一个元素 , 默认为-1,但是可以弹出其他下标的值,比如-2 -3 ,出来的元素还可以被接收
• x.remove：根据元素的值进行删除,删除具体的值

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
del movieName[2]
print('------删除之后------movieName=%s' % movieName)

movieName2 = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName2=%s' % movieName2)
movieName2.pop()
print('------删除之后------movieName=%s' % movieName)

movieName3 = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName3)
movieName3.remove('指环王')
print('------删除之后------movieName3=%s' % movieName3)

排序

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

reverse方法是将list逆置。

a = [1, 4, 2, 3]
print(a)   #[1, 4, 2, 3]
a.reverse()  # 逆置，不排序
print(a)   #[3, 2, 4, 1]

a.sort()  # 默认从小到大排序
print(a)  #[1, 2, 3, 4]
a.sort(reverse=True)  # 从大到小排序
print(a)  #[4, 3, 2, 1]

列表的循环

while 没那么划算, 最好用for

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)

排序

选择排序

从小到大排序的,每一轮确定最小值,并排在最前面, 下标为0的位置和后面的位置一个一个的比

比如 4 5 1 8 6

第一轮: 第一个索引位置( 下标为0 )的值和后面的每一个值都比较一次,4和5比较,4小,不动, 4和1比较,1小,互换位子,这个时候第一个索引对应的值是1. 1和8比较,1小不动, 1和6比较,1小不动,第一轮结束 1 5 4 8 6

第二轮:第二个索引位置( 下标为1 )和后面的比较 得到 1 4 5 6 8

第三轮 : 第三个索引位置 得到 1 4 5 6 8

第四轮 : 第四个索引位置 得到 1 4 5 6 8

每一轮比较的次数逐渐减少,一轮少一次,总次数为 len(str())-1

'''打印
*******
******
*****
****
***
**
*    '''
for i in range(7):
    for j in range(i + 1, 7):
		print("8", end="")
#通过上面的改编   就变成了选择排序
nums = [5, 6, 7, 4, 3, 8, 1, 2]
for i in range(len(nums)):     #i控制第几轮,同时也是控制的下标为i的值
    for j in range(i + 1, len(nums)):   #j控制每一轮要对比多少次
        if nums[i] > nums[j]:			#nums[i]表示当前第几轮的下标为0的值
            						  #nums[j]表示每一轮的第i+1 i+2 i+3...i+n-2的下标的值
            nums[i], nums[j] = nums[j], nums[i]

冒泡排序

下标0 1比较, 然后下标1 2 比较,然后下标 2 .3比较,每一轮找到最大值,并排在最后

比如 4 5 1 8 6

第一轮: 4和5比较, 5大,不动, 然后5和1比较, 5大,所以换位, 然后5和8比,5小,不动,8和6比,8大, 8和6换位 ,最后为,4 1 5 6 8

第二轮: 4和1 比,4大 换,4和5比,5 大,不动,5和6 比,6大 ,不动,6 和8比,8 大 ,不动, 得 1 4 5 6 8

第三轮:5.6比较 不动 6.8比较 不动

第四轮: 6.8比较, 不动

nums = [5, 6, 7, 4, 3, 8, 1, 2]
for i in range(len(nums)):		# i控制第几轮,只是控制第几轮
    for j in range(0, len(nums) - i - 1):	#j控制每一轮多少次,,但是最多比较的次数为len(nums) - i - 1
        							#因为用的下标,比如nums有8个元素,下标最大为7,比较的最后一次的两个#									#为下标6.7的两个值,len(nums)的值为8, 8-2=6.当循环到下标为6的时,下								 #标为6的值就会和下标为7的值比较,,所以长度为len(nums) - i - 1
        if nums[j] > nums[j + 1]:  #这一轮中,下标为4的比下标为5的小,就互换位置
            nums[j], nums[j + 1] = nums[j + 1], nums[j]    #互换位置
print(nums)					#输出排序后的nums

快速排序(思想)

需要两个边界索引值 一般是i 和 j i在最左边, j在最右边 ,一个是最大索引值,一个是最小索引值

还需要一个基准值(base),基准值在左边,右边的j先动,反之亦然

拿着j往中间跑,同时i也要往中间跑,用base所对应的值为标准, 比如5 7 4 1 8 6 2 3

第一轮

i在5的左边蓄势待发 j在3的右边蓄势待发 base=5

j往左边 找比base值5 小的数, j找的第一个数字是3.比5小,所以不动了,j 停下来 i 就开始动

i往右边走 找比基准值5大的数, i找的第一个数字是7,比5大,所以这个时候的 i 和 j 所对应的值交换位置

得5 3 4 1 8 6 2 7

第二轮

j此时在数值7的头顶,j继续往左,找了2,j停下来 i 就开始往右,

i此时在数值3的头顶,找到了8 停下 得到5 3 4 1 2 6 8 7

每次停下,两个数字都要交换

第三轮

此时j在数值8的头顶 ,i在数值2的头顶

然后j动了,但是撞到了在数值2头顶的i ,这个时候 因为i和j 碰到了 ,所以吧i和j屁股下的 2和基准值5交换

交换之后,会发现,在i和j撞的地方,左边的都是小于5的,右边的都是大于5的,得到 2 3 4 1 5 6 8 7

第四轮

用5为红线,吧左右分开,2 3 4 1 和6 8 7 分别进行和第一轮一样的操作

第五轮… 分开之后排好了,就开始回收