3.1--3.3.2抽象数据类型ADT、单链表初始化删除插入、Collection接口、Iterator接口的简单介绍

3.1抽象数据类型

抽象数据类型(abstract data type,ADT)是带有一组操作的一些对象的集合。

3.2.1表的简单数组实现

在必要的时候扩展一个数组arr

int [] arr = new int[10];
//扩大该数组
int [] newArr = new int[arr.length*2];
for(int i=0;i<arr.length;i++){
   newArr[i] = arr[i];
}
arr = newArr;

3.2.2简单链表

单链表的初始化、插入、删除

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.    
4. typedef int ElemType;  
5.    
6. //定义结点类型   
7. typedef struct Node {  
8.     ElemType data;              //单链表中的数据域   
9.     struct Node *next;          //单链表的指针域   
10. }Node,*LinkedList;  
11.    
12.    
13. //单链表的初始化  
14.    
15. LinkedList LinkedListInit() {  
16.     Node *L;  
17.     L = (Node *)malloc(sizeof(Node));   //申请结点空间   
18.     if(L == NULL) { //判断是否有足够的内存空间   
19.         printf("申请内存空间失败\n");  
20.     }  
21.     L->next = NULL;                  //将next设置为NULL,初始长度为0的单链表   
22.     return L;  
23. }  
24.    
25.    
26. //单链表的建立1，头插法建立单链表  
27.    
28. LinkedList LinkedListCreatH() {  
29.     Node *L;  
30.     L = (Node *)malloc(sizeof(Node));   //申请头结点空间  
31.     L->next = NULL;                      //初始化一个空链表  
32.        
33.     ElemType x;                         //x为链表数据域中的数据  
34.     while(scanf("%d",&x) != EOF) {  
35.         Node *p;  
36.         p = (Node *)malloc(sizeof(Node));   //申请新的结点   
37.         p->data = x;                     //结点数据域赋值   
38.         p->next = L->next;                    //将结点插入到表头L-->|2|-->|1|-->NULL   
39.         L->next = p;   
40.     }  
41.     return L;   
42. }   
43.    
44.    
45. //单链表的建立2，尾插法建立单链表  
46.    
47. LinkedList LinkedListCreatT() {  
48.     Node *L;  
49.     L = (Node *)malloc(sizeof(Node));   //申请头结点空间  
50.     L->next = NULL;                  //初始化一个空链表  
51.     Node *r;  
52.     r = L;                          //r始终指向终端结点，开始时指向头结点   
53.     ElemType x;                         //x为链表数据域中的数据  
54.     while(scanf("%d",&x) != EOF) {  
55.         Node *p;  
56.         p = (Node *)malloc(sizeof(Node));   //申请新的结点   
57.         p->data = x;                     //结点数据域赋值   
58.         r->next = p;                 //将结点插入到表头L-->|1|-->|2|-->NULL   
59.         r = p;   
60.     }  
61.     r->next = NULL;   
62.        
63.     return L;     
64. }  
65.    
66.    
67. //单链表的插入，在链表的第i个位置插入x的元素  
68.    
69. LinkedList LinkedListInsert(LinkedList L,int i,ElemType x) {  
70.     Node *pre;                      //pre为前驱结点   
71.     pre = L;  
72.     int tempi = 0;  
73.     for (tempi = 1; tempi < i; tempi++) {  
74.         pre = pre->next;                 //查找第i个位置的前驱结点   
75.     }  
76.     Node *p;                                //插入的结点为p  
77.     p = (Node *)malloc(sizeof(Node));  
78.     p->data = x;   
79.     p->next = pre->next;  
80.     pre->next = p;  
81.        
82.     return L;                             
83. }   
84.    
85.    
86. //单链表的删除，在链表中删除值为x的元素  
87.    
88. LinkedList LinkedListDelete(LinkedList L,ElemType x)  
89. {  
90.     Node *p,*pre;                   //pre为前驱结点，p为查找的结点。   
91.     p = L->next;  
92.     while(p->data != x) {              //查找值为x的元素   
93.         pre = p;   
94.         p = p->next;  
95.     }  
96.     pre->next = p->next;          //删除操作，将其前驱next指向其后继。   
97.     free(p);  
98.     return L;  
99. }   
100.    
101.    
102. int main() {  
103.     LinkedList list,start;  
104.     printf("请输入单链表的数据：");   
105.     list = LinkedListCreatH();  
106.     for(start = list->next; start != NULL; start = start->next) {  
107.         printf("%d ",start->data);  
108.     }  
109.     printf("\n");  
110.     int i;  
111.     ElemType x;  
112.     printf("请输入插入数据的位置：");  
113.     scanf("%d",&i);  
114.     printf("请输入插入数据的值：");  
115.     scanf("%d",&x);  
116.     LinkedListInsert(list,i,x);  
117.     for(start = list->next; start != NULL; start = start->next) {  
118.         printf("%d ",start->data);  
119.     }  
120.     printf("\n");  
121.     printf("请输入要删除的元素的值：");  
122.     scanf("%d",&x);  
123.     LinkedListDelete(list,x);   
124.     for(start = list->next; start != NULL; start = start->next) {  
125.         printf("%d ",start->data);  
126.     }  
127.     printf("\n");  
128.        
129.     return 0;  
130. }  

3.3.1 Java Collections API 中的 Collection接口

Collection API位于java.util包中。集合（collection）的概念在Collection接口中得

到抽象，它存储一组类型相同的对象。

//Collection接口扩展Iterable接口，可以直接使用这些方法
	public interface Collection<AnyType> extends Iterable<AnyType>{
		int size();
		boolean isEmpty();
		void clear();
		boolean contains(AnyType x);
		boolean add(AnyType x);
		boolean remove(AnyType x);
		java.util.Iterator<AnyType> iterator();
	}

3.3.2 Iterator接口

Iterator接口的思路：通过Iterator方法，每个集合均可创建并返回给客户一个实现

Iterator接口的对象，并将当前位置的概念在对象内部存储下来。

//当编译器见到一个正在用于Iterator的对象的增强的for循环的时候，
	//它用对iterator方法的那些调用代替增强的for循环以得到一个Iterator对象，
	//然后调用next和hasNext
	public static <AnyType> void print(Collection<AnyType> coll){
		Iterable<AnyType> itr = coll.iterator();
		while (itr.hasNext()) {
			AnyType item = itr.next();
			System.out.println(item);
		}
	}

如果对正在被迭代的集合进行结构上的改变（即对该集合使用add、remove、clear方法），那么迭代器就不再合法（并且在其后使用该迭代器时将会有ConcurrentModificationException异常被抛出）。