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

源码下载