设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

java实现单链表、双向链表

2016-7-29 15:47| 发布者: zhangjf| 查看: 584| 评论: 0

摘要: 本文实例为大家分享了java实现单链表、双向链表的相关代码，供大家参考，具体内容如下 java实现单链表： package code; class Node { Node next; int data; public Node(int data) { this.data=data; } ...

本文实例为大家分享了java实现单链表、双向链表的相关代码，供大家参考，具体内容如下

java实现单链表：

  2. package code;
  4. class Node
  5. {
  6. Node next;
  7. int data;
  8. public Node(int data)
  9. {
  10. this.data=data;
  11. }
  13. }
  14. class LinkList
  15. {
  16. Node first;
  17. //头部
  18. public LinkList()
  19. {
  20. this.first=null;
  21. }
  22. public void addNode(Node no)
  23. {
  24. no.next=first;
  25. first=no;//在头部添加
  26. }
  27. public void delectNode()
  28. {
  29. Node n=first.next;
  30. first=null;
  31. first=n;//在头部删除
  32. }
  33. //删除指定位置
  34. public int Number()
  35. {
  36. int count=1;
  37. //查看有多少元素
  38. Node nd=first;
  39. while(nd.next!=null)
  40. {
  41. nd=nd.next;
  42. count++;
  43. }
  44. return count;
  45. }
  46. public void delectExact(int n)
  47. {
  48. //删除指定位置
  49. if(n>1)
  50. {
  51. int count=1;
  52. Node de=first;
  53. while(count<n-1)
  54. {
  55. de=de.next;
  56. count++;
  58. }
  59. de.next=de.next.next;
  60. }
  61. else
  62. first=first.next;
  64. }
  65. public void addExact(int n,Node nd)
  66. {
  67. if(n>1)//添加指定位置
  68. {
  69. int count=1;
  70. Node de=first;
  71. while(count<n-1)
  72. {
  73. de=de.next;
  74. count++;
  76. }
  77. nd.next=de.next;
  78. de.next=nd;
  80. }
  81. else
  82. first=first.next;
  83. }
  84. public int findNode(int n)
  85. {
  86. int count=1;//查找一个数对应的位置
  87. Node de=first;
  88. while(de.data!=n)
  89. {
  90. de=de.next;
  91. count++;
  92. if(de==null)
  93. {
  94. return -1;
  95. }
  96. }
  97. return count;
  98. }
  99. public void print()
  100. {
  101. Node no=first;//打印所有
  102. while(no!=null)
  103. {
  104. System.out.println(no.data);
  105. no=no.next;
  106. }
  107. }
  108. }
  109. public class TextNode
  110. {
  111. public static void main(String[] args)
  112. {
  113. LinkList ll=new LinkList();
  114. ll.addNode(new Node(12));
  115. ll.addNode(new Node(15));
  116. ll.addNode(new Node(18));
  117. ll.addNode(new Node(19));
  118. ll.addNode(new Node(20));
  119. /*System.out.println(ll.first.data);
  121. ll.delectNode();
  122. System.out.println(ll.first.data);*/
  123. System.out.println(ll.Number());
  124. ll.delectExact(3);
  125. ll.addExact(3, new Node(100));
  126. System.out.println(ll.Number());
  127. // ll.print();
  128. System.out.println(ll.findNode(112));
  130. }
  131. }
复制代码

java实现双向链表：

  2. public class DoubleLink
  3. {
  4. public static void main(String[]args)
  5. {
  6. Node2 no=new Node2(5);
  7. no.addLeft(new Node2(6));
  8. no.addRight(new Node2(7));
  9. /*no.print();
  10. no.print2();*/
  11. no.addExact2(1, new Node2(8));
  12. no.print();
  13. System.out.println("--------------");
  14. no.print2();
  15. }
  16. }
  17. class Node2
  18. {
  19. public Node2 first;
  20. public Node2 end;
  21. public Node2 left;
  22. public Node2 right;
  23. int data=0;
  24. public Node2(int n)
  25. {
  27. first=this;
  28. end=this;
  30. first.data=n;
  31. }
  32. //从头部添加
  33. public void addLeft(Node2 before)
  34. {
  35. first.left=before;
  36. before.right=first;
  37. first=before;
  38. }
  39. //从尾部添加
  40. public void addRight(Node2 after)
  41. {
  42. end.right=after;
  43. after.left=end;
  44. end=after;
  45. }
  46. //插入正数(第三声)的第几个
  47. public void addExact(int n,Node2 no)
  48. {
  49. int count=0;
  50. if(n==0)
  51. {
  52. addLeft(no);
  53. }
  54. else
  55. {
  56. Node2 f=first;
  57. while(true)
  58. {
  59. f=f.right;
  60. count++;
  61. if(count==n)
  62. {
  63. //此处为四个指针的指向的变化
  64. no.left=f.left;
  65. f.left.right=no;
  66. // first.left=no;
  67. no.right=f;
  68. f.left=no;
  69. break;
  70. }
  72. }
  73. }
  74. }
  75. //插入倒数的第几个
  76. public void addExact2(int n,Node2 no)
  77. {
  78. int count=0;
  79. if(n==0)
  80. {
  81. addRight(no);
  82. }
  83. else
  84. {
  85. Node2 f=end;
  86. while(true)
  87. {
  88. f=f.left;
  89. count++;
  90. if(count==n)
  91. {
  93. no.left=f;
  94. no.right=f.right;
  95. f.right.left=no;
  96. f.right=no;
  97. break;
  99. }
  100. }
  101. }
  102. }
  103. //正序遍历
  104. public void print()
  105. {
  106. System.out.println(first.data);
  107. while(first.right!=null)
  108. {
  109. System.out.println(first.right.data);
  110. first=first.right;
  111. }
  112. // System.out.println(end.data);
  113. }
  114. //倒序遍历
  115. public void print2()
  116. {
  117. System.out.println(end.data);
  118. while(end.left!=null)
  119. {
  120. System.out.println(end.left.data);
  121. end=end.left;
  122. }
  123. }
  126. }
  127. /*值得注意的是，每一次插入一个新的对象的时候，需要注意指针指向的改变。
  128. 首先是这个新的对象两边的指向（左和右），其次是时左边的对象向右的指向
  129. 和右边对象向左的指向。
  130. 这四个指针的指向必须正确，否则可能导致正序或者倒序遍历无法实现。
  131. */
  132. /*对比单链表，单链表只能从一个方向遍历，因为只有一个头，而双向链表，有头和尾，可以从
  133. * 头遍历，也可以从尾遍历，而且其中一个对象因为有两个方向的指针，所以他可以获得左边的
  134. * 对象也可以获得右边的对象。
  135. * 但是单链表的话，因为只有一个方向，所以只能向左或右。添加对象的时候，双向也可以从头添加，也可以从尾添加。
  136. * 如果单链表要实现两个方向添加比较难得，或者说不行，因为他只有向左或向右的一个方向的指针
  137. * 而双向链表每个对象都有两个方向的指针没这样更灵活，但是这同样有缺点，因为这样的话每个对象
  138. * 都会包含两个指针，这同样内存会消耗更多。
  139. *
  140. * */
复制代码

以上就是本文的全部内容，希望对大家学习java程序设计有所帮助。

收藏 邀请
上一篇：批量查询快递单号下一篇：Java中常见的URL问题及解决方案

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-6 15:59

Copyright 2015-2025 djqfx

返回顶部