Java学习之单链表创建以及正向遍历和反向遍历方法

原创 2016年08月30日 21:42:55

链表是一种存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。原先是在C语言的学习中有遇到过,Java中的链表第一次遇到是在一家公司的面试题中。链表的种类有单链表、双端链表、有序链表,以下就单链表做一个简单的讨论。

1、创建数据节点

public class Node {
       publicint value;//节点标号
       publicNode next;//用于指向下一个节点的指针
      
       publicint getValue() {
              returnvalue;
       }
       publicvoid setValue(int value) {
              this.value= value;
       }
       publicNode getNext() {
              returnnext;
       }
       publicvoid setNext(Node next) {
              this.next= next;
       }
}


2、创建单链表以及遍历方法,正向遍历网上较多,所以以下提出了两种反向遍历方法 

public class NodeTest {
       Nodehead = null;
       Nodepoint = null;
       NodenewNode = null;
       Nodenod = null;
       publicstatic int CountNum = 0;
       publicstatic void main(String[] args){
     
              NodeTestnodeTest = new NodeTest();
              //添加节点数据
              //Stack<Node>stk = new Stack<Node>();
              for(intj = 0; j < 100; j++){
                     nodeTest.AddNode(j);
              }
             
              //显示节点数据
//          for(intn = 0;n < 100; n++){
//                 if(n== 0){
//                        nodeTest.nod= (Node)nodeTest.head;
//                        System.out.println(nodeTest.nod.value);
//                 }
//                 else{
//                        nodeTest.nod= (Node)nodeTest.nod.next;
//                        System.out.println(nodeTest.nod.value);
//                 }    
//          }
             
              //查找数据
//          Scannersim = new Scanner(System.in);
//          System.out.println("输入你所需要查找的node(0~99):");
//          intinput =  sim.nextInt();

              //正向遍历查找数据
//          for(intn = 0;n < 100; n++){
//                 if(n== 0){
//                        nodeTest.nod= (Node)nodeTest.head;
//                        if(input== nodeTest.nod.value){
//                               System.out.println(nodeTest.nod.value);
//                        }
//                 }
//                 else{
//                        nodeTest.nod= (Node)nodeTest.nod.next;
//                        if(input== nodeTest.nod.value){
//                               System.out.println(nodeTest.nod.value);
//                        }
//                 }    
//          }    
             
              //反向遍历方法一,栈
//          System.out.println("反向遍历:");
//          //nodeTest.printStack(stk);
//          Enumeration<Node>items = stk.elements();//得到栈中枚举
//          while(items.hasMoreElements()){
//                 Nodenode = (Node)items.nextElement();
//                 if(node.value== input){
//                        System.out.println(node.value+ ";;");
//                 }
//          }    
              search(nodeTest.head);
       }
             
      //反向遍历方法二,递归
       publicstatic  void search(Node nodeTest){
              if(nodeTest.next!=null) {
                     search(nodeTest.next);
                     System.out.println(nodeTest.value);
              }else{
                     return;
              }
       }
       //添加节点Stack<Node>stk
       publicvoid AddNode(int i){
              newNode= new Node();
              if(head== null){
                     head= newNode;
              }else{
                     if(CountNum== 1){
                            point= head;                  
                     }
                     point.next= newNode;
              }
              point= newNode;
              point.value= i;
              point.next= null;
              CountNum++;
             
              //stk.push(point);
       }
      
       publicvoid printStack(Stack<Node> stack){
              if(stack.empty()){
                     System.out.println("栈是空的");
              }else{
                     System.out.println("栈中的元素:");
                     Enumeration<Node>items = stack.elements();//得到栈中枚举
                     while(items.hasMoreElements()){
                            Nodenode = (Node)items.nextElement();
                            System.out.println(node.value+ ";;");
                           
                     }
              }
       }
}
 


不足之处望指正。



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

【Java】利用单链表遍历、队列通过广度优先搜索算法来求各个的连通分量

这里就不再用书上的大堆废话的来说,广度优先搜索算法就是遍历一个图所有点的算法,也就说要对图中的每一个点进行访问,访问之后你才能对点进行操作。由于你对一个图进行操作,那么你必须对图上的每个点进行操作,所...

单链表----定义、增加节点、删除节点、遍历输出(java)

单链表的结构比较简单,图示如下: 单链表有很多个节点构成。每个节点由指针域和数值域构成,指针指向下一个节点的数值域。最后一个节点的指针指向的是NULL。java实现单链表的一些基本的操作:packa...

单链表的各种操作——创建及遍历

链表动态地进行存储分配,可以适应数据动态地增减的情况,且可以方便地插入、删除数据项。

单链表的创建和遍历

//24 #include #include #include /* typedef struct Node{  int data;//数据域  struct Node *pNext;/...

C语言实现单链表的初始化、创建、遍历等操作

编译环境:VC++6.0 #include#includetypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;LinkL...

单链表的创建、遍历、测长、插入、删除、访问、排序、逆序

马上要找工作了,最近把数据结构复习了一下,从单链表开始,一点一点巩固。解析的内容太长就省了,直接贴出代码,需要说明的一点是,下面创建的单链表以及相关操作都是带头结点的。 typedef struct ...

数据结构——单链表的创建、删除、遍历以及节点的插入、删除等操作

1、创建一个结构体:创建一个包含自身结构的结构体,该结构体包含一个数据域和指针域 1、链表初始化:在链表的初始化过程中要为一个结点用malloc函数分配一个空间,并且时next指针指向一个NULL,...

C++实现单链表(Singly-Linked List)追加、遍历、删除

#include using namespace std; struct Node { int data; struct Node* next; }; class List { Node* ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)