链表

 

1.给定一个链表，判断链表中是否有环。

用快慢指针的方法。时间复杂度O(n)，空间复杂度O(1)。

设置p1为慢指针，p2为快指针，两者初始时都指向链表的头结点

慢指针p1每次前进1步，快指针p2每次前进2步。如果链表存在环，则快指针p2肯定先进入环，慢指针p1后进入环，两个指针必定会相遇。

如果不存在环，则快指针会先行到达链表的尾部变为None。

class Node:
    def __init__(self,value):
        self.value = value
        self.next = None
def isLoop(list):
    # p1:慢指针
    p1 =  list
    #p2:快指针
    p2 = list
    #当链表为空或者只有一个结点时，就不执行循环体里的程序，返回False
    while p2 and p2.next:
        p1=p1.next
        p2=p2.next.next
        if p1==p2:
            return True
    return False

if __name__ == "__main__":
    list_obj = Node(3)
    p1 = Node(2)
    p2 = Node(0)
    p3 = Node(4)

    list_obj.next = p1
    p1.next = p2
    p2.next = p3
    p3.next = p2

    print(isLoop(list_obj))

 2.在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

 

示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

 

 

“根节点” 对应的是矩阵的 “左下角” 和 “右上角” 元素，本文称之为 标志数 ，以 matrix 中的 左下角元素 为标志数 flag ，则有:

若 flag > target ，则 target 一定在 flag 所在 行的上方 ，即 flag 所在行可被消去。
若 flag < target ，则 target 一定在 flag 所在 列的右方 ，即 flag 所在列可被消去。

算法流程：

从矩阵 matrix 左下角元素（索引设为 (i, j) ）开始遍历，并与目标值对比：
当 matrix[i][j] > target 时，执行 i-- ，即消去第 i 行元素；
当 matrix[i][j] < target 时，执行 j++ ，即消去第 j 列元素；
当 matrix[i][j] = target 时，返回 truetruetrue ，代表找到目标值。
若行索引或列索引越界，则代表矩阵中无目标值，返回 falsefalsefalse 。

def findNumberIn2DArray(matrix,target):
    (rows,cols)=matrix.shape
    if rows==0 or cols==0:
        return 0
    i=rows-1
    j=0
    while(i>=0 and j<=cols-1):
        print(i,j)
        if (matrix[i][j]>target):
            i-=1
        elif (matrix[i][j]<target):
            j+=1
        else:
            return True
    return False
import numpy as np
matrix=np.array([
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
])

print(findNumberIn2DArray(matrix,10))

 3. 获取单向链表倒数第k个结点的值

设置2个指针p和q都指向head，p先向前移动 k-1 个结点，接着，p，q一起移动，直到q.next = null,此时q指针所指的结点就是要找的结点。

class Node():
    def __init__(self,value):
        self.value=value
        self.next=None
def find(Listnode,k):
    p=Listnode
    q=Listnode
    for i in range(k):
        p=p.next
    print(p.value)
    while p.next:
        p=p.next
        q=q.next
    print(q.value)
    return q.value

node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
node5 = Node(5)
node6 = Node(6)
node7 = Node(7)
node8 = Node(8)
node9 = Node(9)
node10 = Node(10)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5
node5.next = node6
node6.next = node7
node7.next = node8
node8.next = node9
node9.next = node10
find(node1,2)

 4.删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。

class Node():
    def __init__(self,value):
        self.value=value
        self.next=None
def delete_node(Listnode,node):
    p=Listnode
    while p.next and p.next!=node:
        p=p.next
    p.next=p.next.next

node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
node5 = Node(5)

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

delete_node(node1,node3)

print(node2.next.value)