算法题汇总

1、快速排序

2、IP的有效值是1.0.0.1~255.255.255.255，写个程序参数是char*的IP,返
回IP是否合法
提示：IP不超过4位，是否每一位都在合法范围，是否包含非法字符

3、一个字符串数组char*A[]={'china','chinese',chese',...},求这个数
组中字符串的最长公共前缀

4、求两个字符串的最大公共子串，例：‘abcdefg’和 ‘zxdef’最长公共
子串为‘def’

def find_lcsubstr(s1, s2):

  m = [[ 0 for i in range ( len (s2) + 1 )] for j in range ( len (s1) + 1 )] #生成0矩阵，为方便后续计算，比字符串长度多了一列

  mmax = 0  #最长匹配的长度

  p = 0 #最长匹配对应在s1中的最后一位

  for i in range ( len (s1)):

  for j in range ( len (s2)):

   if s1[i] = = s2[j]:

   m[i + 1 ][j + 1 ] = m[i][j] + 1

   if m[i + 1 ][j + 1 ]>mmax:

    mmax = m[i + 1 ][j + 1 ]

    p = i + 1

  return s1[p - mmax:p],mmax  #返回最长子串及其长度   

print find_lcsubstr( 'abcdfg' , 'abdfg' )

 

 

 

#最长公共序列

import numpy

def find_lcseque(s1, s2):

  # 生成字符串长度加1的0矩阵，m用来保存对应位置匹配的结果

  m = [ [ 0 for x in range ( len (s2) + 1 ) ] for y in range ( len (s1) + 1 ) ]

  # d用来记录转移方向

  d = [ [ None for x in range ( len (s2) + 1 ) ] for y in range ( len (s1) + 1 ) ]   

  for p1 in range ( len (s1)):

  for p2 in range ( len (s2)):

   if s1[p1] = = s2[p2]:      #字符匹配成功，则该位置的值为左上方的值加1

   m[p1 + 1 ][p2 + 1 ] = m[p1][p2] + 1

   d[p1 + 1 ][p2 + 1 ] = 'ok'    

   elif m[p1 + 1 ][p2] > m[p1][p2 + 1 ]: #左值大于上值，则该位置的值为左值，并标记回溯时的方向

   m[p1 + 1 ][p2 + 1 ] = m[p1 + 1 ][p2]

   d[p1 + 1 ][p2 + 1 ] = 'left'    

   else :              #上值大于左值，则该位置的值为上值，并标记方向up

   m[p1 + 1 ][p2 + 1 ] = m[p1][p2 + 1 ] 

   d[p1 + 1 ][p2 + 1 ] = 'up'    

  (p1, p2) = ( len (s1), len (s2))

  print numpy.array(d)

  s = []

  while m[p1][p2]:  #不为None时

  c = d[p1][p2]

  if c = = 'ok' :  #匹配成功，插入该字符，并向左上角找下一个

   s.append(s1[p1 - 1 ])

   p1 - = 1

   p2 - = 1

  if c = = 'left' : #根据标记，向左找下一个

   p2 - = 1

  if c = = 'up' :  #根据标记，向上找下一个

   p1 - = 1

  s.reverse()

  return ''.join(s)

print find_lcseque( 'abdfg' , 'abcdfg' )

 

5、单向链表反序

6、多个已序数组交集

7、遍历二叉树

8、对一篇文章中的单词按字母顺序排序

9、找出字符串里第一个重复出现的字符‘afdgdfdadfg’

10、对一个版本的字符串比较大小：1.2.2，1.0.1，1.3.2，排序

11、字符串‘welcom to tidn&di’，编码输出其中的‘tidndi’

第一种方法：

 t='welcome to tidn&di'

r='tidndi'

e=t[11:]

w=e.replace('&','')
print(w)

第二种方法：

w=t[11:15]+t[16:] 

print(w)

 

#冒泡排序
def sot(x):
    for i in range(len(x)-1):
        for j in range(len(x)-1-i):
            if x[j]>x[j+1]:
                x[j],x[j+1]=x[j+1],x[j]
    return x

#选择排序
def sot(x):
    for i in range(len(x)):
        min=i
        for j in range(i+1,len(x)):
            if x[i]>x[j]:
                min=j
        t = x[min]
        x[min] = x[i]
        x[i] = t

#插入排序
def sot(x):
    for i in range(1,len(x)):
        j=i-1
        while j>=0:
            if x[j]>x[j+1]:
                x[j],x[j+1]=x[j+1],x[j]
                j=j-1
            else:
                break
    return x

 

#快速排序(待确定)
def sot(x):
    for i in range(1,len(x)):
        key=x[i]
        j=i-1
        while j>=0:
            if x[j]>key:
                x[j+1]=x[j]
                x[j]=key
                j=j-1
            else:
                break
    return x

#快速排序
def partion(nums,left,right):
    key = nums[left]
    while left < right:
        # right下标位置开始，向左边遍历，查找不大于基准数的元素
        while left < right and nums[right] >= key:
            right -= 1
        if left < right:  # 找到小于准基数key的元素,然后交换nums[left],nums[right]
            nums[left],nums[right] = nums[right],nums[left]
        else:   # left〉=right 跳出循环
            break
        # left下标位置开始，向右边遍历，查找不小于基准数的元素
        while left < right and nums[left] < key:
            left += 1
        if left < right:  # 找到比基准数大的元素，然后交换nums[left],nums[right]
            nums[right],nums[left] = nums[left],nums[right]
        else: # left〉=right 跳出循环
            break
    return left  #此时left==right 所以返回right也是可以的
def quick_sort_standord(nums,left,right):
    if left < right:
        key_index = partion(nums,left,right)
        quick_sort_standord(nums,left,key_index)
        quick_sort_standord(nums,key_index+1,right)
if __name__ == '__main__':
    nums = [5, 6, 4, 2, 3,1]
    print nums
    quick_sort_standord(nums,0,len(nums)-1)
    print nums

转载于:https://www.cnblogs.com/jiaoxiaohui/p/10640465.html