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

2019独角兽企业重金招聘Python工程师标准>>>

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));

	}

}

转载于:https://my.oschina.net/u/267492/blog/74653