二分查找，排序，树，链表

二分查找：(顺序数组

class Solution(object):
    def search(self, nums, target):

        left=0
        right=len(nums)-1
        while left<=right:
            mid=left+(right-left)/2
            if nums[mid]==target:
                return mid
            else:
                if nums[mid]<target:
                    left=mid+1
                else:
                    right=mid-1
        return -1

 

 

 

 

先序遍历 (1)访问根节点(2)先序遍历左子树(3)先序遍历右子树

class Solution:

    def preorderTraversal(self, root):

        if not root:

            return [ ]

        res = [ ]

        res.append(root.val)

        res += self.preorderTraversal(root.left)

        res += self.preorderTraversal(root.right)

        return res

 

2.

        return[root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

 

 

 

中序遍历 (1)中序遍历左子树(2)访问根节点(3)中序遍历右子树

        if root == None:
            return []
        res = []
        res += self.inorderTraversal(root.left)
        res.append(root.val)
        res += self.inorderTraversal(root.right)
        return res

后序遍历 (1)后序遍历左子树(2)后序遍历右子树(3)访问根节点

        if root == None:
            return []
        lis = []
        lis += self.postorderTraversal(root.left)
        lis += self.postorderTraversal(root.right)
        lis.append(root.val)
        return lis

 

 

冒泡排序

def maopao_sort(rlist):
    for i in range(len(rlist)):
        for j in range(i+1, len(rlist)):
            if rlist[i] >= rlist[j]:
                rlist[i], rlist[j] = rlist[j], rlist[i]
    return rlist

 

插入排序 

从第一个元素开始，该元素可以认为已经被排序； 
取出下一个元素，在已经排序的元素序列中从后向前扫描； 
如果该元素（已排序）大于新元素，将该元素移到下一位置； 
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置； 
将新元素插入到该位置后； 
重复步骤2~5

def insertion_sort(list):
    n = len(list)
    for i in range(1,n):  #从list第二个元素开始
        for j in range(i,0,-1):
            if list[j] < list[j-1]:
                list[j],list[j-1] = list[j-1],list[j]
            else:
                break
    return list

选择排序 

def select_sort(rlist):
    list1 = []
    for i in range(len(rlist)):
        smaller = rlist[i]
        for j in range(i+1, len(rlist)):
            if rlist[j] < smaller:
                smaller = rlist[j]
        list1.append(smaller)
    return list1

快速排序

以第一个数为基准，从前后外寻找大于基准的，从后往前寻找小于基准的，交换

当相邻数字进行交换后，基准再与较小的相邻数交换

然后递归二分

def quick_sort(rlist):
    if len(rlist) <= 1:
        return rlist
    else:
        low = []
        big = []
        key = rlist[0]
        for i in rlist[1:]:
            if i < key:
                low.append(i)
            else:
                big.append(i)
    return quick_sort(low) + [key] + quick_sort(big)
 

 

归并排序

一组空了以后把另一组全部接入

 

奇偶排序    

转换成二进制，判断01

bin是将整型转换为二进制数组成的字符串，注意它的结果是个字符串

 

 

判断链表是否具有回环：

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head:
            return False
        #定义快慢指针
        fast = slow = head
        #快指针走得快，如果没有环的话，一定会先走到末尾的空指针处
        while fast and fast.next:
            #慢指针一次走一步
            slow = slow.next
            #快指针一次走两步（因为我们已经判断过一步后的节点不是空了，不用担心会报Node没有next属性的错误）
            fast = fast.next.next
            #如果快指针能够追上慢指针，就说明链表有环
            if fast == slow:
                return True
        
        return False

 

 

链表反转

https://blog.csdn.net/weixin_39561100/article/details/79818949?utm_source=blogxgwz6

class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if pHead == None or pHead.next == None:
            return pHead  
        cur = pHead 
        tmp = None
        newhead = None  
        while cur:  
            tmp = cur.next   
            cur.next = newhead  
            newhead = cur
            cur = tmp  
        return newhead
 

循环反转单链表

循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可