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;

}

}

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