算法

sort 和sorted

list_name.sort() 返回一个排序后的列表，仅被定义在list中
sorted(list_name) 返回一个新列表，可用于所有可迭代对象

key 参数/函数

list.sort()和sorted函数增加了key参数来指定一个函数，此函数将在每个元素比较之前被调用。例如通过key指定的函数来忽略字符串的大小：

```python

>>>sorted("This is a test string from Andrew".split(),key=str.lower)
['a','Andrew','from','is','string','test','this']
```

key参数的值为一个函数，此函数只有一个参数，且返回一个值用来进行比较，这个技术是快速的因为key指定的函数将准确地对每个元素调用。
更广泛的使用情况是用复杂对象的某些值来对复杂对象的序列排序，例如：

```python
>>>student_tuples =[('john','a','15'),('jane','b','12'),('dave','b','15')]
```

key=lambda元素：元素[字段索引]
例如：想对元素第二个字段排序，则key= lambda y:y[1]、

```python
>>>list = [('a',4),('b',2),('c',5),('d',3)]

print(sorted(list,key= lambda x:x[0]))
```

牛客算法题：旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

示例：

```python
x=[4,5,6,7,8,1,2,3]
# 输出1
```

分析：二分查找变种，没有具体的值用来比较。那么用中间值和高低位进行比较，看处于递增还是递减序列，进行操作缩小范围。

处于递增：low上移
处于递减：high下移
其余情况：low++缩小范围

特殊情况

代码：

```python
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        if not rotateArray:
            return 0
        low = 0
        high = len(rotateArray)-1
        while low < high:
            mid = int((low+high)/2)
            # 非递减数列的情况
            if rotateArray[low] < rotateArray[high]:
                return rotateArray[low]

            if rotateArray[mid]>rotateArray[low]:
                low = mid + 1
            elif rotateArray[mid]<rotateArray[high]:
                high = mid
            else:
                low += 1
        return rotateArray[low]
A = Solution()
A.minNumberInRotateArray([4,5,6,7,8,1,2,3])
```

牛客算法题：反转链表

题目描述：
输入一个链表，反转链表后，输出新链表的表头。

我的解法：利用三个指针反转链表

牛客算法题：链表中的节点每K个一组翻转

题目描述：
将给出的链表中的节点每K个一组翻转，返回翻转后的链表。如果链表中的节点数不是k的倍数，将最后剩下的节点保持原样，你不能更改节点中的值，只能更改节点本身。要求空间复杂度o(1)。

例如：
给定的链表是1->2->3->4->5
对于k=2，你应该返回2->1->4->3->5
对于k=3，你应该返回3->2->1->4->5

我的解法：用一个栈先把链表的节点依次存起来，再在栈里面进行节点的翻转，再把链表按照翻转后的顺序连起来。

#     class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None



# @param head ListNode类 
# @param k int整型 
# @return ListNode类

class Solution:
    def reverseKGroup(self , head , k ):
        # 储存节点的栈
        s = []
        now = head
        if not head:
            return None
        # 按照原来的顺序将节点存栈
        while now:
            s.append(now)
            now = now.next
        n = len(s)//k
        # 把栈的每k个元素（保存额节点）依次翻转
        for i in range(0,n):
            # 这里不能用reverse()函数，因为reverse()函数返回的是一个列表，不能直接赋值给原来的列表，而reversed(Target_List)返回的是一个迭代器，则可以赋值给列表
            s[k*i:k*(i+1)]= reversed(s[k*i:k*(i+1)])
        # 按照翻转后的次序重新构造链表
        for i in range (0,len(s)-1):
            s[i].next =s[i+1]
        # 注意这里最后一个节点的next指针没有改变，会指向他原来指向的那个节点形成死循环
        s[-1].next = None
        return s[0]
        # write code here