java中关于链表操作

package 剑指offer;


import java.util.Stack;


/**  
 * @author guoliang 
 */ 
public class ReverseSingleList {   
public static void main(String [] args){
/**
* 构造一个含有是个元素的链表
*/
Node head = new Node(0);
Node temp = null;
Node cur = null;
for(int i = 1;i < 10;i++){
temp = new Node(i);
if(i != 1){
cur.setNextNode(temp);
}else{

head.setNextNode(temp);
}
cur = temp;
}

Node before = head;
while(before != null){
System.out.print(before.getRecord()+"   ");
before = before.getNextNode();
}

}
//向链首增加一个元素
public static Node AddToHead(Node head,int value){
Node newNode = new Node(value);
if(head == null)
{
head = newNode;
}
newNode.setNextNode(head.getNextNode());
head.setNextNode(newNode);
return head;
}
//向链表结尾添加一个元素
public static Node AddToTail(Node head,int value){
Node newNode = new Node(value);
newNode.setNextNode(null);
if(head == null){
head = newNode;
return head;
}
while(head.getNextNode() != null){
head = head.getNextNode();
}
head.setNextNode(newNode);
return head;
}
//删除一个元素，并返回所删除元素的data
public static int delete(Node head,int index){
//判断是否是一个空链表
if(head == null)return -1;
//循环到index-1处跳出循环,头指针不算，index从1开始
int count = 0;
while(head.getNextNode()!= null){
++count;
if(count == index)//跳出循环是指针指向index-1
break;
head = head.getNextNode();
}
if(count < index){//说明链表的长度小于index 等于的情况：要删除的长度刚好是链表的长度+1
return -1;
}
int elem = head.getNextNode().getRecord();//得到当前节点的下个节点的data域
head.setNextNode(head.getNextNode().getNextNode());

return elem;
}
//从尾到头输出链表，两种1先把链表反转，顺着输出  2：顺序存入到栈中，弹栈，这里采用第二种
public static Stack<Integer> printReverse(Node head){
Stack<Integer> nodeStack = new Stack<Integer>();
if(head == null){
nodeStack.push(-1);//这里以一个-1作为链空的标识
return nodeStack;
}
while(head.getNextNode() != null){
nodeStack.push(head.getNextNode().getRecord());
head = head.getNextNode();
}
return nodeStack;
}
//从尾到头输出链表，两种1先把链表反转，顺着输出  2：顺序存入到栈中，弹栈，
//这里采用第二种,实际上递归就是利用栈的性质，所以采用递归，上面的方法是非递归
public static void printReverse2(Node head){
if(head != null){
while(head.getNextNode() != null){
printReverse(head.getNextNode());
}
System.out.println(head.getRecord()+"\t");
}
}
//反转链表
public static Node reverse(Node head) {   
        if (null == head) {   
            return head;   
        }   
        Node pre = head;   
        Node cur = head.getNextNode();   
        Node next;   
        while (null != cur) {   
            next = cur.getNextNode();   
            cur.setNextNode(pre);   
            pre = cur;   
            cur = next;   
        }   
        //将原链表的头节点的下一个节点置为null，再将反转后的头节点赋给head      
        head.setNextNode(null);   
        head = pre;   
           
        return head;   
    }   

}  
class Node {   
    //变量   
    private int record;   
    //指向下一个对象   
    private Node nextNode;   
  
    public Node(int record) {   
       // super();   
        this.record = record;   
    }   
    public int getRecord() {   
        return record;   
    }   
    public void setRecord(int record) {   
        this.record = record;   
    }   
    public Node getNextNode() {   
        return nextNode;   
    }   
    public void setNextNode(Node nextNode) {   
        this.nextNode = nextNode;   
    }   

}   

//有什么问题可以联系我哦