java中 基本数据结构的应用

集合框架中的接口

Collection：集合层次中的根接口，JDK没有提供这个接口直接的实现类。
Set：不能包含重复的元素。SortedSet是一个按照升序排列元素的Set。
List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。
Map：包含了key-value对。Map不能包含重复的key。SortedMap是一个按照升序排列key的Map。

ArrayList

ArrayList：我们可以将其看作是能够自动增长容量的数组。
利用ArrayList的toArray()返回一个数组。
Arrays.asList()返回一个列表。
迭代器(Iterator) 给我们提供了一种通用的方式来访问集合中的元素。

Collections类

排序：Collections.sort()
（1）自然排寻(natural ordering )；
（2）实现比较器(Comparator)接口。
取最大和最小的元素：Collections.max()、Collections.min()。
在已排序的List中搜索指定的元素：Collectons.binarySearch()。

LinkedList

LinkedList是采用双向循环链表实现的。
利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

ArrayList和LinkedList的比较

ArrayList底层采用数组完成，而LinkedList则是以一般的双向链表(double-linked list)完成，其内每个对象除了数据本身外，还有两个 引用，分别指向前一个元素和后一个元素。
如果我们经常在List的开始处增加元素，或者在List中进行插入和删除操作，我们应该使用LinkedList，否则的话，使用ArrayList将更加快速。

HashSet

实现Set接口的hash table(哈希表)，依靠HashMap来实现的。
我们应该为要存放到散列表的各个对象定义hashCode()和equals()。

散列表

散列表又称为哈希表。散列表算法的基本思想是：
  以结点的关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个值作为该结点存储在散列表中的地址。
当散列表中的元素存放太满，就必须进行再散列，将产生一个新的散列表，所有元素存放到新的散列表中，原先的散列表将被删除。在Java语言中，通过负载因子(load factor)来决定何时对散列表进行再散列。例如：如果负载因子是0.75，当散列表中已经有75%的位置已经放满，那么将进行再散列。
负载因子越高(越接近1.0)，内存的使用效率越高，元素的寻找时间越长。负载因子越低(越接近0.0)，元素的寻找时间越短，内存浪费越多。
HashSet类的缺省负载因子是0.75。

TreeSet

TreeSet是依靠TreeMap来实现的。
TreeSet是一个有序集合，TreeSet中元素将按照升序排列，缺省是按照自然顺序进行排列，意味着TreeSet中元素要实现Comparable接口。
我们可以在构造TreeSet对象时，传递实现了Comparator接口的比较器对象。

HashSet和TreeSet的比较

HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

HashMap

HashMap对key进行散列。
keySet()、values()、entrySet()。

TreeMap

TreeMap按照key进行排序。

HashMap和TreeMap的比较

和Set类似，HashMap的速度通常都比TreeMap快，只有在需要排序的功能的时候，才使用TreeMap。

Talk is cheap,show me the code

在Java中使用Set,可以方便地将需要的类型，以集合类型保存在一个变量中.主要应用在显示列表.
Set是一个不包含重复元素的collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

Set demo:

import java.util.*;
public class test {

public static void main(String[] args) {
   // TODO Auto-generated method stub
   Set set=new HashSet();
   set.add("abc");
   set.add("cde");
   set.add("efg");
   set.add("fgh");   
   set.add("abc"); //重复的abc,set会自动将其去掉  
   System.out.println("size="+ set.size() );
   
    List list = new ArrayList();
    list.add("abc");
    list.add("aaa");
    list.add("fff");
    set.addAll(list); //将list中的值加入set,并去掉重复的abc
        
    System.out.println("size="+ set.size() );
   for( Iterator   it = set.iterator(); it.hasNext(); )
    {             
         System.out.println("value="+it.next().toString());            
    }
}  
}

list Demo

import java.util.*;
public class test2 {

public static void main(String[] args) {
   
    List list = new ArrayList();
    list.add("abc");
    list.add("aaa");
    list.add("fff");
        
    System.out.println("size="+ list.size() );
   for( int i=0;i<list.size();i++ )
    {             
         System.out.println("value="+list.get(i));            
    }
}  
}

数据结构中的栈，在解决很多问题都有用处，比如括号匹配，迷宫求解，表达式求值等等

java中有封装好的类，可以直接调用：

 

Stack:

 

1-->public Stack()创建一个空堆栈

 

2-->public boolean empty()测试堆栈是否为空;

 

3-->public E pop()移除堆栈顶部的对象，并作为此函数的值返回该对象。 

 

4-->public E push(E item)把项压入堆栈顶部

 

5-->public E peek()查看堆栈顶部的对象，但不从堆栈中移除它。 

 

6-->public boolean empty()测试堆栈是否为空

 

结合一道题目：

 

括号配对问题

描述

现在，有一行括号序列，请你检查这行括号是否配对。

输入

第一行输入一个数N（0<N<=100）,表示有N组测试数据。后面的N行输入多组输入数据，每组输入数据都是一个字符串S(S的长度小于10000，且S不是空串），测试数据组数少于5组。数据保证S中只含有"[","]","(",")"四种字符

输出

每组输入数据的输出占一行，如果该字符串中所含的括号是配对的，则输出Yes,如果不配对则输出No

样例输入

3
[(])
(])
([[]()])

样例输出

No
No
Yes

 

 

代码：

import java.util.Scanner;
import java.util.Stack;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int N = scan.nextInt();
		String s;
		for (int i = 0; i < N; i++) {
			s = scan.next();
			if (isMatch(s)) {
				System.out.println("Yes");
			} else {
				System.out.println("No");
			}
		}
	}
	private static boolean isMatch(String s) {
		Stack<Character> sk = new Stack<Character>();
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) == '(') {
				sk.push('(');
			}
			if (s.charAt(i) == ')') {
				if (!sk.isEmpty() && sk.pop() == '(')
					continue;
				else
					return false;
			}
			if (s.charAt(i) == '[') {
				sk.push('[');
			}
			if (s.charAt(i) == ']') {
				if (!sk.isEmpty() && sk.pop() == '[')
					continue;
				else
					return false;
			}
		}
		if (sk.isEmpty())
			return true;
		else
			return false;
	}
}        

add                增加一个元索                                         如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove      移除并返回队列头部的元素       如果队列为空，则抛出一个NoSuchElementException异常
element   返回队列头部的元素                         如果队列为空，则抛出一个NoSuchElementException异常
offer              添加一个元素并返回true              如果队列已满，则返回false
poll                  移除并返问队列头部的元素        如果队列为空，则返回null
peek              返回队列头部的元素                         如果队列为空，则返回null
put                  添加一个元素                                           如果队列满，则阻塞
take                移除并返回队列头部的元素         如果队列为空，则阻塞
Queue Demo

注意队列的定义方式

import java.util.*;;
public class Queue<Object> {
	public static void main(String[] args)  
    {  
        Deque<String> queue = new LinkedList<String>();  
        queue.offer("1");//插入一个元素  
        queue.offer("2");  
        queue.offer("3");  
        //打印元素个数  
        System.out.println("queue.size()"+queue.size());  
        //遍历打印所有的元素,安装插入是顺序打印  
        for (String string : queue)  
        {  
            System.out.println(string);  
        }  
    }  

}