data structures and algorithms in java lafore

Linear table Lookup algorithmSequential LookupBinary lookup (linear table must be already sorted)1 /**binary Find2 * @paramobj3 * @paramvalue4 */5 Public Static voidHalfsort (int[] obj,intvalue) {6 intLen=obj.length;//gets the length of the array7 intMin=0;8 intMax=len-2;9 while(minmax) {Ten intMiddle= (Min+max)/2;//gets the subscript for the middle element of an array One if(obj[middle]==value) { ASystem.out.printl

1#include 2#include 3 voidSelectsort (int*a,intn);//pre-declaring the function to be called4 intMainvoid)5 {6 intK;7 intx[Ten]={2,4,6,8,0,1,3,5,7,9};8 for(k=0;kTen; k++)9printf"%d", X[k]);Tenprintf"\ n"); OneSelectsort (x,Ten); A for(k=0;kTen; k++) -printf"%d", X[k]); -printf"\ n"); theSystem"Pause"); - - return 0; - } + - voidSelectsort (int*a,intN//array elements are pointers, number of arrays + { A intI,j,t;//integer variable at intMin//minimum value, inde

1 classTrietree ():2 def __init__(self):3Self.root = {}4 5 defAddNode (SELF,STR):6 #each node (root node) in the tree that contains the number of words to that node, and the key that appears after the node.7Nowdict =Self.root8 forIinchRange (len (str)):9 ifStr[i] not inchNowdict:#discover new ways to combineTenNowdict[str[i]] = {'Count'70A'prefix': str[:i+1]} OneNowdict = Nowdict[str[i]]#move to the next node. Anowdict['Count'] + = 1 - - defCount

, card): Table.append (Card)ifTable.count (Card) >=2: whileTable.count (Card) >0:person.append (Table.pop ()) whileLen (hen)!=0 andLen (haa)! =0:#print "tab:", List (table)i = Hen.popleft ()#hen the cards first#print "Hen put", IRefreshtable (hen, i)#Hen Action#print "hen:", List (hen) #print "tab:", List (table)j = Haa.popleft ()#Haa after the card#print "Haa put", JRefreshtable (Haa, J)#haa Action#print "Haa:", List (HAA)#print "tab:", List (table)#print "Next Turn"

One, simple demopublic class Recursion {public static void Main (string[] args) {Test (100);}public static void Test (int n) {if (n = = 0) {Return}SYSTEM.OUT.PRINTLN (n);Test2 (n-1);}}Two, triangle numberpublic class Triangle {public static int GetNumber (int n) {int total= 0;while (n > 0) {Total = Total + N;n--;}return total;}public static int getnumberbyrecursion (int n) {if (n = = 1) {return 1;} else {return n + getnumberbyrecursion (n-1);}}}Test:public class Testtriangle {public static void

Quick sort:/** Quick Sort*/public class QuickSort {/*** Divide arrays*/public static int partition (long arr[],int left, int. Right,long point) {int leftptr = left-1;int rightptr = right;while (true) {Loop, will be smaller than the keyword left in the left sidewhile (Leftptr Loop, will be larger than the keyword left on the right sidewhile (Rightptr > Leftptr arr[--rightptr] > point);if (leftptr >= rightptr) {Break} else {Long tmp = arr[leftptr];ARR[LEFTPTR] = arr[rightptr];ARR[RIGHTPTR] = tmp;

Data structures and algorithms (C # implementation) series --- generalized tree (II) Heavenkiller (original) Public override object key {get {return this. Key ;}} Public override uint degree {get {return this. degree ;}} // Public override uint height {get {return this. Height ;}} Public override bool isempty () // property takes the place of isempty

1#include 2#include 3 4 intBinsearch (intXintV[],intn);//function Declaration5 6 intMain ()7 {8 intarr[]={1,2,3,4,5,6,7,8,9,Ten};9 intas a result, num;Tennum=7; OneResults =binsearch (Num,arr,Ten); A - if(Results 0) -printf"I didn't find!\n ."); the Else -printf"find%d\n in arr[%d]", as a result, num); -System"Pause"); - + return 0; - } + A intBinsearch (intXintV[],intN//function Definition at { - intLow,high,mid;//min, max, Middle - -low=0; -high=n-1; - in

Data structures and algorithms (C # implementation) series --- AVLTree (II) // --------------- Override -------------------- Public override void AttachKey (object _ obj) { If (! IsEmpty ()) Throw new Exception ("My: this node must be a empty tree node! "); This. key = _ obj;

) { returnNULL; } TreeNode* node =NewTreeNode;//noice that [new] should is written out.Node->elem = * (aftorder+length-1); Std::coutStd::endl; intRootindex = 0; for(; rootindex //a variation of the loop { if(Inorder[rootindex] = = * (aftorder+length-1)) Break; } node->left =binarytreefromorderings (inorder, Aftorder, Rootindex); Node->right = binarytreefromorderings (inorder + rootindex + 1, Aftorder + rootindex, Length-(Rootindex + 1)); returnnode;}intMainintarg

Data structures and algorithms (C # implementation) series --- tree (III) Heavenkiller (original) // Overwrite Object. Equals () --- reference type realization Public override bool Equals (object _ obj) { If (_ obj = null) Return false; // this cannot be null If (! (This. GetType () = _ obj. GetType ())) Return false; // The type is not equal. Tree tmpObj = (Tre

Public classSelectionsort { Public Static voidsort (integer[] array) {if(Array = =NULL|| Array.Length = = 0) { return; } Integer mininum=NULL; Integer Miniindex=NULL; for(inti = 0; i ) {Miniindex=i; Mininum=Array[i]; for(intj = i + 1; J ) { if(Array[j] mininum) {Miniindex=J; Mininum=Array[j]; } } if(Miniindex! =i) {swap (array, I, miniindex); } } } Private Static voidswap (integer[] array, integer i, Integer j) {Integer temp=Array[i]

1 Sequence decompression: through * to pass the match*a, B = somelist, First, *mid, last = Somelist, a, *b = Somelist2 using bidirectional queues: From collections import dequeQ = deque (maxlen=5) can be fixed lengthQ = deque () can also be any lengthcan be inserted and removed from both ends, append, Appendleft, pop, popleft3 finding the largest or smallest n elements: using heapq (heap queue)HEAPQ. nlargest (N, Alist) heapq. nsmallest (n, alist) is suitable when n is relatively smallYou can al

The maximum value in the output array A and its subscript#include Data structures and algorithms-maximum values in a string output array

Title: Define the Fibonacci sequence as follows:/0 N=0F (n) = 1 n=1\ f (n-1) +f (n-2) n=2Enter N to find the nth item of the sequence in the quickest way.#include Data structures and algorithms-string Fibonacci to find the nth item

(self) self.engine.accept (visitor) self.body.accept (Visito R) forWheelinchself.wheels:wheel.accept (visitor)#This is our visitor, and every change is here .classPrintvisitor:defVisitwheel (self, Wheel):Print "Visiting"+wheel.name+"Wheel" defVisitengine (self, Engine):Print "Visiting engine" defvisitbody (self, body):Print "Visiting Body" defVisitcar (self, car):Print "Visiting Car"if __name__=='__main__': Car=Car () visitor=printvisitor () car.accept (visitor)Learn some Python basics

Package Com.js.ai.modules.pointwall.testxfz;class ordarray{private long[] a;private int nelems;public OrdArray (int max ) {a=new long[max];nelems=0;} public int size () {return nelems;} Insert method public void Insert (Long value) {int j;for (j=0;j　　Data structures and algorithms: the dichotomy Demo

True Second, collections. Ordereddict: Dictionary with OrderOrdereddict internally maintains a doubly linked list to record the order in which key values are inserted, update the key value does not affect the original order, insert key value is inserted at the end, so its memory consumption is twice times the normal dictionary ,From collections Import ORDEREDDICTD = Ordereddict () d[' a '] = 1d[' c '] = 3d[' b '] = 2print (d, D.items ()) Ordereddict (' A ', 1), (' C ', 3)

-set receives a tree height effect and is less efficient. Therefore, there are two kinds of improved heuristic algorithms.The first is to merge by rank, and for each node to record his height, change the father of the smaller node to the larger one. If both sides are equal, select one as the father, and the rank of the root node plus one.The second is path compression, and each time the find-set is called, the father of the node found on the path is changed directly to the root node.1make-SET (x

1. The principle of hill sorting2. Code implementationdefShell_sort (alist): N=Len (alist)#Initial StepGap = N/2 whileGap >0:#Insert Sort by step forIinchRange (Gap, N): J=I#Insert Sort whileJ>=gap andALIST[J-GAP] >Alist[j]: alist[j-GAP], alist[j] = alist[j], alist[j-Gap] J-=Gap#get a new step sizeGap = GAP/2alist= [54,26,93,17,77,31,44,55,20]shell_sort (alist)Print(alist)Attention:(1) Hill sort uses the idea of splitting up and merging, splitting apart3. Complexity of TimeOp