JAVA数据结构 线性表的链式存储及其实现

2线性表的链式存储及其实现

虽然顺序表具备随机存取的特色是一种有用的存储结构可是也有缺陷：

（1）      若须要给顺序表增长存储空间首先必须开辟一个更大的存储空间而后把数据复制到如今这个表当中

（2）      由于顺序表的数据元素在存储结构上相邻素要删除元素就要移动平均一半的数据元素

因此顺序表适合静态的线性表，表一旦造成就不多进行插入操做，对于要进行平凡的插入或者删除操做的“动态的”线性表一般采用链式存储结构，与此同时链式存储结构也失去了可随机存取的优势，链式结构只能进行顺序存取。

统一接口以下：

/*
 * Kiss_My_Love
 * 2012/8/26
 * xaut.media082
 * */
package www.xaut.com.linkedlist;

public interface Ilist {
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object get(int i);
	public void insert(int i,Object x);
	public void remove(int i);
	public int indexOf(Object x);
	public void display();
}

2.1单链表的表示

data

next

节点有数据和指针构成

2.1.1节点类的描述

/*
 * Kiss_My_Love
 * xaut
 * 2012/8/26
 * */
package www.xaut.com.linkedlist;

public class Node {
		private Object data;
		private Node next;
		
		public Node(){
			this.data=null;
			this.next=null;
		}
		public Node(Object data){
			this.data=data;
			this.next=null;
		}
		public Node(Object data,Node next){
			this.data=data;
			this.next=next;
		}
		
		public Object getData() {
			return data;
		}
		public void setData(Object data) {
			this.data = data;
		}
		public Node getNext() {
			return next;
		}
		public void setNext(Node next) {
			this.next = next;
		}
		
}

2.1.2单链表类的描述：

/*
 * Kiss_My_Love
 * xaut
 * 2012/8/26
 * */
package www.xaut.com.linkedlist;

import java.util.Scanner;

public class LinkedList implements Ilist {

	private Node head;
	public LinkedList(){//初始化头结点
		head=new Node();
	}
	public LinkedList(int n,boolean Order){//初始化头结点
		this();
		if(Order)
			create1(n);
		else 
			create2(n);
	}
	//尾插法创建单链表
	public void create1(int n){
		Scanner sc=new Scanner(System.in);
		for(int j=0;j<n;j++){
			insert(this.length(),sc.next());
		}
	} 
	//头插法创建单链表
    public void create2(int n){
    	Scanner sc=new Scanner(System.in);
    	for(int j=0;j<n;j++){
			insert(0,sc.next());
		}
	}
	public void clear() {
			head.setData(null);
			head.setNext(null);

	}

	@Override
	public boolean isEmpty() {
		return head.getNext()==null;
	}

	@Override
	public int length() {
		int length=0;
		Node p=head.getNext();
		while(p!=null){
			length++;
			p=p.getNext();
		}
		return length;
	}

	@Override
	public Object get(int i) {
		Node p=head.getNext();
		//i的合法性
		if(i<0||p==null){
			try {
				throw new Exception("第"+i+"个数据元素不从在");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	
		for(int j=0;j<i&&p!=null;j++){
			p=p.getNext();
		}
		return p.getData();
	}

	@Override
	//在第i个数据元素以前插入
	public void insert(int i, Object x) {
		Node q=new Node (x);
		int j=-1;
		//判断I的合法性
		Node p=head;
		if(j>i-1||p==null){
			try {
				throw new Exception("插入位置不合法");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		for(;j<i-1;j++){
			p=p.getNext();
		}
		q.setNext(p.getNext());
		p.setNext(q);
	}
        //删除掉第i个数据元素 
	public void remove(int i) {
		Node p=head;
		for(int j=-1;j<i-1&&p!=null;j++){
			p=p.getNext();
		}
		p.setNext(p.getNext().getNext());
	}

	@Override
	public int indexOf(Object x) {
		Node p=head.getNext();
		int j=0;
		while(p!=null&&!p.getData().equals(x)){
			p=p.getNext();
			++j;
		}
		if(p!=null){
			return j;
		}else
			return -1;
	
	}

	@Override
	public void display() {
		Node p=head.getNext();
		while(p!=null){
			System.out.print(p.getData()+"  ");
			p=p.getNext();
		}
		System.out.println();

	}

}

         因为单链表 只须要一个头指针就能惟一标识它因此单链表的成员变量只需设置一个头指针便可

测试类

/*
 * Kiss_My_Love
 * xaut
 * 2012/8/26
 * */
package www.xaut.com.linkedlist;

public class TestLinkedList {


	public static void main(String[] args) {
		int n=10;
		LinkedList L=new LinkedList();
		for(int i=0;i<n;i++){
			L.insert(i, i);
		}
		L.display();
		System.out.println(L.length());
		System.out.println(L.get(5));
		L.remove(5);
		L.display();
		System.out.println(L.indexOf(9));

	}

}