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=headtemp.next!=tailtemp=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=headtemp!=nulltemp=temp.next){
//遍历整个链表
System.out.print(temp.info+"
")
//输出每个节点的信息
}
System.out.println()
//输出一个换行，可以没有这一行
}
public boolean isInList(int
el){
//判断el是否存在于链表中
IntNode
temp
//定义一个中间变量
for(temp=headtemp!=null
&&
temp.info!=eltemp=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.nexttemp.info!=el
&&
temp.next!=nullpred=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.nexttemp!=null
&&
temp.info!=el1pred=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))
}
}
你可能对链表的数据结构并不是很清楚 给你个写示例代码理解下，最好打个断点每一步跟踪理解一下//class ListNode {
// int val
// jdb.ListNode next
// ListNode(int x) { val = x }
//}
public class Main {
public static void main(String[] args) throws Exception {
//现在有一个链表1->2->3
ListNode listNode = new ListNode(1)
listNode.next = new ListNode(2)
listNode.next.next = new ListNode(3)
listNode.next.next.next = new ListNode(4)
//我们来打印一下
printListNode(listNode)
//我现在要在2后面插入9
boolean flag = insertVal(listNode, 3, 9)
System.out.println("是否插入成功:"+flag)
//再来打印一下
printListNode(listNode)
}
/**
*
* @param listNode//原链表
* @param pre//插入前的位置
* @param val//插入的值
*/
public static boolean insertVal(ListNode listNode,Integer pre, Integer val) {
boolean rs = false
//找插入前的位置
while (listNode != null && listNode.val != pre) {
listNode = listNode.next
}
if (listNode != null &&listNode.val==pre) {
//找到啦
//先把原链表后的数据保存起来 这边就是3->4
ListNode temp = listNode.next
//把要插入的值连上，再把原来保存的值连上
listNode.next = new ListNode(val)
listNode.next.next = temp
//上面代码中 listNode的值是2，listNode.next的值是9，listNode.next.next的值就是刚才保存的临时链表3->4
//插入成功标记一下哦
rs=true
}
return rs
}
/**
* 打印呀
* @param listNode
*/
public static void printListNode(ListNode listNode) {
if (listNode != null) {
ListNode temp = listNode
while (temp != null) {
System.out.println(temp.val)
temp = temp.next
}
}
System.out.println("-------------")
}
}
