Sinde1992的博客

优化算法有很多，经典算法包括：有线性规划，动态规划等；改进型局部搜索算法包括爬山法，最速下降法等，模拟退火、遗传算法以及禁忌搜索称作指导性搜索法。而神经网络，混沌搜索则属于系统动态演化方法。梯度为基础的传统优化算法具有较高的计算效率、较强的可靠性、比较成熟等优点，是一类最重要的、应用最广泛的优化算法。但是，传统的最优化方法在应用于复杂、困难的优化问题时有较大的局限性。一个优化问题称为是复杂的，通常是

# coding=utf-8class ListNode(): def __init__(self, x): # 定义链表节点 self.val = x self.next = Nonedef findcommon(p1, p2): n1 = Getlength(p1) n2 = Getlength(p2) n3 = abs(n

# coding=utf-8def GetnumK(data,k): number=0 length=len(data) if data==None and length>0: first=Getfirstk(data,length,k,0,length-1) last=Getlastk(data,length,0,length-1)

# coding=utf-8'''输入一个递增排序的数组和一个数字s，在数组中查找两个数，使他们的和正好时s思路：两个指针分别指向头尾，第一个和最后一个数字相加和s判断大小，大的尾指针渐渐'''def Findsum(arry,s): if arry==None or len(arry)0 or arry[-1]+arry[-2]<s: return []

# coding=utf-8#左旋转就是分成两部分，完成3次反转即可def leftrotate(s,n): if len(s)0 or len(s)or n0: return '' strlist=list(s) strlist=reverse(strlist) length=len(s) p=length-n frontlis

# coding=utf-8def continus(number): if number==None or len(number)0: return 0 trans={'A':1,'J':11,'Q':12,'k':13} for i in range(len(number)):#转换 if number[i] in trans.keys

# coding=utf-8def lastdelete(n,m): if n1 and m1: return -1 index=0 for i in range(1,n+1): index=(index+m)%i#f[i] = (f[i-1] + m) % i 约瑟环 return indexif __name__ == '

# coding=utf-8# 不用加减乘除实现两数相加def add(num1,num2): while num2: sum=num1^num2#异或 carry=(num1&num2)1#位与再右移得到进位 num1=sum num2=carry return num1print(add(2,4))

# coding=utf-8def findnumber(lists,num): i=0 j=len(lists)-1 mid=int(len(lists)/2) if lists[mid]>num: j=mid-1 findnumber(lists[:mid-1],num) elif list[mid]<num:

插入排序包括直接插入排序和希尔排序选择排序包括直接选择排序和推排序交叉排序包括冒泡排序和快排本文用python实现了插入、希尔、直接选择、堆、冒泡、归并、基排序http://python.jobbole.com/82270/# coding=utf-8# 插入排序，插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部

# coding=utf-8def firstnum(s): if s==None or len(s)==0: return -1 alphapet={}#定义一个空字典 alist=list(s)#将字符串放到列表里 for item in alist: if item not in alphapet.keys():

# coding=utf-8#打印第N个丑数def getugly(index): if index0: return 0 uglyNumber=[1]*index nextindex=1 index2=0 index3=0 index5=0 while nextindex<index: minval=mi

定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时

一、 递归版本1、算法简述简单地说：就是第一个数分别以后面的数进行交换E．g：E = （a , b , c），则 prem（E）= a.perm（b,c）+ b.perm（a,c）+ c.perm（a,b）然后a.perm（b,c）= ab.perm（c）+ ac.perm（b）= abc + acb.依次递归进行好了，知道算法之后就不难编出一份好的代码了。2、代码参考1 Foo(cons

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想—-分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。总的说来，要直接默写出快速排序还是有一定难度的，因为本人就自己的理解对快速排序作了下白话解释，希望对大家理解有帮助，达到快速排序，快速搞定

1.基本数据结构 栈，先进后出，单向队列，先进先出。 栈实现：一个数组，一个计数器，用于记录栈顶元素的坐标。进栈，计数器加1，退栈，计数器减1.单向队列实现：一个数组，一个头指针，一个尾指针。头指针指向队头，尾指针指向队尾。入队，尾指针向后移动一个单位，出队，头指针移动一个单位。双向队列实现：两个栈，可以想象一下两个量筒里的球。接

1. 插入排序(1) 直接插入排序void StraightInsertionSort(std::vectorint>& num) { if (num.size() == 0 || num.size() == 1) return; for (int i = 1; i < num.size(); ++i) { int tmp = num.at(i);

# coding=utf-8#输入一个正整数数组，把数组里所有数字拼起来排成一个数，# offer33.打印能拼接出的所有数字中最小的一个#思路：先把数组转成字符串，然后冒泡排序def minNum(arry): if arry==None or len(arry)0: return '' strNum=[str(m) for m in arry]

#coding=utf-8'''offer29--最开始保存两个数值：数组中的一个数字以及它出现的次数，然后遍历，如果下一个数字等于这个数字，那么次数加一，如果不等，次数减一，当次数等于0的时候，在下一个数字的时候重新复制新的数字以及出现的次数置为1，直到进行到最后，然后再验证最后留下的数字是否出现次数超过一半，因为可能前面的次数依次抵消掉，最后一个数字就直接是保留下来的数字，但是出现次数不一

# coding=utf-8# O(nlogk)的算法, 适合海量数据# 利用一个k容量的容器存放数组, 构造最大堆, 当下一个数据大于最大数, 跳过,# 小于最大数, 则进入容器替换之前的最大数from offer import build, adjustdef getk(data, k): if data is None or len(data) or k 0:

# coding=utf-8#连续子数组的最大和def Findgreat(arry): if arry==None or len(arry)0: return 0 msum=0 nsum=arry[0] for i in range(len(arry)): if msum0: msum=arry[i]

# coding=utf-8class Listcode: def __init__(self,x): self.val=x self.next=Noneclass Solution: def Merge(self,head1,head2): if head1==None: return head2