java链表倒序

=============Node.java==================

 

import java.util.Random;

/**
 * 单个节点
 * @version 1.0
 * @author 点子二木
 * @date 2008-7-22
 * @right Copyright (C), 2008
 */
public class Node {
 public int value = 0;
 public Node next = null;

 public Node(int value) {
  this.value = value;
 }
 
 public Node(int value, Object obj) {
  this.value = value;
  
  Random r = new Random();
  int nextValue = r.nextInt(100);
  this.next = new Node(nextValue);
 }

}

 

 

 

================NodeLink.java========================

 

import java.util.Random;

/**
 * 链表
 * @version 1.0
 * @author 点子二木
 * @date 2008-7-22
 * @right Copyright (C), 2008
 */
public class NodeLink {

 private static final int NUM_RANDOM = 10;

 Node nodes[] = null;

 // 构造方法//
 public NodeLink(Node[] nodes) {
  this.nodes = nodes;
 }

 // /主方法/

 /**
  * 将链表倒序
  *
  * @return
  */
 private Node[] Reverse() {
  Node nodesRev[] = null;
  nodesRev = new Node[this.nodes.length];

  for (int i = 0; i < this.nodes.length; i++) {
   nodesRev[this.nodes.length - i - 1] = this.nodes[i];
   if (i >= 1) {
    nodesRev[this.nodes.length - i - 1].next = this.nodes[i - 1];
   } else if (i == 0) {
    nodesRev[nodes.length-1].next = this.nodes[nodes.length-1].next;
   }
  }
  return nodesRev;
 }

 /**
  * 打印链表
  *
  * @param nodes
  */
 private static void printLink(Node[] nodes) {
  boolean isNull = false;
  if (!isNull) {
   for (int i = 0; i < nodes.length; i++) {
    if (nodes[i].next != null) {
     System.out.println(" nodes[" + Integer.toString(i)
       + "]:value=" + nodes[i].value + "; next="
       + nodes[i].next.value);
    }
   }
  } else {
   System.out.println("无子节点");
  }
 }

 /**
  * @param args
  */
 public static void main(String[] args) {

  System.out.println("============Reverse NodeLink test================");

  // 利用随机函数定义一定数量的链表的值，由此创建的Point类实例存入一个数组中
  Node nodeArray[] = new Node[NUM_RANDOM];
  Random r = new Random();
  int value = 0;

  value = r.nextInt(100);
  nodeArray[0] = new Node(value, null);

  for (int i = 1; i < nodeArray.length; i++) {
   value = nodeArray[i - 1].next.value;
   nodeArray[i] = new Node(value, null);
  }

  System.out.println("Original List:");
  NodeLink.printLink(nodeArray);

  Node nodesRev[] = null;
  NodeLink nodeLink = new NodeLink(nodeArray);

  // 编程实现根据一个已存在的链表创建一个倒序链表。
  System.out.println("Reverse it:");
  nodesRev = nodeLink.Reverse();
  NodeLink.printLink(nodesRev);

 }

}

 

 

 

 

输出结果：

============Reverse NodeLink test================
Original List:
 nodes[0]:value=68; next=83
 nodes[1]:value=83; next=70
 nodes[2]:value=70; next=8
 nodes[3]:value=8; next=41
 nodes[4]:value=41; next=49
 nodes[5]:value=49; next=92
 nodes[6]:value=92; next=93
 nodes[7]:value=93; next=11
 nodes[8]:value=11; next=23
 nodes[9]:value=23; next=3
Reverse it:
 nodes[0]:value=23; next=11
 nodes[1]:value=11; next=93
 nodes[2]:value=93; next=92
 nodes[3]:value=92; next=49
 nodes[4]:value=49; next=41
 nodes[5]:value=41; next=8
 nodes[6]:value=8; next=70
 nodes[7]:value=70; next=83
 nodes[8]:value=83; next=68
 nodes[9]:value=68; next=3