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实现单链表,功能有插入,删除,遍历。

public class Code {private int data;private Code next;public int getData() { return data;}public voi...
  • raindew1985
  • raindew1985
  • 2007年06月27日 02:12
  • 3039

JAVA中关于链表的操作和基本算法

import java.util.HashMap; import java.util.Scanner; import java.util.Stack; /** * * @author Thin...
  • kerryfish
  • kerryfish
  • 2014年04月18日 19:36
  • 54001

java 数据结构 遍历链表程序

  • 2009年02月07日 18:26
  • 1KB
  • 下载

java链表的get方法遍历VS使用迭代器遍历

无论何种集合,应当允许用户以某种方式遍历集合,而不需要知道对象在集合中是如何表示及存储的,java集合框架为各种数据结构的集合,比如链表、散列表等都提供了迭代器。     某些集合根据其数据存储结构...
  • huacuo2013
  • huacuo2013
  • 2015年09月30日 15:05
  • 1059

Java实现循环单链表……

相比于C和C++,Java中没有了“结构”,因此就要使用类来描述“结构”,同样的,在实现链表时,就可以使用类来定义节点,然后进行相应的操作,以下是我实现循环单链表的代码,循环单链表和单链表的区别在于最...
  • iNiegang
  • iNiegang
  • 2015年10月06日 16:31
  • 3756

正向创建单向链表

正向创建链表,即采用”尾插法“。 数据集合: 10 20 30 40 50 60 目标:按数组的值,单向正向创建一个链表。 主要算法, 1.创建头结点 2.创建其他节点 ...
  • u013243347
  • u013243347
  • 2016年05月23日 14:52
  • 817

java 链表的常见操作

1.定义链表的节点类 class Node { protected Node next; // 下一节点 protected String data;// 数据 public Node(St...
  • kangaroo_07
  • kangaroo_07
  • 2017年08月30日 21:53
  • 205

Java算法之链表笔记记录

本篇主要介绍一种新的数据存储结构——链表。链表可能是继数组之后第二种使用得最广泛的通用存储结构。 链表的机制灵活,用途广泛,适用于许多通用数据库。它也可以取代数组,作为其他存储结构的基础,例如栈,队...
  • dingchenxixi
  • dingchenxixi
  • 2016年09月04日 13:55
  • 850

剑指offer 反向遍历链表

#include #include #include #include #include #include using namespace std; //链表的反遍历,利用栈 struc...
  • u014787301
  • u014787301
  • 2016年03月27日 20:47
  • 464

list循环正反向输出

import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class List...
  • yueyeqingshan
  • yueyeqingshan
  • 2016年07月20日 16:03
  • 788
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java学习之单链表创建以及正向遍历和反向遍历方法
举报原因:
原因补充:

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