首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >剑指Offer 1-22题(Python版)

剑指Offer 1-22题(Python版)

作者头像
小一
发布于 2019-08-14 07:51:59
发布于 2019-08-14 07:51:59
46100
代码可运行
举报
文章被收录于专栏:谓之小一谓之小一
运行总次数:0
代码可运行
1.二维数组中的查找

题目: 在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。

思路:遍历每一行,查找该元素是否在该行之中。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        for line in array:
            if target in line:
                return True
        return False

if __name__=='__main__':
    target=2
    array=[[1,2,3,4],[2,3,4,5],[3,4,5,6],[4,5,6,7]]
    solution=Solution()
    ans=solution.Find(target,array)
    print(ans)

2.替换空格

题目: 请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

思路:利用字符串中的replace直接替换即可。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        temp = s.replace(" ", "%20")
        return temp

if __name__=='__main__':
    s='We Are Happy'
    solution=Solution()
    ans=solution.replaceSpace(s)
    print(ans)

3.从尾到头打印链表

题目:输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。

思路:将链表中的值记录到list之中,然后进行翻转list。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        l=[]
        while listNode:
            l.append(listNode.val)
            listNode=listNode.next
        return l[::-1]

if __name__=='__main__':
    A1 = ListNode(1)
    A2 = ListNode(2)
    A3 = ListNode(3)
    A4 = ListNode(4)
    A5 = ListNode(5)

    A1.next=A2
    A2.next=A3
    A3.next=A4
    A4.next=A5

    solution=Solution()
    ans=solution.printListFromTailToHead(A1)
    print(ans)

4.重建二叉树

题目:输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。

题解:首先前序遍历的第一个元素为二叉树的根结点,那么便能够在中序遍历之中找到根节点,那么在根结点左侧则是左子树,假设长度为M.在根结点右侧,便是右子树,假设长度为N。然后在前序遍历根节点后面M长度的便是左子树的前序遍历序列,再后面的N个长度便是右子树的后序遍历的长度。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre)==0:
            return None
        if len(pre)==1:
            return TreeNode(pre[0])
        else:
            flag=TreeNode(pre[0])
            flag.left=self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
            flag.right=self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
        return flag

if __name__=='__main__':
    solution=Solution()
    pre=list(map(int,input().split(',')))
    tin=list(map(int,input().split(',')))
    ans=solution.reConstructBinaryTree(pre,tin)
    print(ans.val)

5.用两个栈实现队列

题目:用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。

题解:申请两个栈Stack1和Stack2,Stack1当作输入,Stack2当作pop。当Stack2空的时候,将Stack1进行反转,并且输入到Stack2。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.Stack1=[]
        self.Stack2=[]
    def push(self, node):
        # write code here
        self.Stack1.append(node)
    def pop(self):
        # return xx
        if self.Stack2==[]:
            while self.Stack1:
                self.Stack2.append(self.Stack1.pop())
            return self.Stack2.pop()
        return self.Stack2.pop()

if __name__=='__main__':
    solution = Solution()
    solution.push(1)
    solution.push(2)
    solution.push(3)
    print(solution.pop())

6.旋转数组的最小数字

题目:把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个非减排序的数组的一个旋转,输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。

题解:遍历数组寻找数组最小值。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        minnum=999999
        for i in range(0,len(rotateArray)):
            if minnum>rotateArray[i]:
                minnum=rotateArray[i]
        if minnum:
            return minnum
        else:
            return 0

if __name__=='__main__':
    solution=Solution()
    rotateArray=list(map(int,input().split(',')))
    ans=solution.minNumberInRotateArray(rotateArray)
    print(ans)

7.斐波那契数列

题目:大家都知道斐波那契数列,现在要求输入一个整数n,请你输出斐波那契数列的第n项。n<=39。

题解:递归和非递归方法。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def Fibonacci(self, n):
        # write code here
        if n==0:
            return 0
        if n==1:
            return 1
        Fib=[0 for i in range(0,n+1)]
        Fib[0],Fib[1]=0,1
        for i in range(2,n+1):
            Fib[i]=Fib[i-1]+Fib[i-2]
        return Fib[n]
    def Fibonacci1(self,n):
        if n==0:
            return 0
        if n==1 or n==2:
            return 1
        else:
            return self.Fibonacci1(n-1)+self.Fibonacci1(n-2)

if __name__=='__main__':
    solution=Solution()
    n=int(input())
    ans=solution.Fibonacci1(n)
    print(ans)

8.跳台阶

题目:一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。

题解:ans[n]=ans[n-1]+ans[n-2]

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Solution:
    def jumpFloor(self, number):
        # write code here
        if number==0:
            return 0
        if number==1:
            return 1
        if number==2:
            return 2
        ans=[0 for i in range(0,number+1)]
        ans[1],ans[2]=1,2
        for i in range(3,number+1):
            ans[i]=ans[i-1]+ans[i-2]
        return ans[number]


if __name__ == '__main__':
    solution = Solution()
    n=int(input())
    ans=solution.jumpFloor(n)
    print(ans)

9.变态跳台阶

题目:一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

题解:ans[n]=ans[n-1]+ans[n-2]+ans[n-3]+...+ans[n-n],ans[n-1]=ans[n-2]+ans[n-3]+...+ans[n-n],ans[n]=2*ans[n-1]。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        if number==1:
            return 1
        if number==2:
            return 2
        return 2*self.jumpFloorII(number-1)

if __name__=='__main__':
    solution=Solution()
    n=int(input())
    ans=solution.jumpFloorII(n)
    print(ans)

10.矩形覆盖

题目:我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形,总共有多少种方法?

题解:新增加的小矩阵竖着放,则方法与n-1时相同,新增加的小矩阵横着放,则方法与n-2时相同,于是f(n)=f(n-1)+f(n-2)。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        # write code here
        if number==0:
            return 0
        if number==1:
            return 1
        Fib=[0 for i in range(0,number+1)]
        Fib[1],Fib[2]=1,2
        for i in range(3,number+1):
            Fib[i]=Fib[i-1]+Fib[i-2]
        return Fib[number]

if __name__=='__main__':
    solution=Solution()
    n=int(input())
    ans=solution.rectCover(n)
    print(ans)

11.二进制中1的个数

题目:输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

题解:每次进行左移一位,然后与1进行相与,如果是1则进行加1。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        count = 0
        for i in range(32):
            count += (n >> i) & 1
        return count

if __name__=='__main__':
    solution=Solution()
    n=int(input())
    ans=solution.NumberOf1(n)
    print(ans)

12.数值的整次方

题目:给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        ans=1
        for i in range(0,abs(exponent)):
            ans=ans*base
        if exponent>0:
            return ans
        else:
            return 1/ans

if __name__=='__main__':
    solution=Solution()
    base=float(input())
    exponent=int(input())
    ans=solution.Power(base,exponent)
    print(ans)

13.调整数组顺序使奇数位于偶数前面

题目:输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。

题解:申请奇数数组和偶数数组,分别存放奇数值和偶数值,数组相加便为结果。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        array1=[]#奇数
        array2=[]#偶数

        for i in range(0,len(array)):
            if array[i]%2!=0:
                array1.append(array[i])
            else:
                array2.append(array[i])
        ans=array1+array2
        return ans

if __name__=='__main__':
    solution=Solution()
    array=list(map(int,input().split(',')))
    ans=solution.reOrderArray(array)
    print(ans)

14.链表中倒数第K个节点

题目:输入一个链表,输出该链表中倒数第k个结点。

题解:反转链表,寻找第K个节点。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        #反转链表
        if head is None or head.next is None:
            return head
        pre=None #指向上一个节点
        while head:
            #先用temp保存当前节点的下一个节点信息
            temp=head.next
            #保存好next之后,便可以指向上一个节点
            head.next=pre
            #让pre,head指向下一个移动的节点
            pre=head
            head=temp
        # 寻找第K个元素的位置
        for i in range(1,k):
            pre=pre.next
        temp=pre
        return temp

if __name__=='__main__':
    solution=Solution()
    k=3
    p1=ListNode(1)
    p2=ListNode(2)
    p3=ListNode(3)
    p4=ListNode(4)
    p1.next=p2
    p2.next=p3
    p3.next=p4

    ans=solution.FindKthToTail(p1,k)
    print(ans.val)

15.反转链表

题目:输入一个链表,反转链表后,输出新链表的表头。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if pHead is None or pHead.next is None:
            return pHead
        pre=None
        while pHead:
            #暂存当前节点的下一个节点信息
            temp=pHead.next
            #反转节点
            pHead.next=pre
            #进行下一个节点
            pre = pHead
            pHead=temp
        return pre

if __name__=='__main__':
    solution=Solution()
    p1=ListNode(1)
    p2=ListNode(2)
    p3=ListNode(3)
    p1.next=p2
    p2.next=p3
    ans=solution.ReverseList(p1)
    print(ans.val)

16.合并两个排序的列表

题目:输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

题解:将两个链表之中的数值转换到列表之中,并进行排序,将排序后的列表构造成链表。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    # 返回合并后列表
    def Merge(self,pHead1,pHead2):
        # write code here
        if pHead1 is None and pHead2 is None:
            return None
        num1,num2=[],[]
        while pHead1:
            num1.append(pHead1.val)
            pHead1=pHead1.next
        while pHead2:
            num2.append(pHead2.val)
            pHead2=pHead2.next
        ans=num1+num2
        ans.sort()
        head=ListNode(ans[0])
        pre=head
        for i in range(1,len(ans)):
            node=ListNode(ans[i])
            pre.next=node
            pre=pre.next
        return head

if __name__=='__main__':
    solution=Solution()
    pHead1_1 = ListNode(1)
    pHead1_2 = ListNode(3)
    pHead1_3 = ListNode(5)
    pHead1_1.next=pHead1_2
    pHead1_2.next=pHead1_3

    pHead2_1 = ListNode(2)
    pHead2_2 = ListNode(4)
    pHead2_3 = ListNode(6)
    pHead2_1.next=pHead2_2
    pHead2_2.next=pHead2_3
    ans=solution.Merge(pHead1_1,pHead2_1)
    print(ans)

17.树的子结构

题目:输入两棵二叉树A,B,判断B是不是A的子结构。(ps:我们约定空树不是任意一个树的子结构)。

题解:将树转变为中序序列,然后转变为str类型,最后判断是否包含。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if pRoot1 is None or pRoot2 is None:
            return False
        pRoot1_result,pRoot2_result=[],[]
        self.order_traversal(pRoot1,pRoot1_result)
        self.order_traversal(pRoot2,pRoot2_result)
        str1=''.join(str(i) for i in pRoot1_result)
        str2=''.join(str(i) for i in pRoot2_result)
        print(str1,str2)
        if str2 in str1:
            return True
        else:
            return False

    def order_traversal(self,root,result):
        if not root:
            return
        self.order_traversal(root.left,result)
        result.append(root.val)
        self.order_traversal(root.right,result)

if __name__=='__main__':
    solution=Solution()
    pRootA1 = TreeNode(1)
    pRootA2 = TreeNode(2)
    pRootA3 = TreeNode(3)
    pRootA4 = TreeNode(4)
    pRootA5 = TreeNode(5)
    pRootA1.left=pRootA2
    pRootA1.right=pRootA3
    pRootA2.left=pRootA4
    pRootA2.right=pRootA5

    pRootB2 = TreeNode(2)
    pRootB4 = TreeNode(4)
    pRootB5 = TreeNode(5)
    pRootB2.left=pRootB4
    pRootB2.right = pRootB5
    ans=solution.HasSubtree(pRootA1,pRootB2)
    print(ans)

18.二叉树的镜像

题目: 操作给定的二叉树,将其变换为源二叉树的镜像。

输入描述:

源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ 11 9 7 5

思路:递归实现反转每个子节点

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        # A1_order_result=[]
        # self.order_traversal(A1,A1_order_result)
        if root is None:
            return
        if root.left is None and root.right is None:
            return
        temp=root.left
        root.left=root.right
        root.right=temp

        if root is not None:
            self.Mirror(root.left)
        if root is not None:
            self.Mirror(root.right)

    def order_traversal(self,root,result):
        if not root:
            return
        self.order_traversal(root.left,result)
        result.append(root.val)
        self.order_traversal(root.right,result)

if __name__=='__main__':
    A1 = TreeNode(8)
    A2 = TreeNode(6)
    A3 = TreeNode(10)
    A4 = TreeNode(5)
    A5 = TreeNode(7)
    A6 = TreeNode(9)
    A7 = TreeNode(11)
    A1.left=A2
    A1.right=A3
    A2.left=A4
    A2.right=A5
    A3.left=A6
    A3.right=A7

    temp1=[]
    solution=Solution()
    solution.order_traversal(A1,temp1)
    print(temp1)
    solution.Mirror(A1)
    solution.order_traversal(A1,temp1)
    print(temp1)

19.顺时针打印矩阵

题目:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,
例如,如果输入如下矩阵:
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 16
则依次打印出数字
1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路:每次打印圈,但要判断最后一次是打印横还是竖,另外判断数据是否已存在。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        m,n=len(matrix),len(matrix[0])
        res = []
        if n==1 and m==1:
            res.append(matrix[0][0])
            return res
        for k in range(0,(min(m,n)+1)//2):
            [res.append(matrix[k][i]) for i in range(k, n - k)]
            [res.append(matrix[j][n-k-1]) for j in range(k,m-k) if matrix[j][n-k-1] not in res]
            [res.append(matrix[m-k-1][j]) for j in range(n-k-1,k-1,-1) if matrix[m-k-1][j] not in res]
            [res.append(matrix[j][k]) for j in range(m-1-k,k-1,-1) if matrix[j][k] not in res]
        return res

if __name__=='__main__':
    solution=Solution()
    m,n=1,5
    matrix=[]
    for i in range(0,m):
        matrix.append(list(map(int,input().split(' '))))
    print(matrix)
    ans=solution.printMatrix(matrix)
    print(ans)

20.包含Min函数的栈

题目:定义栈的数据结构,请在该类型中实现一个能够得到栈中所含最小元素的min函数。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.num=[]
    def push(self, node):
        # write code here
        self.num.append(node)
    def pop(self):
        # write code here
        self.num.pop()
    def top(self):
        # write code here
        numlen = len(self.num)
        return self.num[numlen-1]
    def min(self):
        # write code here
        return min(self.num)

if __name__=='__main__':
    solution = Solution()
    solution.push(1)
    solution.push(2)
    solution.push(3)
    solution.push(4)
    solution.pop()
    print(solution.top())
    print(solution.min())

21.栈的压入弹出序列

题目:输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序,序列4,5,3,2,1是该压栈序列对应的一个弹出序列,但4,3,5,1,2就不可能是该压栈序列的弹出序列。(注意:这两个序列的长度是相等的)。

题解:新构建一个中间栈,来模拟栈的输入和栈的输出,比对输入结果和输出结果是否相等。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        if len(pushV)==1 and len(popV)==1 and pushV[0]!=popV[0]:
            return False

        helpV=[]
        pushV.reverse()
        popV.reverse()
        #模拟给定栈的压入和压出
        helpV.append(pushV[len(pushV)-1])
        pushV.pop()
        while True:
            if helpV[len(helpV)-1]!=popV[len(popV)-1]:
                helpV.append(pushV[len(pushV)-1])
                pushV.pop()

            if helpV[len(helpV)-1]==popV[len(popV)-1]:
                helpV.pop()
                popV.pop()

            if pushV==[] and popV==[] and helpV==[]:
                return True

            if pushV==[] and popV[len(popV)-1]!=helpV[len(helpV)-1]:
                return False


if __name__=='__main__':
    solution=Solution()
    push=list(map(int,input().split(' ')))
    pop=list(map(int,input().split(' ')))
    ans=solution.IsPopOrder(push,pop)
    print(ans)

22.从上往下打印二叉树

题目:从上往下打印出二叉树的每个节点,同层节点从左至右打印。

思路:递归,每次将左子树结果和右子树结果存到结果集之中。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    # 返回从上到下每个节点值列表,例:[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        if root is None:
            return []
        ans=[]
        ans.append(root.val)
        self.orderans(root,ans)
        return ans

    def orderans(self,root,ans):
        if not root:
            return
        if root.left:
            ans.append(root.left.val)
        if root.right:
            ans.append(root.right.val)

        self.orderans(root.left, ans)
        self.orderans(root.right,ans)

if __name__=='__main__':
    solution=Solution()
    A1 = TreeNode(1)
    A2 = TreeNode(2)
    A3 = TreeNode(3)
    A4 = TreeNode(4)
    A5 = TreeNode(5)

    A1.left=A2
    A1.right=A3
    A2.left=A4
    A2.right=A5
    ans=solution.PrintFromTopToBottom(A1)
    print(ans)

你看到的这篇文章来自于公众号「谓之小一」,欢迎关注我阅读更多文章。

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2018-08-16,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 谓之小一 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
shapely.geometry.polygon 实现任意两个四边形的IOU计算
来源为华中科技大学白翔老师。import numpy as np import shapelyfrom shapely.geometry import Polygon,MultiPoint #多边形 line1=[2,0,2,2,0,0,0,2] #四边形四个点坐标的一维数组表示,[x,y,x,y....]a=np.array(line1).reshape(4, 2) #四边形二维坐标表示poly1 = Polygon(a).convex_hull #python四边形对象,会自动计算四个点,最
狼啸风云
2021/05/10
2K0
[1025]python地理处理包shapely
github:https://github.com/Toblerity/Shapely
周小董
2021/07/20
4.8K0
[1025]python地理处理包shapely
(数据科学学习手札74)基于geopandas的空间数据分析——数据结构篇
geopandas是建立在GEOS、GDAL、PROJ等开源地理空间计算相关框架之上的,类似pandas语法风格的空间数据分析Python库,其目标是尽可能地简化Python中的地理空间数据处理,减少对Arcgis、PostGIS等工具的依赖,使得处理地理空间数据变得更加高效简洁,打造纯Python式的空间数据处理工作流。本系列文章就将围绕geopandas及其使用过程中涉及到的其他包进行系统性的介绍说明,每一篇将尽可能全面具体地介绍geopandas对应方面的知识,计划涵盖geopandas的数据结构、投影坐标系管理、文件IO、基础地图制作、集合操作、空间连接与聚合。   作为基于geopandas的空间数据分析系列文章的第一篇,通过本文你将会学习到geopandas中的数据结构。 geopandas的安装和使用需要若干依赖包,如果不事先妥善安装好这些依赖包而直接使用pip install geopandas或conda install geopandas可能会引发依赖包相关错误导致安装失败,官方文档中的推荐安装方式为:
Feffery
2020/02/15
3K0
模拟量差分和单端(iou计算方法)
人工修正后的每一个框与算法输出的所有框去计算IOU,取出IOU大于0.9的算法输出框
全栈程序员站长
2022/07/31
5980
模拟量差分和单端(iou计算方法)
30分钟学会shapely空间几何分析
shapely是python中开源的空间几何对象库,支持Point(点),LineString(线), Polygon(面)等几何对象及相关空间操作。
lyhue1991
2021/03/17
4.5K0
30分钟学会shapely空间几何分析
讲解python多边形裁剪
在计算机图形学中,多边形裁剪是一个常用的技术,用于确定多边形与给定裁剪窗口之间的交集。通过裁剪,我们可以剔除不在裁剪窗口范围内的部分,从而减少图形处理的计算量,并加速渲染过程。 Python提供了各种库和算法来实现多边形裁剪。在本篇文章中,我们将使用shapely库来进行多边形的裁剪操作。shapely是一个Python库,提供了一些用于处理几何图形数据的功能。
大盘鸡拌面
2023/12/26
6360
(数据科学学习手札84)基于geopandas的空间数据分析——空间计算篇(上)
  在本系列之前的文章中我们主要讨论了geopandas及其相关库在数据可视化方面的应用,各个案例涉及的数据预处理过程也仅仅涉及到基础的矢量数据处理。在实际的空间数据分析过程中,数据可视化只是对最终分析结果的发布与展示,在此之前,根据实际任务的不同,需要衔接很多较为进阶的空间操作,本文就将对geopandas中的部分空间计算进行介绍。
Feffery
2020/05/25
4.2K0
(数据科学学习手札84)基于geopandas的空间数据分析——空间计算篇(上)
geopandas 0.14版本重要更新内容一览
大家好我是费老师,就在前两天,Python生态中的GIS运算神器geopandas发布了其0.14.0新版本,在这次新版本更新中,不仅是新增了许多矢量计算API,还开始为日后正式发布1.0版本做准备,对一些底层依赖版本进行改动。今天的文章中,我就将为大家一一介绍相关的更新内容:
派大星的数据屋
2023/09/18
4090
geopandas 0.14版本重要更新内容一览
(数据科学学习手札154)geopandas 0.14版本新特性一览
  大家好我是费老师,就在前两天,Python生态中的GIS运算神器geopandas发布了其0.14.0新版本,在这次新版本更新中,不仅是新增了许多矢量计算API,还开始为日后正式发布1.0版本做准备,对一些底层依赖版本进行改动。今天的文章中,我就将为大家一一介绍相关的更新内容:
Feffery
2023/09/18
4490
(数据科学学习手札154)geopandas 0.14版本新特性一览
Part3-1.获取高质量的阿姆斯特丹建筑立面图像(附完整代码)
本文为《通过深度学习了解建筑年代和风格》论文复现的第三部分——获取阿姆斯特丹高质量街景图像的上篇,主要讲了如何获取利用谷歌街景地图自动化获取用于深度学习的阿姆斯特丹的高质量街景图像,此数据集将用于进行建筑年代的模型训练[1]。
renhai
2023/11/24
9660
Part3-1.获取高质量的阿姆斯特丹建筑立面图像(附完整代码)
geopandas:Python绘制数据地图
GeoPandas是一个Python开源项目,旨在提供丰富而简单的地理空间数据处理接口。 GeoPandas扩展了Pandas的数据类型,并使用matplotlib进行绘图。GeoPandas官方仓库地址为:GeoPandas。 GeoPandas的官方文档地址为:GeoPandas-doc。 本文主要参考GeoPandas Examples Gallery。 GeoPandas的基础使用见Python绘制数据地图1-GeoPandas入门指北。 GeoPandas的可视化入门见Python绘制数据地图2-GeoPandas地图可视化。
luckpunk
2023/09/14
4.1K0
geopandas:Python绘制数据地图
(在模仿中精进数据可视化06)常见抽象地图的制作方法
  我们经常会在一些PPT报告或者宣传广告中看到一些比较抽象的地图,它们都是在正常地图的基础上,通过置换几何元素,来实现出较为抽象的效果,这类的作品非常之多,因此本文不模仿实际的某幅作品,而是制作出下面三类抽象地图:
Feffery
2021/01/05
9750
(在模仿中精进数据可视化06)常见抽象地图的制作方法
Google Earth Engine(GEE)——点线面运算及其交集并集等
Earth Engine 支持对Geometry对象的各种操作。这些包括对单个几何图形的操作,例如计算缓冲区、质心、边界框、周长等。例如:
此星光明
2024/02/02
3260
Google Earth Engine(GEE)——点线面运算及其交集并集等
一个R语言中操纵矢量空间数据的标准化工具—sf
摘要 Simple features是一种在计算机中编码矢量空间数据(点、线、面等)的标准化方法。sf包在R语言中引入了simple features对象,它基本具备和sp、rgeos、rgdal一样的矢量空间数据处理能力。本文主要描述此包的基本功能,其在R语言诸多扩展生态系统中的地位,以及在连接R语言与其他空间计算系统中的潜在价值。
数据小磨坊
2019/09/17
4.6K0
一个R语言中操纵矢量空间数据的标准化工具—sf
六、处理几何数据【ArcGIS Python系列】
要素类中的每个要素都由一个或多个顶点组成,这些顶点定义了点、多段线或多边形要素。在点要素类的情况下,每个点要素由单个顶点组成。多段线和多边形要素由多个顶点组成。每个顶点是由一对x、y坐标定义的位置。该图说明了点、多段线和多边形如何在笛卡尔坐标空间中由顶点定义。
renhai
2023/11/24
5850
六、处理几何数据【ArcGIS Python系列】
(数据科学学习手札147)Python GIS利器shapely全新2.0版本一览
  大家好我是费老师,我写过很多篇介绍geopandas相关技术的文章,而geopandas之所以如此高效易用,成为Python GIS生态中的翘楚,离不开其底层依赖库shapely对其矢量计算功能的支持。
Feffery
2022/12/18
9870
(数据科学学习手札147)Python GIS利器shapely全新2.0版本一览
GEE训练教程——如何确定几何形状的中心点坐标和相交的坐标
在GEE中,可以使用.geometry()方法来获取几何形状的中心点坐标和相交的坐标。
此星光明
2024/06/11
3080
GEE训练教程——如何确定几何形状的中心点坐标和相交的坐标
GIS拓扑讲解点线面几何体的拓扑关系判断及运算分析_turf案例
Turf.js是JavaScript  空间分析库,由Mapbox 提供,Turf 实现了
周陆军博客
2023/04/09
2.8K0
spatial4j入门实战
Spatial4j是一款java编写的空间计算开源库,支持ASL开源协议,支持地理空间计算。
doaction
2021/11/18
3.2K0
POSTGIS 总结
PostGIS是一个空间数据库,空间数据库像存储和操作数据库中其他任何对象一样去存储和操作空间对象。
小石头
2022/11/10
6.9K0
POSTGIS 总结
推荐阅读
相关推荐
shapely.geometry.polygon 实现任意两个四边形的IOU计算
更多 >
目录
  • 2.替换空格
  • 3.从尾到头打印链表
  • 4.重建二叉树
  • 5.用两个栈实现队列
  • 6.旋转数组的最小数字
  • 7.斐波那契数列
  • 8.跳台阶
  • 9.变态跳台阶
  • 10.矩形覆盖
  • 11.二进制中1的个数
  • 12.数值的整次方
  • 13.调整数组顺序使奇数位于偶数前面
  • 14.链表中倒数第K个节点
  • 15.反转链表
  • 16.合并两个排序的列表
  • 17.树的子结构
  • 18.二叉树的镜像
  • 19.顺时针打印矩阵
  • 20.包含Min函数的栈
  • 21.栈的压入弹出序列
  • 22.从上往下打印二叉树
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档