Question

用Java语言实现单向链表

单向链表的实现：
1.链表的结点：
一个单向链表是一组结点(数据元素)的序列，每个结点有两个域：数据域和指针域。
2.指针：
指针域存放其后继结点的地址，最后一个结点的指针域为空。头指针head指向链表的第一个结点，当链表为空时，头指针为空值。
3.结点的数据域：
-数据域存放数据，可能是三角形、矩形、圆形三种形状中的任何一种。
-形状除了具有与大小有关的属性外，还有颜色属性。
4.链表需要实现的功能：
(1)生成链表；
-根据输入生成链表
-生成一条长度为6、节点中的形状随机、颜色随机、大小均为10的链表。（其中大小为10的含义是指：三角形或矩形的边长都为10，圆的半径都为10。）
(2)链表中结点的插入与删除；
(3)在链表中删掉某类(三角形、圆形、矩形)的结点
(4)将链表中具有某种颜色A的节点改为颜色B。

Answer 1

1.先定义一个节点类

package com.buren;

public class IntNode {
//定义一个节点类

int
info;
//定义属性，节点中的值
IntNode next;
//定义指向下一个节点的属性

public IntNode(int
i){ //构造一个next为空的节点
this(i,null);
}

public IntNode(int i,IntNode
n){ //构造值为i指向n的节点
info=i;
next=n;
}

}

2.再定义一个链表类，这是主要部分

package com.buren;

public class IntSLList {

private IntNode head,tail;
//定义指向头结点和尾结点的指针，
//如果大家看着这个不像指针的话，那就需要对指针有更深刻的了解

public
IntSLList(){
//定义一个空节点
head=tail=null;
}

public boolean
isEmpty(){
//判断节点是否为空
return
head==null;
//这行代码看起来似乎很神奇，其实真的很神奇，偶是服了
}

public void addToHead(int el){
//将el插入到头结点前
head=new
IntNode(el,head);
//将节点插入到头结点前，作为新的投节点
if(head==tail){
//给空链表插入节点时
tail=head;
//头结点和尾结点指向同一个节点
}
}

public void addToTail(int
el){
//向链表的尾部增加结点
if(!isEmpty()){
//判断链表是否为空
tail.next=new
IntNode(el);
//新建立一个值为el的节点，将链表的尾结点指向新节点
tail=tail.next;
//更新尾指针的指向
}else{
head=tail=new
IntNode(el);
//如果链表为空，新建立一个节点，将头尾指针同时指向这个节点
}
}

public int
deleteFromHead(){
//删除头结点，将节点信息返回
int
el=head.info;
//取出节点信息
if(head==tail){
//如果链表中只有一个节点
head=tail=null;
//删除这一个节点
}else{
head=head.next;
//如果链表中不止一个节点，将头结点的下一个节点作为头结点
}
return
el;
//返回原头结点的值
}

public int
deleteFromTail(){
//删除尾结点，返回尾结点的信息
int
el=tail.info;
//取出尾结点的值
if(head==tail){
// 如果链表中只有一个节点
head=tail=null;
//删除这个节点
}else{
IntNode
temp;
//定义中间变量
for(temp=head;temp.next!=tail;temp=temp.next);
//找出尾结点的前一个节点，注意最后的分号，

//这个for循环是没有循环体的，目的在于找出尾结点的前一个节点

//在整个程序中用了很多次这样的写法，相当经典啊
tail=temp;
//将找出来的节点作为尾结点，删除原来的尾结点
tail.next=null;
//将新尾结点的指向设为空
}
return
el;
//返回原尾结点的信息
}

public void
printAll(){
//打印链表中所有节点的信息
if(isEmpty()){
//如果链表为空
System.out.println("This
list is
empty!");
//输出提示信息
return;
//返回到调用的地方
}
if(head==tail){
//当链表中只有一个节点时
System.out.println(head.info);
//输出这个节点的信息，就是头结点的信息
return;
}
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null;temp=temp.next){
//遍历整个链表
System.out.print(temp.info+"
");
//输出每个节点的信息
}
System.out.println();
//输出一个换行，可以没有这一行
}

public boolean isInList(int
el){
//判断el是否存在于链表中
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null
&&
temp.info!=el;temp=temp.next);
//将el找出来，注意最后的分
return
temp!=null;
// 如果存在返回true，否则返回flase，这两行代码很有思想
}

public void delete(int
el){
//删除链表中值为el的节点
if(head.info==el
&&
head==tail){
//如果只有一个节点，并且节点的值为el
head=tail=null;
//删除这个节点
}else
if(head.info==el){
// 不止一个节点，而头结点的值就是el
head=head.next;
//删除头结点
}else{
IntNode
pred,temp;
//定义两个中间变量
for(pred=head,temp=head.next;temp.info!=el
&&
temp.next!=null;pred=pred.next,temp=temp.next);
//跟上面的类似，自己琢磨吧，也是要注意最后的分号
pred.next=temp.next;
//将temp指向的节点删除，最好画一个链表的图，有助于理解
if(temp==tail){
//如果temp指向的节点是尾结点
tail=pred;
//将pred指向的节点设为尾结点，
}
}
}

//下面这个方法是在链表中值为el1的节点前面插入一个值为el2的节点，
//用类似的思想可以再写一个在链表中值为el1的节点后面插入一个值为el2的节点
public boolean insertToList(int el1,int
el2){
//定义一个插入节点的方法，插入成功返回true，否则返回false
IntNode
pred,temp; //定义两个中间变量
if(isEmpty()){
//判断链表是否为空
return
false;
//如果链表为空就直接返回false
}
if(head.info==el1
&&
head==tail){
//如果链表中只有一个节点，并且这个节点的值是el1
head=new
IntNode(el2,head);
//新建立一个节点
return
true;
}else if(head.info==el1){
IntNode t=new
IntNode(el2);
t.next=head;
head=t;
return
true;
}else{
for(pred=head,temp=head.next;temp!=null
&&
temp.info!=el1;pred=pred.next,temp=temp.next);
if(temp!=null){
IntNode
a=new IntNode(el2);
pred.next=a;
a.next=temp;
return
true;
}else{
System.out.println(el1+"
NOT EXEISTS!");
return
false;
}
}
}

3.下面是测试代码
public static void main(String[] args){
IntSLList test=new
IntSLList();

//test.addToHead(7);
test.addToTail(7);

System.out.println(test.insertToList(7,5));
test.printAll();
System.out.println(test.isInList(123));
}
}

Answer 2

实现代码如下:

erface StackPK{
void Push(Object obj);
Object Pop;
boolean isEmpty;
Size;
}

public LinkStack implements StackPK{
private SLLNode{
private Object data;
private SLLNode next;
SLLNode{}
SLLNode(Object obj){
data=obj;
}

public void Data(Object o){
(onull)
throw IllegalArgumentException("object is null");
data=o;
}
public Object getData{
data;
}
public void Next(SLLNode n){
next=n;
}
public SLLNode getNext{
next;
}
public String toString{
(String)data;
}
}

private SLLNode top;
public LinkStack{
top=null;
}
public void Push(Object obj){
(objnull)
throw IllegalArgumentException("n is null");
(topnull)
{
SLLNode temp= SLLNode(obj);
top=temp;
}

{
SLLNode temp= SLLNode(obj);
temp.Next(top);
top=temp;
}
}
public Object Pop{
SLLNode temp;
(topnull)
throw IllegalArgumentException("stack is empty");
temp=top;
top=top.getNext;
temp.getData;
}
public boolean isEmpty{
(top null)
true;

false;
}
public Size{
SLLNode cnt;
cnt=top;
count=0;
(cnt null)
0;
while(cnt != null){
count;
cnt=cnt.getNext;
}
count;
}
public void (String args){
LinkStack ls= LinkStack;
Object arr= String{"liangming","gaojie","liangbing","wuxia","zhangjun"};
for( i=0;i<arr.length;i)
ls.Push(arr[i]);
while(ls.Size>0)
{
.out.prln(ls.Pop);
}
}
}