data structures in java tutorial

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

1. HashMap Overview HashMap is an asynchronous implementation of the map interface based on a hash table (Hashtable is similar to HashMap, the only difference being that the method in Hashtalbe is thread-safe, that is, synchronous). This implementation provides all the optional mapping operations and allows NULL values and NULL keys to be used. This class does not guarantee the order of mappings, especially if it does not guarantee that the order is immutable. 2. Four points of attention on Has

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

} the } + } - classdolinkedlist{ $ PrivateLinkedlistLinkedList; $ Publicdolinkedlist () { - This. LinkedList =NewLinkedlist(); - } the Public voidAddele (String str) { - Wuyi Linkedlist.add (str); the } - PublicString Getele () { Wu returnLinkedlist.removefirst (); - } About Public Booleanisemp () { $ returnlinkedlist.isempty (); - - } -}A simple small program, the package is not very good, written in

Chapter 6 of Robert lafore, Java data structures and algorithms /* 6.1 assume that you have bought a cheap handheld computer, but find that its built-in chip cannot be used for multiplication and can only be used for addition. To get rid of this dilemma, you need to write your own program, write a recursive method mult (), and its parameter number is X and the re

---------------------");d L.myadd (" Hello.. 1 ");d L.myadd (" Hello.. 2 ");d L.myadd (" Hello.. 3 ");d L.myadd ("Hello.. 4 "), SOP (" queue out Order "),//sop (DL), while (!dl.isempty ()) {SOP (Dl.myget ());} SOP ("---------------------End-------------------");} public static void Duizhan () {Duizhan dz=new Duizhan (); SOP ("-------------------stack---------------------");d Z.myadd (" Hello.. 1 ");d Z.myadd (" Hello.. 2 ");d Z.myadd (" Hello.. 3 ");d Z.myadd (" Hello.. 4 "), SOP (" Stack Out Or

(e e);//replace element in collection * "9" void Add (e e);//At the previous position of the current index or the current Adds a new element to the collection at the back of the index position. *//whether or not to add new elements before or after the current index position depends on whether you are traversing sequentially or in reverse order * If it is {@link#next}, insert at the previous position of the current position *//if it is {@link#previous} to inser

1. Bubble Sort: Time complexity is O (n2)The hypothesis is a small to large sort: a comparison between two adjacent numbers, and a larger number at the back. The largest number in the last row after a comparisonsuch as: 40, 8, 15, 18, 121 times after the order is: 8, 15, 18, 12, 40 in turn until from small to big pat good for (int i = 0;i ) { for (int j = 0;j n-1-i;j++) {//The last few are already lined up There is no need to sort the if(A[j] > a[j+1]) { k= a[j] ; = A

Stack top element public class stackelementTool Stack class:public class seqstackOperation Result:Shortcomings, please correct me.Implementation of the stack of data Structures (JAVA) (i)

]; while (end>start) { while (end>startarrys[key)//If there is nothing smaller than the key value, compare next until there is a smaller swap position than the key value, And then compare it back to the past End--; if (arrys[end]) { arrys[end]; arrys[arrys[start]; arrys[tmp; } while (end>startarrys[start]) Start+ +; if (arrys[key) {

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 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 K K K 3 10 8 6 5Elina's cards are: 2 3 A J Q J 4 K 4 6 5 J 3 2 King

) Unordered array Delete (query + fill hole) O (N) Ordered array deletion (query + fill hole) O (N) Why not use data to solve everythingAn unordered array is inserted (O (1) time), and the query spends (O (N) time). An ordered array query spends (O (logn) time), but inserts a missing cost (O (N) time). And the deletion takes (O (N) time). So a data structur

is true. is called a short-circuit operation because if the value of the expression on the left side of is false, the expression on the right will be shorted out directly and will not be evaluated.Most of the time we may need to use instead of , for example, to verify that the user's name is not NULL and is not an empty string when validating the login, it should be written as username! = null !username.equals (""), The order of the two cannot be exchanged,You cannot use the operator, becaus

Common data Structures in JavaCommon data structures are hash tables, linear lists, linked lists, and java.util packages with three important interfaces: List,set,map commonly used to implement basic data structuresHow the HashMap worksHashMap based on the hashing principle,

This article summarizes some of the data structures implemented in JavaBriefly:ListQueuemapSetThe data structure involved:Stack: provides push and stack (POP) functionsqueues: non-blocking methods for offer and pull, blocking methods for put and takeList : provides various functions such as add, find, remove, traverse, etc.Tree: Red-black tree, usually used for r

() method in the Bubblesort.java program (listing 3.1) with the Oddevensort () method . Make sure it runs in a sort of different amount of data, and that you need to figure out the number of two scans. Parity Ordering is actually useful in multiprocessor environments where the processor can process each odd pair at the same time, and then handle even pairs at the same time. Because the odd pairs are independent of each other, each pair can be compar

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