数据结构——2.1线性表顺序存储

概念：
顺序存储和链式存储
线性表的实现

顺序表和数组的区别：
线性表在顺序存储的时候就是用数组来表示的，但顺序表在删除一个元素的时候，如本来是（a，b，c）删除后（a，c），对于数组（a，b，c）删除后是（a，，c），线性表的长度可长可短，但数组的长度一旦定义不可修改，顺序表不允许两个元素之间是有一个位置不存元素，但是数组允许。

线性表可以为空
数据元素是有序（不一定是必须从大到小或必须从小到大）且有限
除了第一个和最后一个元素后，每个元素都有唯一一个直接前驱和直接后继

线性表的ADT：
例一：求A∪B

 /*
     * 思路：A∪B，可以A不动，得到B的长度（ListLen），
     * 每次从B中获取一个元素（getElement），
     * 判断是否在A中（Locate），
     * 若不在则插入（insertList）
     */
    union(List La,List Lb){
    	Lb_len = ListLen(Lb);
    	La_len = ListLen(La);
    	for (i = 0;i < Lb_len;i++) {
    		getElement(Lb,i,e);
    		if(！Locate(La,e)) {
    			insertList(La,++La,e);
    		}
    	}	
    }
    对于实现，我觉得用Java的Set比较方便，因为Set可以直接去重。

例一：归并A和B

/*
 * 思路：归并，即要有序和合并在一起，这里讲从小到大的顺序
 * 1、初始化线性表Lc
 * 2、从La中取得元素ai，从Lb中取得元素bj，
 * 3、判断ai和bj的大小，小的插入Lc
 * 4、重复2/3步骤
 * 5、把剩下的一次插入Lc即可
 */
mergeList(List La,List Lb){
	La_len = ListLen(La);
	Lb_len = ListLen(Lb);
	Lc_len = La_len + Lb_len;
	Lc = (ElemType*)malloc(Lc_len * sizeof(ElemType));
	i = 0;j = 0; k = 0;
	while(i < La_len && j < Lb_len) {
		getElem(La,i,ai); 
		getElem(Lb,j,bj);
		if(ai <= bj) {
			InsertList(Lc,++k,ai); 
			i++;
		}else {
			InsertList(Lc,++k,bj); 
			j++;
		}
	}
	while(i < La_len) {
		getElem(La,i,ai);
		InsertList(Lc,++k,ai); 
		i++;
	}
	while(j < Lb_len) {
		getElem(Lb,j,bj);
		InsertList(Lc,++k,bj); 
		j++;
	}
}

顺序存储：
计算第i各元素的位置：
Locate（ai）= a1 + （i - 1）* L；
存取结构：
随机存取；查找第 i 个元素的时间复杂度是O（1），顺序表存取；
顺序存取：查找第 i 个元素的时间复杂度是O（n），单链表存取；
顺序表类型;
静态结构；一旦装满不能扩充
动态结构；可以扩充

typeof struct sqlist{
	ElemType *elem;//基址
	int maxsize;//最大长度
	int len;//当前元素长度
}SqList；

顺序表初始化：

InitList（）{
	elem = (ElemType *)malloc (maxsize * sizeof (ElemType));
	if (! elem) return false;
    len = 0;
}

顺序表的插入：
在第 i 个位置之前插入一个元素，则需要移动n - i + 1个元素，

判断边界问题非常重要
假设顺序表的长度是n，第 i 个，合法的 i 的范围是：1 <= i <= n
对于下标 i 来说，合法的范围是：0 <= i <= n-1
判断是否溢出非常重要
如果此时的len已经大于或等于maxsize了，就不能再插入了

1、把第 i 个元素移动到第 i + 1 个
2、把 e 插入到第 i - 1个位置
3、线性表长度加1
InsertList（La，i ，e）{
	La_len = ListLen(La);
	if(i < 0 || i > len -1 ) return false;
	if(len >= maxsize)  return false;
	for (j = len-1;j > i;j--){
		La[j + 1] = La[j];
	}
	La[i-1] = e;
	len++;
	return true;
}    
该算法的时间主要浪费在移动n - i + 1个元素上， 其时间复杂度是O(n)

顺序表的删除：
删除第 i 个元素，则需要移动n - i 个元素，其时间复杂度是O(n)
判断边界问题非常重要
假设顺序表的长度是n，第 i 个，合法的 i 的范围是：1 <= i <= n
判断是否是空表非常重要

 1、把第 i +1 个元素移动到第 i 个元素
 2、把第i 个元素返回
 3、线性表长度减1
 Delete(La,i,e){
 if (i < 0 || i > len-1) return false;
 if( len == 0) return false;
 e = La[i-1];
 for(j = i; j < len ;j++){
 	La[j-1] = La[j];
 len--;
 return e;
 }
   该算法的时间主要浪费在移动n - i个元素上， 其时间复杂度是O(n)

顺序表的定位删除：
删除线性表中值为x的元素,其时间复杂度是O(n)

1、找到值为x的元素，获取其下标 i
2、把第 i +1 个元素移动到第 i 个元素
3、线性表长度减1
Locate_Delete（La，x）{
 while（i < len）{
	if(La[i] != x){
		i++;
	}else{
		for(j = i + 1; j < len;j++){
			La[j - 1] = La[j];
		}
			len--;
			break;
		}		
  }
  if(i >= len) return false;
  return true;
} 
该算法的时间主要浪费查找元素值为x的元素和移动n - i个元素上， 其时间复杂度是O(n)