《数据结构Java版》线性表之单链表的建立及操作

《数据结构Java》线性表之单链表的建立及操作

package sjjg3;

//单链表结点类，T指定结点的元素类型

public class Node {

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

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

public Node(T data,Node next) {//构造结点，data指定数据元素，next指定后继结点

this.data=data;//T对象引用赋值

this.next=next;//Node对象引用赋值

}

public Node() {

this(null, null);

}

public String toString() {//返回结点数据域的描述字符串

return this.data.toString();

}

}

package sjjg3;

//单链表类，实现ADT List声明方法，T表示数据元素的数据类型

public class SinglyList extends Object{

public Node head;//头指针，指向单链表的头结点

//（1）构造方法

public SinglyList() {//构造空单链表

this.head=new Node();//创建头结点，data和next值均为null }

public SinglyList(T[] values) {//构造单链表，由values数组提供元素this();//创建空单链表，只有头结点

Node rear=this.head;//rear指向单链表最后一个结点

for(int i=0;i(values[i],null);//尾插入，创建结点链入rear结点之后

rear=rear.next;//rear指向新的链尾结点

}

}

public boolean isEmpty() {//判断单链表是否空，O(1)

return this.head.next==null;

}

//（2）存取

public T get(int i) {//返回第i个元素，0<=i<表长度。若i越界，则返回null。O(n)

Node p=this.head.next;

for(int j=0;p!=null && j

return(i>=0 && p!=null)?p.data:null;//若p指向第i个结点，返回其元素值}

public void set(int i,T x) {//设置第i个元素为x，0<=i<表长度，x!=null。

}

public int size() {//返回单链表长度，O(n)。

Node p=head;

int count=0;

while(p!=null) {

count++;

p=p.next;

}

return count;

}

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

public String toString() {

String str=this.getClass().getName()+"(";//返回类名

for(Node p=this.head.next;p!=null;p=p.next) {//p遍历单链表

str+=p.data.toString();

if(p.next!=null)

str+=",";//不是最后一个结点时，加分隔符

}

return str+")";//空表返回()

}

//（3）插入

//插入x作为第i个元素，x!=null,返回插入结点

//对序号i采取容错措施，若i<0，则插入x在最前；若i>n，则插入x在最后。O(n) public Node insert(int i,T x){

if(x==null)

throw new NullPointerException("x==null");//抛出空对象异常Node front=this.head;//front指向头结点

for(int j=0;front.next!=null && j

front=front.next;

front.next=new Node(x,front.next);//在front之后插入值为x的结点

return front.next;//返回插入结点

}

public Node insert(T x){//在单链表最后添加x对象，O(n)

//调用insert(i,x)，用整数最大值指定插入在最后，遍历一次，i必须容错

return insert(Integer.MAX_VALUE,x);

}

//（4）删除

public T remove(int i) {//删除第i个元素，0<=i

则返回null。O(n)

Node front=this.head;//front指向头结点

for(int j=0;front.next!=null && j

if(i>=0 && front.next!=null) {//若front的后继结点存在，则删除之T old=front.next.data;//获得待删除结点引用的对象

front.next=front.next.next;//删除front的后继，包括头删除，中间/尾删除

//由Java虚拟机稍后释放结点占用的存储单元

return old;

}

return null;//若i<0或i>表长

}

public void clear() {//删除单链表所有元素

this.head.next=null;//Java自动收回所有结点占用的存储空间}

//（5）查找

public Node search(T key){//查找返回首个与key相等元素结点，查找不成功返回null

for(Node p=head.next;p!=null;p=p.next)

if(key.equals(p.data))

return p;

return null;

}

public boolean contains(T key){//判断是否包含关键字为key元素

Node p = null;

return this.search(key)!=p;

}

}

package sjjg3;

public class SinglyTest {

public static void main(String[] args) {

Node i;

String values[] = {"A","B","C","D","E","F"};

SinglyList list = new SinglyList(values);

Integer values1[] = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

SinglyList list1 = new SinglyList(values1);

Integer values2[] = { 100, 11, 22, 33, 44, 55, 66, 77, 88, 99 };

SinglyList list2 = new SinglyList(values2);

System.out.println("更改前的顺序表:");

System.out.println(list.toString());

System.out.println(list1.toString());

System.out.println(list2.toString());

list.insert(3,"K");

System.out.print("插入后的顺序表:");

System.out.println(list.toString());

list1.remove(4);

System.out.print("删除后的顺序表:");

System.out.println(list1.toString());

i=list2.search(100);

System.out.print("查找结果：");

if(i!=null)

System.out.print(true);

else

System.out.print(false);

}

}