java 数据结构之单链表

例子

package com.hh.singlylinkedlist;

/**

* 单链表的结点类

* @author user

*

* @param <T>

*/

public class Node<T> {

public T data; //数据域，保存数据元素

public Node<T> next; //地址域，引用后继结点

public Node(){

this(null, null);

}

public Node(T data, Node<T> next){

this.data = data;

this.next = next;

}

}

package com.hh.singlylinkedlist;

/**

* 线性表接口

* @author user

*

*/

public interface LList<T> {

boolean isEmpty(); //判断线性表是否为空

int length(); //返回线性表的长度

T get(int i); //返回第i（i>=0）个元素

void set(int i, T x); //设置第i个元素值为x

void insert(int i, T x);//插入x作为第i个元素

void append(T x); //在线性表最后插入x元素

T remove(int i); //删除第i个元素并返回被删除对象

void removeAll();//删除线性表所有元素

T search(T key); //查找，返回首次出现的关键字为key元素

}

package com.hh.singlylinkedlist;

/**

* 带头结点单链表类

* @author user

*

* @param <T>

*/

public class SinglyLinkedList<T> implements LList<T>{

protected Node<T> head; //头指针，指向单链表的

//默认构造方法，构造空的单链表，创建头结点，data和next值均为null

public SinglyLinkedList() {

this.head = new Node<T>();

}

//指定数组中的多个对象构造单链表，采用尾插入构造单链表

public SinglyLinkedList(T[] element){

//创建空单链表，只有头结点

this();

if(element == null){

return;

}

//rear指向单链表最后一个结点（这里指的是头结点）

Node<T> rear = this.head;

for(int i=0; i<element.length; i++){

//尾插入，创建结点链入rear结点之后

rear.next = new Node<T>(element[i],null);

//rear指向新的链尾结点

rear = rear.next;

}

}

//判断单链表是否为空

@Override

public boolean isEmpty() {

return this.head.next == null;

}

@Override

public int length() {

int i=0;

Node<T> p = this.head.next; //p从单链表第一个结点开始

while(p != null){ //判断单链表是否结束了

i++;

p = p.next; //p到达后继结点

}

return 0;

}

//返回单链表所有元素的描述字符串，形式为"(,)",覆盖Object类的toString()方法，O(n)

@Override

public String toString() {

String str = "(";

Node<T> p = this.head.next;

while(p != null){

str += p.data.toString();

p = p.next;

if(p != null){

str += ",";

}

}

return str + ")";

}

//返回第i(i>=0)个元素，若i指定序号无效，则返回null

@Override

public T get(int i) {

if(i >=0){

Node<T> p = this.head;

for(int j =0; p != null && j<i; j++){

p = p.next;

}

if(p != null){

return p.data;

}

}

return null;

}

//设置第i(i>=0)个元素值为x，若i指定序号无效，则抛出序号越界异常

@Override

public void set(int i, T x) {

if(x == null){

return;

}

if(i >=0){

Node<T> p = this.head.next;

for(int j=0; p != null && j<i; j++){

p = p.next;

}

if(p != null){

p.data = x;

}

}else{

throw new IndexOutOfBoundsException(i+"");

}

}

//将x对象插入在序号为i结点前

@Override

public void insert(int i, T x) {

if(x == null){

return;

}

Node<T> p = this.head; //p指向头结点

for(int j=0; p.next != null && j<i; j++){

p = p.next;

}

p.next = new Node<T>(x,p.next);

}

@Override

public void append(T x) {

insert(Integer.MAX_VALUE, x);

}

@Override

public T remove(int i) {

if(i>=0){

Node<T> p = this.head;

for(int j=0; p.next != null && j<i; j++){

p = p.next;

}

if(p.next != null){

T old = p.next.data;

p.next = p.next.next;

return old;

}

}

return null;

}

@Override

public void removeAll() {

this.head.next = null;

}

//查找某个元素是否存在

@Override

public T search(T key) {

if(key == null){

return null;

}

Node<T> p = this.head.next;

while(p != null){

if(p.data.equals(key)){

return p.data;

}

p = p.next;

}

return null;

}

}

package com.hh.singlylinkedlist;

public class TestMain {

public static void main(String[] args) {

String[] strArr = {"1","2","3","4","5","6","7","8","9","10",

"11","12","13","14","15","16"};

SinglyLinkedList<String> bean = new SinglyLinkedList<String>(strArr);

String str = bean.toString();

System.out.println("原数组内容："+str);

int i = 5;

str = bean.get(i);

System.out.println("获取第"+i+"元素值："+str);

bean.insert(i, "55");

System.out.println("在第"+i+"位置插入数据后的数组："+bean.toString());

str = bean.remove(i);

System.out.println("删除的元素："+ str );

System.out.println("在第"+i+"位置删除数据后的数组："+bean.toString());

str = bean.search("8");

System.out.println("查找第8个元素的值为："+str);

}

}

源码下载