python algorithms mastering basic algorithms in python language

in the code below?# Not O (3) but O (1) print (' Hello World ') print (' Hello Python ') print (' Hello algorithm ') # not O (n2+n) but O (N2) for I in Range (n): Print (' Hello World ') to J in range (n): print (' Hello World ') # not O (1/2n2) but O (N2) for I in Range (n): For J in Ran GE (i): print (' Hello world ')And look at the following code:# time Complexity O (log2n) or O (Logn) while n > 1: print (n) n

Combinatorial algorithms The idea of this program is to open an array whose subscript represents 1 to M, and the value of the array element is 1 to indicate its subscript The number represented is selected, and 0 is not selected. First, the first n elements of the array are set to 1, which indicates the number of top N. The "10" combination of the array element values is then scanned from left to right, and the first "10" combination is found to chan

Fast ordering of Python algorithms #-*-Coding:utf-8-*-from random import randint, shuffle def _partition (seq, p, R): "" "Array division, pseudo code as follows: partition (A, P, R) 1 X←a[r]//As Division Master 2 i←p-1 3 for J←p to r-1 4 do if A[J] 

next time . A the defShufflepile (self): + """in the current state, the tree is adjusted so that it becomes a heap""" - #downward adjustment from "heap bottom" to "heap top", which keeps the smallest elements rising $ #This allows the heap below the I node to be the local minimum heap. $ forIinchRange ((Len (self)-2)/2,-1,-1):#N/2,..., 0 - Self.siftdown (i) - the defdeletemin (self): - """Remove Minimum element"""Wuyit = self[0]#record the

#!/usr/local/python35/bin/python3.5## # # Insert Sortif __name__=="__main__": Var_list=[3,2,4,5,1] """from the second item, start by comparing it to the item in front of it, and if it is smaller than the previous item, go to the front. """ forIndexinchRange (1, Len (var_list)): Key=var_list[index]## Record The value of the second itemI=index-1## Record the subscript of the preceding paragraph whileI>=0 andKey## If the bar is satisfied, move the preceding paragraph backwards and mo

= [2,3,5,7,8,9,6,54,1,42] Print(List1) selectsort (list1)Print(List1)#Hill Sort#The entire sequence of elements to be sorted into a number of sub-sequences (consisting of elements separated by an "increment") for direct insertion sorting#then reduce the increments in turn and then sort the#when the elements in the entire sequence are basically ordered (the increment is small enough), then the whole element is sorted in a direct insert. defShellsort (data,flag):" ":p Aram Data:list, to be sort

Bubble Sort:defbubble_sort (lists):#Bubble SortCount =len (lists) forIinchRange (0, count): forJinchRange (i + 1, count):ifLists[i] >Lists[j]:#判断后值是否比前置大, if the big exchange it lists[i], Lists[j]=Lists[j], Lists[i]returnListsres=bubble_sort ([1,209,31,4,555,6,765,9,5,4,7,89,6,5,34,3,57,96])Print(RES)Quick sort:defquick_sort (lists, left, right):#Quick Sort ifLeft >=Right :returnlists key=Lists[left] Low= left High= Right whileLeft Right : whileLeft andLists[right] >=Key:right-= 1Lists[left]

Code:#Coding:utf-8#Author: Xubling#swap sort. Bubble sortL = [1, 3, 2, 32, 5, 4]defBubble_sort (L): forIinchRange (len (L)): forJinchRange (i+1, Len (L)):ifL[i]>L[j]:#temp = l[j] #L[j] = l[i] #L[i] = tempL[i], l[j] = L[j], l[i]#Exchange Order PrintLbubble_sort (L)The bubble sort should be the most familiar sort algorithm, so basically write this algorithm without encountering any problems. It is worth noting that the order in which two numbers are exchanged in

#Coding=utf-8 # 1 Quick sort algorithm defQksort (list):ifLen (list) : returnListElse: Pivot=List[0] Less=[x forXinchList[1:]ifxPivot] Greater=[y forYinchList[1:]ify>=Pivot]returnQksort (less) +[pivot]+Qksort (Greater) Q=[1,3,8,3,2,6,5,3,5,7]t=Qksort (q)Print(t)#Coding=utf-8 # 2 Insert sort algorithm defInsection_sort (list): N=len (list) forIndexinchRange (1, N): J=index-1value=List[index] whilej>=0:ifvalueList[j]: list[j+1]=List[j] List[j]=valueElse : BreakJ=j-1returnL

classGraph:def __init__(self): self. V= []classVertex:def __init__(self, x): Self.key=x Self.color=' White'SELF.D= 10000SELF.F= 10000Self.pi=None Self.adj=[] Self.next=NoneclassSolution:defDfs (Self, G): forUinchG.v:u.color=' White'U.pi=NoneGlobal Time Time=0 forUinchG.V:ifU.color = =' White': Self. Dfsvisit (G, u)defdfsvisit (self, G, u):Global Time Time= time + 1U.D=Time U.color='Gray' forVinchU.adj:ifV.color = =' White': Self. Dfsvisit (G, v) v.pi=u u.color='Black' Time= time + 1U.F=

) print (data) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1 8, 19]Select sortIdea: A trip through the smallest number of records, put in the first position, and then go through the record remaining list of the smallest value, placedImport randomdef Select_sort (LI): for I in range (Len (LI)-1): min_loc = i for j in Range (I+1,len (LI)): If Li[j]Insert SortImport randomdef Insert_sort (LI): for I in range (1,len (LI)): temp = li[i]

1. Principle:2. Code implementationdefQuick_sort (alist, Start, end):"""Quick Sort""" #Recursive exit conditions ifStart >=End:return #sets the starting element as the datum element to find the positionMID =Alist[start]#Low is the left-to-right cursor for the left of the sequenceLow =Start#High is the right-to-left cursor to the right of the sequenceHigh =End whileLow High :#If low is not coincident with high, the element with high points is not smaller than the datum element, then high

First, build and traverse the binary treeclass Node (object): def __init__ (Self,item): self.key=Item self.left=None self.right=noneclassBinaryTree (object):def __init__(self): Self.root=NonedefAddNode (self,item): New_node=Node (item)ifSelf.root isNone:self.root=New_nodeElse: Stack=[] Stack.append (Self.root) whileTrue:node=stack.pop (0)ifNode.left isNone:node.left=New_nodereturn elifNode.right isNone:node.right=New_nodereturn Else: Stack.a

Lagrangian interpolation algorithm, very simple, sharing for reference.1 #CODING=GBK2 " "3 Created on 2014-8-314 5 @author: Administrator6 " "7 defLagrange (X,XT,YT):8y =09 forIinchRange (3):Tent = 1 One forJinchRange (3): A ifi!=J: -t = t* (X-xt[j])/(xt[i]-Xt[j]) -y = y+t*Yt[i] the Print("The result is:%f"%y) - -XT = [] -YT = [] +x = float (Input ("interpolation x;")) -n = Int (input ("number of nodes;")) + forIinchrange (n): AXt.append (Float (input ("the value

at a time until an empty slot is found and the key is stored in that position. For example, the hash value of the conflict is H, followed by the order of H+1, h+2, h+3 ...To prevent aggregation (clustering), the skip slots method can be used.(ii) quadratic probing (square probe): that is, the conflicting hash value is H, then the next lookup is h+1, followed by h+4,h+9,h+16 ...(2) Chaining (linked list method): All elements of the same hash value are saved in a linked list. However, the more el

value.Similarly, when an element of the RightMark position is greater than or equal to the base value, RightMark moves to the left one position to continue scanning, and the scan stops when the element of the RightMark position is less than the base value.After stopping the scan, we compare the size of the Leftmark and RightMark, if the Rightmark　　After we have put the datum values in the correct position, we see that the elements on the left side of the base value are smaller than the datum va

"Select Sort"The selection sort is based on a bubbling sort (Bubble sort) that has been improved: each visit process (pass) needs to be exchanged at most.Each visit process, to find the maximum value, when the end of the visit, the maximum value is exchanged to the correct position;Then continue to repeat the process in the remaining sublist until the n-1 visit is completed (n is the length of the list);At this point, the remaining elements in the list are automatically aligned to the correct po

Recommend a Visual Web site "Visual Algo": Url= ' https://visualgo.net/en/sorting 'This website gives the principles and processes of various sorting algorithms, which are visualized through dynamic forms. The related pseudo-code are also given, as well as the specific steps to execute to code."Bubble Sort"You need to repeatedly visit the sequence of columns that need to be sorted. The size of the adjacent two items is compared during the visit, and i

Recently learned about Python implementation of common machine learning algorithms on GitHubDirectory First, linear regression 1. Cost function2. Gradient Descent algorithm3. Normalization of the mean value4. Final running result5, using the linear model in the Scikit-learn library to implement Second, logistic regression 1. Cost function2. Gradient3. Regularization4, S-type func

Eight, the base sort Basic idea: the Cardinal sort (radix sort) is "assigned sort" (distribution sort), also known as "bucket method" (bucket sort) or bin sort, as the name implies, it is part of the information through the key value, The elements to be sorted are assigned to some "buckets", in order to achieve the order, the cardinal sort method is a sort of stability, its time complexity is O (Nlog (r) m), where R is the cardinality taken, and M