数据结构与算法：线性表

回顾数据结构与算法的时候，发现好多都忘了，于是决定整理一下；
线性表是n个数据元素的有限序列。
特点：
1．集合中必存在唯一的一个“第一元素”；
2．集合中必存在唯一的一个 “最后元素”；
3．除最后元素之外，均有 唯一的后继；
4. 除第一元素之外，均有 唯一的前驱。
基本操作：
初始化：构造一个空的线性表。
销毁：销毁一个已存在的线性表。
插入：第i个位置之前插入一个新元素。
删除：删除线性表中的第i个数据元素。
更新：更新第i个数据元素。
查找：找出线性表中满足特定条件的元素的位置
获取：取线性表中的第i个数据元素
判空：判断当前线性表是否为空
求长度：求出线性表中数据元素的个数
正序遍历：依次访问线性表中每个元素并输出

一；线性表的顺序表示：

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。通常称这种存储结构的线性表为顺序表。
常见操作：
1.初始化

//无参构造方法
public sequenceList ( )  
{
	length=0;  //线性表初始为空
	listArray=(T[])new Object[maxSize];
}
//有参构造方法
public sequenceList (int n ) 
{
    	if(n<=0){
 		   System.out.println("error");
 		   System.exit(1);
 		}
 	length=0;  //线性表初始为空
 	listArray=(T[])new Object[n];	
}

2.顺序表的插入

public boolean add(T obj,int pos) 
{
    	if(pos<1||pos>length+1){
		System.out.println("pos值不合法");
		return false;
		}
		//先判断顺序表数组空间状态，如果顺序表数组空间已经存满，重新分配存储空间
if(length==listArray.length){
 	T[] p=(T[])new Object[length*2];
 	for(int i=0;i<length;i++)
 		p[i]=listArray[i];
 	listArray=p;   
       }
 	for(int i=length;i>=pos;i--)
 		    listArray[i]=listArray[i-1];
 	listArray[pos-1]=obj;   
 	length++;
 	return true;
}

3.顺序表的删除

public T remove(int pos) 
{
	if(isEmpty()){
	System.out.println("顺序表为空，无法执行删除操作");
	return null;
	}
	else{
	if(pos<1||pos>length){
	System.out.println("pos值不合法");
	return null;
	}
	 T x=listArray[pos-1];
	 for(int i=pos;i<=length;i++)
		listArray[i-1]=listArray[i];
	  length--;
	  return x;			
        }
}

4.顺序表的查找

public int find(T obj) 
{
	if(isEmpty( )){
		System.out.println("顺序表为空");
		return -1;
	}
	else{
		for(int i=0;i<length;i++)
			if(listArray[i].equals(obj))  
				return i+1;
			return -1;		
	}		
}

5.获取元素

public T value(int pos) 
{	if(isEmpty( )){
		System.out.println("顺序表为空");
		return null;
	}
	else{
	            if(pos<1||pos>length){		 		 
	            System.out.println("pos值不合法");
		    return null;
	              }
		return listArray[pos-1];		
	}    	    	
}

6.顺序表的更新元素

public boolean modify(T obj,int pos)
{    	if(isEmpty( )){
		System.out.println("顺序表为空");
		return false;
	}
    	else{
    		if(pos<1||pos>length){
        			System.out.println("error");
        			return false;
        	}
        	listArray[pos-1]=obj;   	
        	return true;  	
    	}    	
}

7.判空

public boolean isEmpty(  )
{    	return length==0;   }

8.求长度

public int size(  ) 
{    	return length;	}

9.正序输出

public void nextOrder(  ) 
{
    	for(int i=0;i<length;i++)
    		System.out.println(listArray[i]);
}

10.清空

public void clear(){
      length=0;
}

二；线性表的链式表示

线性表的链式存储结构是用一组任意的存储单元来存放线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。

数据域	指针域

（单链表结点结构）
（在这里我只总结单链表，对于循环链表和双向链表就不做过多总结）
1.单链表的实现

//泛型定义
public class Node<T> {
	T data;
	Node<T> next;
	public Node(Node<T> n)
	{	next=n;		}
	public Node(T obj,Node<T> n)
	{	data=obj;   next=n;	}
	public T getData()
	{	return data;	}
	public Node<T> getNext()
	{	return next;	}
}

2.单链表的初始化

public linkList( ){
	length=0;
	head=new Node<T>(null);		
 }

3.获取头结点的地址

public Node<T> getHead ( )
{	return head;	}

4.单链表的插入

public boolean add(T obj,int pos){
	if((pos<1||pos>length+1)){
		System.out.println("pos值不合法");
		return false;
	}
	int num=1;
	Node<T> p=head,q=head.next;
	while(num<pos){
		p=q;	q=q.next;     num++;
	}
	p.next=new Node<T>(obj,q);
	length++;
	return true;	
}

4.单链表的删除

public T delete(int pos){
	if(isEmpty()){
	System.out.println("链表为空表");
	return null;
	}
	else{
	if(pos<1||pos>length){
	System.out.println("pos值不合法");
	return null;
	}
	int num=1;
	Node<T> p=head,q=head.next;
	while(num<pos){
		p=q;
		q=q.next;
		num++;
	}
	p.next=q.next;
	length--;
	return q.data;	
}
}

5.查找

public int find(T obj){
	if(isEmpty()){
	System.out.println("链表为空表");
	return -1;
	}
	int num=1;
	Node<T> p=head.next;    
	while(p!=null){          //单链表的判空条件
		if(p.data.equals(obj)==false){   
			p=p.next;					num++;		
			}			
		else break;
	}
	if(p==null) return -1;
	return num;
}

6.获取第pos个结点的值

public T value(int pos){
	if(isEmpty()){
	System.out.println("链表为空表");
	return null;
	}
	else{
	if((pos<1||pos>length+1)){				System.out.println("pos值不合法");
		return null;
	}
	int num=1;
	Node<T> q=head.next;
	while(num<pos){		
		q=q.next;
		num++;
	}
	return q.data;		
}
}

7.更新第pos个结点的值

public boolean modify(T obj,int pos){		
	if(isEmpty()){
	System.out.println("链表为空表");
	return null;
	}
	else{
	if((pos<1||pos>length+1)){				
	System.out.println("pos值不合法");
		return false;
	}
	int num=1;
	Node<T> q=head.next;
	while(num<pos){			
		q=q.next;
		num++;
	}
	q.data=obj;	return true;		
}
}

循环链表是另一种形式的链表，它的特点是表中最后一个结点的指针域不再为空，而是指向表头结点，整个链表形成一个环。
双向链表：prior+data+next。

小结

顺序存储：
优点：存储密度大，存储空间利用率高，可随机存取。
缺点：插入或删除元素时不方便。
适合查找（静态操作）
链式存储：
优点：插入或删除元素时很方便，使用灵活。结点空间可以动态申请和释放；
缺点：存储密度小，存储空间利用率低，非随机存取。
适合插入，删除（动态操作）