JAVA实现双向链表的增删功能

JAVA实现双向链表的增删功能，完整代码 
 

1. package linked;

2. class LinkedTable{

3. }

4. public class LinkedTableTest {

5.     //构造单链表

6.     static Node node1 = new Node("name1");

7.     static Node node2 = new Node("name2");

8.     static Node node3 = new Node("name3");

9.     static Node node4 = new Node("name4");

10.     static Node node5 = new Node("name5");

11.     public static void main(String[] args)

12.     {

13.         //设置指针

14.         setPoint();

15.         //循环遍历

16.         System.out.println("*******初始链表*******");

17.         out(node1,node5);

18.         System.out.println();

19.         //插入节点在node2的后面

20.         addNode(node2,node3);

21.         // 循环遍历

22.         System.out.println("*******插入node2.5*******");

23.         out(node1, node5);

24.         System.out.println();

25.         //删除节点

26.         node2.setNextNode(node3);

27.         node3.setNextNodeF(node2);

28.         // 循环遍历

29.         System.out.println("*******删除node2.5*******");

30.         out(node1, node5);

31.         System.out.println();

32.     }

33.     //设置指针

34.     public static void setPoint()

35.     {

36.         //设置正向指针

37.         node1.setNextNode(node2);

38.         node2.setNextNode(node3);

39.         node3.setNextNode(node4);

40.         node4.setNextNode(node5);

41.         //设置反向指针

42.         node5.setNextNodeF(node4);

43.         node4.setNextNodeF(node3);

44.         node3.setNextNodeF(node2);

45.         node2.setNextNodeF(node1);

46.     }

47.     //循环遍历单链表

48.     public static void outLinked(Node startNode){

49.         Node node= new Node();

50.         node.setNextNode(startNode);

51.         do

52.         {

53.             node=node.getNextNode();

54.             System.out.print(node.getName()+"----");   

55.         }while(node.getNextNode()!=null);

56.     }

57.     //反向循环遍历单链表

58.     public static void outLinkedF(Node endNode){

59.         Node node= new Node();

60.         node.setNextNodeF(endNode);

61.         do

62.         {

63.             node=node.getNextNodeF();

64.             System.out.print(node.getName()+"----");   

65.         }while(node.getNextNodeF()!=null);

66.     }

67.     //循环遍历

68.     public static void out(Node startNode,Node endNode)

69.     {

70.         outLinked(startNode);

71.         System.out.println();

72.         outLinkedF(endNode);

73.     }

74.     //插入节点

75.     public static void addNode(Node preNode,Node nextNode)

76.     {

77.         Node node_add = new Node("name2.5");

78.         node_add.setNextNode(preNode.getNextNode());

79.         preNode.setNextNode(node_add);

80.         node_add.setNextNodeF(nextNode.getNextNodeF());

81.         nextNode.setNextNodeF(node_add);

82.     }

83. }

84. class Node {

85.     private String name;

86.     private Node nextNode;

87.     private Node nextNodeF;

88.     public void setName(String name)

89.     {

90.         this.name=name;

91.     }

92.     public void setNextNode(Node nextNode)

93.     {

94.         this.nextNode=nextNode;

95.     }

96.     public void setNextNodeF(Node nextNodeF)

97.     {

98.         this.nextNodeF=nextNodeF;

99.     }

100.     public String getName()

101.     {

102.         return this.name;

103.     }

104.     public Node getNextNode()

105.     {

106.         return this.nextNode;

107.     }

108.     public Node getNextNodeF()

109.     {

110.         return this.nextNodeF;

111.     }

112.     public Node(String name)

113.     {

114.         this.name=name;

115.         this.nextNode=null;

116.     }

117.     public Node( )

118.     {

119.     }

120. }

复制代码

1，构造node节点，需要两个指针，一个正向存储下一个元素的位置，一个反向存储下一个元素的位置 
 
参数说明： 
　　name:用于存储node自身的信息 
　　nextNode:用于存储正向指针 
　　nextNodeF:用于存储反向指针 
 

1. class Node {

2.     private String name;

3.     private Node nextNode;

4.     private Node nextNodeF;

5.     public void setName(String name)

6.     {

7.         this.name=name;

8.     }

9.     public void setNextNode(Node nextNode)

10.     {

11.         this.nextNode=nextNode;

12.     }

13.     public void setNextNodeF(Node nextNodeF)

14.     {

15.         this.nextNodeF=nextNodeF;

16.     }

17.     public String getName()

18.     {

19.         return this.name;

20.     }

21.     public Node getNextNode()

22.     {

23.         return this.nextNode;

24.     }

25.     public Node getNextNodeF()

26.     {

27.         return this.nextNodeF;

28.     }

29.     public Node(String name)

30.     {

31.         this.name=name;

32.         this.nextNode=null;

33.     }

34.     public Node( )

35.     {

36.     }

37. }

复制代码

2，创建节点，设置指针连接节点 
正向指针：指向下一个节点 
反向节点：指向上一个节点 
 

1. //构造单链表
2.     static Node node1 = new Node("name1");
3.     static Node node2 = new Node("name2");
4.     static Node node3 = new Node("name3");
5.     static Node node4 = new Node("name4");
6.     static Node node5 = new Node("name5");

复制代码

1. public static void setPoint()
2.     {
3.         //设置正向指针
4.         node1.setNextNode(node2);
5.         node2.setNextNode(node3);
6.         node3.setNextNode(node4);
7.         node4.setNextNode(node5);
8.         //设置反向指针
9.         node5.setNextNodeF(node4);
10.         node4.setNextNodeF(node3);
11.         node3.setNextNodeF(node2);
12.         node2.setNextNodeF(node1);
13.     }

复制代码

3，将链表循环遍历输出 
 

1. public static void outLinked(Node startNode){
2.         Node node= new Node();
3.         node.setNextNode(startNode);
4.         do
5.         {
6.             node=node.getNextNode();
7.             System.out.print(node.getName()+"----");   
8.         }while(node.getNextNode()!=null);
9.     }

复制代码

1.     public static void outLinkedF(Node endNode){
2.         Node node= new Node();
3.         node.setNextNodeF(endNode);
4.         do
5.         {
6.             node=node.getNextNodeF();
7.             System.out.print(node.getName()+"----");   
8.         }while(node.getNextNodeF()!=null);
9.     }

复制代码

4，添加节点 
 

1.     public static void addNode(Node preNode,Node nextNode)

2.     {

3.         Node node_add = new Node("name2.5");

4.         node_add.setNextNode(preNode.getNextNode());

5.         preNode.setNextNode(node_add);

6.         node_add.setNextNodeF(nextNode.getNextNodeF());

7.         nextNode.setNextNodeF(node_add);

8.     }

复制代码

5，删除节点 
 

1. node2.setNextNode(node3);
2. node3.setNextNodeF(node2);

复制代码

  
  
class Node {private String name;private Node nextNode;private Node nextNodeF;public void setName(String name){this.name=name;}public void setNextNode(Node nextNode){this.nextNode=nextNode;}public void setNextNodeF(Node nextNodeF){this.nextNodeF=nextNodeF;}public String getName(){return this.name;}public Node getNextNode(){return this.nextNode;}public Node getNextNodeF(){return this.nextNodeF;}public Node(String name){this.name=name;this.nextNode=null;}public Node( ){}}