devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

日撸Java三百行（day13：链表）

作者：码创造者 | 2024-08-05 19:00:57

赞

踩

日撸Java三百行（day13：链表）

目录

一、链表的基础知识

二、链表的代码实现

1.链表创建

2.链表遍历

3.链表定位查找

4.链表插入

5.链表删除

6.数据测试

7.完整的程序代码

总结

一、链表的基础知识

在之前顺序表的学习中，我们其实提到过链表。链表它是线性表在不同的物理存储方式下派生出来的，链表不像顺序表，它的数据元素在物理存储结构上并不连续，其数据元素的逻辑顺序是通过链表中的引用链接次序实现的，总结一下就是链表在逻辑上连续，在物理上不连续。

链表中的每一个元素称为结点，因此链表其实是由一系列结点组成的。而每个结点包括两个部分：一个是存储数据元素的数据域data，另一部分则是存储下一个结点地址的指针域next，通过这个指针域我们就可以轻松访问到当前结点的下一个结点，直到某个结点的next域为null。这样，就相当于把所有的结点都串联起来，进行链式访问，所以叫做“链表”。图解如下：

在实际情况中，链表可以分为：

  • 单向or双向

  • 循环or非循环

  • 带头or不带头

组合起来，一共就有8种链表。 

二、链表的代码实现

与顺序表一样，链表也可以进行初始化、查找、插入、删除等操作，下面我们通过java来实现。

1.链表创建

在day11（顺序表一）中，我们学习了类和对象的相关知识，包括如何定义一个类、如何创建对象、如何使用对象等，基于此，我们在定义的链表类中再创建一个结点类，同时定义该结点类的成员变量（data、next）和成员方法，如下：

  1. public class LinkedList {
  2.  
  3. 	/**
  4. 	 * An inner class.
  5. 	 */
  6. 	class Node {
  7. 		/**
  8. 		 * The data.
  9. 		 */
  10. 		int data;
  11.  
  12. 		/**
  13. 		 * The reference to the next node.
  14. 		 */
  15. 		Node next;
  16.  
  17. 		/**
  18. 		 ******************* 
  19. 		 * The constructor
  20. 		 * 
  21. 		 * @param paraValue
  22. 		 *            The data.
  23. 		 ******************* 
  24. 		 */
  25. 		public Node(int paraValue) {
  26. 			data = paraValue;
  27. 			next = null;
  28. 		}// Of the constructor
  29. 	}// Of class Node

在上述代码中，我们有两个需要注意的问题：

  • 这里的结点类是一个内部类inner class，根据链表的基本概念，我们知道链表是由若干个结点组成，而结点又由data域和next域组成，所以其符合内部类的定义（如果外部类是由若干完整的类组成，那么这些若干完整的类就可以定义为内部类）
  • 在定义成员变量next时，使用的是Node引用，这是因为next所指向的是下一个结点的地址，而结点始终是Node类型，所以我们用Node来定义next

然后，我们再定义一个头结点，并通过new为其分配内存空间，代码如下：

  1.     /**
  2. 	 * The header node. The data is never used.
  3. 	 */
  4. 	Node header;
  5.  
  6. 	/**
  7. 	 *********************
  8. 	 * Construct an empty linked list.
  9. 	 *********************
  10. 	 */
  11. 	public LinkedList() {
  12. 		header = new Node(0);
  13. 		//header.next = null; //Redundant
  14. 	}// Of the first constructor

为什么这里要单独把头结点header拿出来定义呢？一方面是因为header是链表的特征，而不是结点的；另一方面是因为头结点的数据域data是无效的，不存放任何数据元素。

2.链表遍历

与顺序表一样，我们同样可以重写toString()方法来遍历输出链表，如下：

  1.     /**
  2. 	 *********************
  3. 	 * Overrides the method claimed in Object, the superclass of any class.
  4. 	 *********************
  5. 	 */
  6. 	public String toString() {
  7. 		String resultString = "";
  8.  
  9. 		if (header.next == null) {
  10. 			return "empty";
  11. 		} // Of if
  12.  
  13. 		Node tempNode = header.next;
  14. 		while (tempNode != null) {
  15. 			resultString += tempNode.data + ", ";
  16. 			tempNode = tempNode.next;
  17. 		} // Of while
  18.  
  19. 		return resultString;
  20. 	}// Of toString

根据之前学过的如何使用一个对象，可以知道if语句中的header.next（对象名.成员变量）即表示头结点后的下一个结点的地址，如果其等于null，那么该链表显然为空，所以我们需要提前排除这种情况；排除后，我们将头结点后的下一个结点定义为tempNode（结点始终是Node类型，所以用Node定义）；再通过while循环进行迭代，其中tempNode.data（对象名.成员变量）表示该结点所存放的数据，而tempNode = tempNode.next;则实现了对象的迭代，相当于由指向前一个结点移动为指向下一个结点，即可访问下一个结点的相关数据，这其实与数组中索引值递增的作用有点类似；最后通过循环条件tempNode != null来控制，当tempNode = null即到达最后一个结点时结束。

3.链表定位查找

其实链表定位查找方法创建的大体思路和顺序表没有什么差别，都是通过循环遍历，将现有的数据元素与目标元素一一比较，最大的不同就是遍历方式发生了改变，代码如下：

  1.     /**
  2. 	 *********************
  3. 	 * Locate the given value. If it appears in multiple positions, simply
  4. 	 * return the first one.
  5. 	 * 
  6. 	 * @param paraValue
  7. 	 *            The given value.
  8. 	 * @return The position. -1 for not found.
  9. 	 *********************
  10. 	 */
  11. 	public int locate(int paraValue) {
  12. 		int tempPosition = -1;
  13.  
  14. 		Node tempNode = header.next;
  15. 		int tempCurrentPosition = 0;
  16. 		while (tempNode != null) {
  17. 			if (tempNode.data == paraValue) {
  18. 				tempPosition = tempCurrentPosition;
  19. 				break;
  20. 			} // Of if
  21.  
  22. 			tempNode = tempNode.next;
  23. 			tempCurrentPosition++;
  24. 		} // Of while
  25.  
  26. 		return tempPosition;
  27. 	}// Of locate
  • 第一步，我们同样设置一个非法值-1，它的作用就是当在链表中没有找到目标元素时（包括链表为空、链表不为空但遍历完后没有找到目标元素这两种情况），返回非法值-1
  • 第二步，定义头结点后的下一个结点，并定义此结点的下标为0（因为前面说过头结点的data域不存放数据，所以头结点后的下一个结点相当于是第一个有效的结点，所以将其下标定为0）
  • 第三步，利用while循环进行遍历，将链表中的数据元素tempNode.data与目标元素paraValue一一比对：如果相等就将此时数据元素的下标赋给tempPosition，然后通过break语句跳出循环，再返回tempPosition的值；如果不等就通过tempNode = tempNode.next进行迭代，继续遍历

4.链表插入

由于链表在物理存储结构上不一定连续，所以它不用像顺序表那样通过大段元素移动覆盖的方式间接完成插入、删除等操作。链表的插入只需要创建一个新的结点，然后修改该新结点插入位置前后的引用链接次序即可，图解如下（图源网络）：

根据图示，要完成链表插入，大体上可以分为三步：

  • 第一步，创建一个新的结点
  • 第二步，找到指定插入位置的前一个结点
  • 第三步，修改该指定插入位置前后的指针指向

代码如下： 

  1.     /**
  2. 	 *********************
  3. 	 * Insert a value to a position. If the list is already full, do nothing.
  4. 	 * 
  5. 	 * @param paraPosition
  6. 	 *            The given position.
  7. 	 * @param paraValue
  8. 	 *            The given value.
  9. 	 * @return Success or not.
  10. 	 *********************
  11. 	 */
  12. 	public boolean insert(int paraPosition, int paraValue) {
  13. 		Node tempNode = header;
  14. 		Node tempNewNode;
  15.  
  16. 		for (int i = 0; i < paraPosition; i++) {
  17. 			if (tempNode.next == null) {
  18. 				System.out.println("The position " + paraPosition + " is illegal.");
  19. 				return false;
  20. 			} // Of if
  21.  
  22. 			tempNode = tempNode.next;
  23. 		} // Of for i
  24.  
  25. 		// Construct a new node.
  26. 		tempNewNode = new Node(paraValue);
  27.  
  28. 		// Now link them.
  29. 		tempNewNode.next = tempNode.next;
  30. 		tempNode.next = tempNewNode;
  31.  
  32. 		return true;
  33. 	}// Of insert

第一步没什么好说的，直接创建即可；第二步中，我们需要提前考虑指定插入位置是否合法，这里将tempNode.next == null是否成立作为判断条件；确定插入位置合法之后，我们通过tempNode = tempNode.next;进行迭代，再利用i < paraPosition控制循环，使得到达指定插入位置的前一个结点；而第三步的修改链接次序，参考上图的解释就好。

5.链表删除

和链表插入同样的思想，链表删除也是通过修改链接次序来实现，不过链表删除还要更简单一点，只需要删掉目标位置前后的链接，再增加目标位置前一个结点与目标位置后一个结点之间的链接即可，图解如下（图源网络）：

由于链表删除不需要创建新的结点，所以只需要两步：

  • 第一步，找到目标位置的前一个结点
  • 第二步，修改目标位置前后的链接次序

代码如下：

  1.     /**
  2. 	 *********************
  3. 	 * Delete a value at a position.
  4. 	 * 
  5. 	 * @param paraPosition
  6. 	 *            The given position.
  7. 	 * @return Success or not.
  8. 	 *********************
  9. 	 */
  10. 	public boolean delete(int paraPosition) {
  11. 		if (header.next == null) {
  12. 			System.out.println("Cannot delete element from an empty list.");
  13. 			return false;
  14. 		} // Of if
  15.  
  16. 		Node tempNode = header;
  17.  
  18. 		for (int i = 0; i < paraPosition; i++) {
  19. 			if (tempNode.next.next == null) {
  20. 				System.out.println("The position " + paraPosition + " is illegal.");
  21. 				return false;
  22. 			} // Of if
  23.  
  24. 			tempNode = tempNode.next;
  25. 		} // Of for i
  26.  
  27. 		tempNode.next = tempNode.next.next;
  28.  
  29. 		return true;
  30. 	}// Of delete

在执行第一步之前，我们需要考虑两个问题，第一个问题是链表是否为空，第二个问题是目标位置是否合法。对于第一个问题，直接用一个if语句进行判断即可，当header.next = null时，头节点的后一个节点的地址为null，也就是第一个有效结点的地址为null，此时链表显然为空，所以返回false；而第二个问题，需要注意与链表插入不一样，此时的判断条件不再是tempNode.next == null，而是tempNode.next.next == null。解决以上两个问题后，就可以利用tempNode = tempNode.next;进行遍历，直到找到目标位置的前一个结点。

对于第二步的修改链接次序，只需要令tempNode.next = tempNode.next.next;即可，这里的temp.next.next其实就是目标位置后一个结点的地址，将该地址赋给tempNode.next（即目标位置前一个结点的next域），这样就把目标位置前一个结点与目标位置后一个结点链接起来了，也就实现了链表删除操作。

6.数据测试

方法创建完成后，我们来进行一些数据测试，如下：

  1.     /**
  2. 	 *********************
  3. 	 * The entrance of the program.
  4. 	 * 
  5. 	 * @param args Not used now.
  6. 	 *********************
  7. 	 */
  8. 	public static void main(String args[]) {
  9. 		LinkedList tempFirstList = new LinkedList();
  10. 		System.out.println("Initialized, the list is: " + tempFirstList.toString());
  11.  
  12. 		for (int i = 0; i < 5; i++) {
  13. 			tempFirstList.insert(0, i);
  14. 		} // Of for i
  15. 		System.out.println("Inserted, the list is: " + tempFirstList.toString());
  16.  
  17. 		tempFirstList.insert(6, 9);
  18.  
  19. 		tempFirstList.delete(4);
  20.  
  21. 		tempFirstList.delete(2);
  22. 		System.out.println("Deleted, the list is: " + tempFirstList.toString());
  23.  
  24. 		tempFirstList.delete(0);
  25. 		System.out.println("Deleted, the list is: " + tempFirstList.toString());
  26.  
  27. 		for (int i = 0; i < 5; i++) {
  28. 			tempFirstList.delete(0);
  29. 			System.out.println("Looped delete, the list is: " + tempFirstList.toString());
  30. 		} // Of for i
  31. 	}// Of main

7.完整的程序代码

  1. package datastructure.list;
  2.  
  3. /**
  4.  * Linked list.
  5.  * 
  6.  * @author Xin Lin 3101540094@qq.com.
  7.  */
  8.  
  9. public class LinkedList {
  10.  
  11. 	/**
  12. 	 * An inner class.
  13. 	 */
  14. 	class Node {
  15. 		/**
  16. 		 * The data.
  17. 		 */
  18. 		int data;
  19.  
  20. 		/**
  21. 		 * The reference to the next node.
  22. 		 */
  23. 		Node next;
  24.  
  25. 		/**
  26. 		 ******************* 
  27. 		 * The constructor
  28. 		 * 
  29. 		 * @param paraValue
  30. 		 *            The data.
  31. 		 ******************* 
  32. 		 */
  33. 		public Node(int paraValue) {
  34. 			data = paraValue;
  35. 			next = null;
  36. 		}// Of the constructor
  37. 	}// Of class Node
  38.  
  39. 	/**
  40. 	 * The header node. The data is never used.
  41. 	 */
  42. 	Node header;
  43.  
  44. 	/**
  45. 	 *********************
  46. 	 * Construct an empty linked list.
  47. 	 *********************
  48. 	 */
  49. 	public LinkedList() {
  50. 		header = new Node(0);
  51. 		//header.next = null; //Redundant
  52. 	}// Of the first constructor
  53.  
  54. 	/**
  55. 	 *********************
  56. 	 * Overrides the method claimed in Object, the superclass of any class.
  57. 	 *********************
  58. 	 */
  59. 	public String toString() {
  60. 		String resultString = "";
  61.  
  62. 		if (header.next == null) {
  63. 			return "empty";
  64. 		} // Of if
  65.  
  66. 		Node tempNode = header.next;
  67. 		while (tempNode != null) {
  68. 			resultString += tempNode.data + ", ";
  69. 			tempNode = tempNode.next;
  70. 		} // Of while
  71.  
  72. 		return resultString;
  73. 	}// Of toString
  74.  
  75. 	/**
  76. 	 *********************
  77. 	 * Reset to empty. Free the space through garbage collection.
  78. 	 *********************
  79. 	 */
  80. 	public void reset() {
  81. 		header.next = null;
  82. 	}// Of reset
  83.  
  84. 	/**
  85. 	 *********************
  86. 	 * Locate the given value. If it appears in multiple positions, simply
  87. 	 * return the first one.
  88. 	 * 
  89. 	 * @param paraValue
  90. 	 *            The given value.
  91. 	 * @return The position. -1 for not found.
  92. 	 *********************
  93. 	 */
  94. 	public int locate(int paraValue) {
  95. 		int tempPosition = -1;
  96.  
  97. 		Node tempNode = header.next;
  98. 		int tempCurrentPosition = 0;
  99. 		while (tempNode != null) {
  100. 			if (tempNode.data == paraValue) {
  101. 				tempPosition = tempCurrentPosition;
  102. 				break;
  103. 			} // Of if
  104.  
  105. 			tempNode = tempNode.next;
  106. 			tempCurrentPosition++;
  107. 		} // Of while
  108.  
  109. 		return tempPosition;
  110. 	}// Of locate
  111.  
  112. 	/**
  113. 	 *********************
  114. 	 * Insert a value to a position. If the list is already full, do nothing.
  115. 	 * 
  116. 	 * @param paraPosition
  117. 	 *            The given position.
  118. 	 * @param paraValue
  119. 	 *            The given value.
  120. 	 * @return Success or not.
  121. 	 *********************
  122. 	 */
  123. 	public boolean insert(int paraPosition, int paraValue) {
  124. 		Node tempNode = header;
  125. 		Node tempNewNode;
  126.  
  127. 		for (int i = 0; i < paraPosition; i++) {
  128. 			if (tempNode.next == null) {
  129. 				System.out.println("The position " + paraPosition + " is illegal.");
  130. 				return false;
  131. 			} // Of if
  132.  
  133. 			tempNode = tempNode.next;
  134. 		} // Of for i
  135.  
  136. 		// Construct a new node.
  137. 		tempNewNode = new Node(paraValue);
  138.  
  139. 		// Now link them.
  140. 		tempNewNode.next = tempNode.next;
  141. 		tempNode.next = tempNewNode;
  142.  
  143. 		return true;
  144. 	}// Of insert
  145.  
  146. 	/**
  147. 	 *********************
  148. 	 * Delete a value at a position.
  149. 	 * 
  150. 	 * @param paraPosition
  151. 	 *            The given position.
  152. 	 * @return Success or not.
  153. 	 *********************
  154. 	 */
  155. 	public boolean delete(int paraPosition) {
  156. 		if (header.next == null) {
  157. 			System.out.println("Cannot delete element from an empty list.");
  158. 			return false;
  159. 		} // Of if
  160.  
  161. 		Node tempNode = header;
  162.  
  163. 		for (int i = 0; i < paraPosition; i++) {
  164. 			if (tempNode.next.next == null) {
  165. 				System.out.println("The position " + paraPosition + " is illegal.");
  166. 				return false;
  167. 			} // Of if
  168.  
  169. 			tempNode = tempNode.next;
  170. 		} // Of for i
  171.  
  172. 		tempNode.next = tempNode.next.next;
  173.  
  174. 		return true;
  175. 	}// Of delete
  176.  
  177. 	/**
  178. 	 *********************
  179. 	 * The entrance of the program.
  180. 	 * 
  181. 	 * @param args Not used now.
  182. 	 *********************
  183. 	 */
  184. 	public static void main(String args[]) {
  185. 		LinkedList tempFirstList = new LinkedList();
  186. 		System.out.println("Initialized, the list is: " + tempFirstList.toString());
  187.  
  188. 		for (int i = 0; i < 5; i++) {
  189. 			tempFirstList.insert(0, i);
  190. 		} // Of for i
  191. 		System.out.println("Inserted, the list is: " + tempFirstList.toString());
  192.  
  193. 		tempFirstList.insert(6, 9);
  194.  
  195. 		tempFirstList.delete(4);
  196.  
  197. 		tempFirstList.delete(2);
  198. 		System.out.println("Deleted, the list is: " + tempFirstList.toString());
  199.  
  200. 		tempFirstList.delete(0);
  201. 		System.out.println("Deleted, the list is: " + tempFirstList.toString());
  202.  
  203. 		for (int i = 0; i < 5; i++) {
  204. 			tempFirstList.delete(0);
  205. 			System.out.println("Looped delete, the list is: " + tempFirstList.toString());
  206. 		} // Of for i
  207. 	}// Of main
  208. }// Of class LinkedList

运行结果：

总结

昨天我们讨论了顺序表，由于其底层是一段连续的物理空间，所以当想要在顺序表中的任意位置插入或删除元素时，必须通过大段元素整体后移或前移才能完成，所以效率很低，时间复杂度为O(n)，针对这一问题，java引入了链表结构。链表有一个非常好的性质就是在插入、删除元素时不用移动元素，只改变引用即可，所以效率比较高。但是链表也有不足的地方，就是当需要定位查找元素时，链表只能按链接顺序依次访问数据元素，时间复杂度为O(n)。

综上所述，顺序表的优势是支持随机访问，并且查找元素比较快，而当需要频繁进行插入、删除元素操作时，链表会更为适合。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/933767
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号