data structures and abstractions with java

with large O notation all require O (N2) time level. Bubbling sorting is not generally selected, although bubbling sort writing is the simplest, but the average performance is not to choose sort and insert sort well.Select sort to reduce the number of exchanges to the lowest, but the number of comparisons is quite large. Select sort can be applied when the amount of data is small and exchange data is more

;importorg.junit.before;importorg.junit.test; importcom.xingej.algorithm.datastructure.array.myarray;/*** Object-Oriented programming,** That is, the you operate is an object, not a basic data type *** @author erjun2017 November 28 Afternoon 9:59:36*/publicclassmyarraytest{privatemyarray myarray; @Before publicvoidinit () { myarray=newmyarray (); testinsert ();}// Insert data test @Test publicvoidtest (

The enumeration (enumeration) interface, although not part of the data structure itself, is widely used in other data structure categories. The enumeration (the enumeration) interface defines a way to retrieve contiguous elements from a data structure.For example, an enumeration defines a method called Nextelement, which is used to get the next element of a

Java data structures and algorithms (iii) -- simple sorting Data alone is not enough. Data presentation often needs to be arranged in a certain order. The higher the requirement, the more complicated the sorting. This article only introduces three simple sorting types. 1) B

; 1){ - if(Peoples[index]) { incount++; - if(Count = = 3){ toPeoples[index] =false; +Count=0; -leftcount--;//minus 1 for the rest of the population. the } * } $ Panax Notoginseng //put the element under the label -index++; the + //If you have counted to the end of the array, start the number A if(Index > Len-1){ theindex = 0; + } - } $ $ for(i

List operation code is small but more error-prone, is more suitable for the interview place. Code implementation /** * Source Name: Mylinklist.java * Date: 2014-09-05 * program function: Java list operation * Copyright: [emailprotected] * A2bgeek */import Java.util.Sta Ck;public class Mylinklist {class Linknode"Data structures and Algorithms"

; J ) {System.out.print (A[j]+ " "); } System.out.println (""); } //Bubble Sort Public voidBubblesort () {intOut , in; for(out = nElems-1, out > 1; out--) { for(in = 0; in ) { if(A[in] > a[in + 1]) {swap (in,+ 1); } } } } //Insert Sort Public voidInsertionsort () {intin, out; //Out are dividing line for(out = 1; out ) { //Remove marked item Longtemp =A[out]; //start shifts at outin =Out ; wh

) { +Temp[i] =key; -}Else { theTemp[i] = This. table[i-1];Bayi } the } the - This. Table =temp; - } the the Public intSearchindex (intkey) { the intn = key/m-1; the intStart =-1; - intLength =-1; the //Find index location the for(inti = 0; I This. Indextable.size (); i++) { the if(n = = This. Indextable.get (i). Index) {94Start = This. Indextable.get (i). Start; theLength = This. Indextable.get (i). len

List interface, repeatable, ordered. List has ArrayList, because is the array structure, is suitable for the data query, LinkedList, because is the chain list structure, is suitable for uses in the deletion operation. If the array of additions and deletions, need to follow the elements are moving forward or backward, if the first element to make additions and deletions, the following elements move is very large, inefficient. Linked list If you do a qu

Recently listening to colleagues said that the use of Sparsearray instead of HashMap can improve performance, so the edge of the two classes of data structure for a simple analysis.Data structure of HashMapHashMap is a combination of arrays and linked lists (in the data structure called "chain-Table hashing"), as shown in:Photo Source: Java's HashMap and HashtableData structure of SparsearraySparsearray ref

Method Public BooleanDeleteLongvalue) { intj =find (value); if(j==Nelems) { return false; } Else { for(intK=j; k) {A[k]= A[k+1]; } nelems--; return true; } } //Binary Method Search Public intFindLongSearchkey) { intlowerbound = 0; intUpperbound = nElems-1; intCurin; while(true) {Curin= (lowerbound + upperbound)/2; if(a[curin]==Searchkey) { returnCurin;//found it } Else if

)? {???????? This.ddata?=?ddata;???????? This.idata?=?idata,????}???? Public?void?displaylink ()? {???????? System.out.println ("{"? +?idata?+? ",?"?) +?ddata?+ "}");????}}Simple test Cases:Package?com.xingej.algorithm.datastructure.linkedlist.singlelinkedlist;import?org.junit.test;/**?*? single-linked list test? *[email protected]?erjun?2017 December 8? Morning 9:00:54?*/public?class? Linklisttest? {[email protected]???? Public?void?test ()? {???????? Linklist?list?=?new? Linklist ();???????? ?

This article is about the search for ordered tables, which mainly includes the optimization usage of sequential lookups, binary lookups, interpolation lookups, Fibonacci lookups;Sequential Optimization Search : The efficiency is very low, but the algorithm is simple, suitable for small data search;Binary lookup : Also known as a binary lookup, it is searched from the middle of the lookup table. Finding results requires only half of the

Stacks and queuesStack (last in, first out)Stack, which allows access to only one data item: The last inserted data item.Stacks can be used to check the matching problems of parentheses and parse mathematical expressions, similar to those used in the compilation principle.The operation of the picture is actually summed up: 1. Read the left delimiter into the stack, 2. The right delimiter is read to match th

) + (N-2) +...+1 = N (N-1)/2When the value of N is very large, the algorithm compares the number of N2/2 times, ignoring minus 1.Assuming that the data is random, it is possible to swap locations each time, possibly without swapping, assuming a probability of 50%, then the number of interchanges is N2/4. However, if the worst-case scenario is that the initial data is reversed, the position is swapped for ea

=currentlink.next;} System.out.println (""); System.out.print ("Linklist.displaylist () Finish");}}public class Linklistapp {public static void main (string[] args) {linklist thelinklist =new linklist (); Thelinklist.insertlink (9, 999, 999.999); Thelinklist.displaylist (); Thelinklist.insertfirst (22, 22.22); Thelinklist.insertfirst (33.33), Thelinklist.insertfirst (44.44), Thelinklist.insertfirst (55, 55.55); Thelinklist.displaylist (); Thelinklist.insertlink (2, 333, 333.333); Thelinklist.di

); Linkedlist.removefirst (); Linkedlist.removelast (); //determine if the linked list is emptySystem.out.println (Linkedlist.isempty ());} HashMap Non-synchronous Public Static voidhashmaptest () {HashMapNewHashmap(); //adding elements to the hash tableHashmap.put ("TP", 123); Hashmap.put ("ZP", 567); System.out.println (HASHMAP); //facilitates a hash table with iterators for(IteratorHashmap.entryset (). iterator (); Iterator.hasnext ();) {EntryIterator.next (); Syst

));}} //Look at cardsLookpoker ("Wind Qing", Fengqingyang);Lookpoker ("Brigitte", Linqingxia);Lookpoker ("Elina", Liuyi); lookpoker ("hole cards", Dipai);}public static void Lookpoker (String name, arraylistSystem.out.print (name + "The card is:");for (String S:array) {System.out.print (S + "");}System.out.println ();}} Test multiple timesOutput: The wind of the card is: Xiao Wang ♦8♥10♦5♣q♥4♣7♣8♠9♦a♠4♥7♠2♦6♠7♥8♣9Brigitte's cards are: ♦q♥5♥9♠a♠6♣3♠q♦7♦10♠k♦k♣k♥3♠10♠8♥6♠5Elina's cards are: ♥2♠3♥

(Array.get (x)); } NBSP;NBSP;} Look at the cardsLookpoker ("Wind Qing", Fengqingyang);Lookpoker ("Brigitte", Linqingxia);Lookpoker ("Elina", Liuyi); lookpoker ("hole cards", Dipai);}public static void Lookpoker (String name, arraylistSystem.out.print (name + "The card is:");for (String S:array) {System.out.print (S + "");}System.out.println ();}} Test multiple timesOutput: The wind is the card is: Xiao Wang 8? 10? 5? Q. 4? 7? 8? 9? A 4? 7 2? 6? 7? 8? 9Brigitte's cards are:? Q. 5? 9? A? 6? 3?

the left to find an element that is larger than the base element, stop, the two elements are exchanged until two pointers meet, the end of the cycle * pointer point to the The position is where the datum element should be located in the collection * eg * {8,-2, 3, 9, 0, 1, 7, 6} * Benchmark * First bm=8 * end = Lengt h-1 = 7 * start=0 * End--, We found 6:8 small, end pointer stopped, current index is j=7 * start++, until element 9 stops, current index i=3 * Exchange the elements corresp