Go语言视频零基础入门到精通

admin

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

1. package linked;
3. class LinkedTable{
4.    
5. }
6. public class LinkedTableTest {
7.    
8.     //构造单链表
9.     static Node node1 = new Node("name1");
10.     static Node node2 = new Node("name2");
11.     static Node node3 = new Node("name3");
12.     static Node node4 = new Node("name4");
13.     static Node node5 = new Node("name5");
14.    
15.    
16.     public static void main(String[] args)
17.     {
18.         //设置指针
19.         setPoint();
20.         
21.         //循环遍历
22.         System.out.println("*******初始链表*******");
23.         out(node1,node5);
24.         System.out.println();
25.         
26.         //插入节点在node2的后面
27.         addNode(node2,node3);
28.         
29.         // 循环遍历
30.         System.out.println("*******插入node2.5*******");
31.         out(node1, node5);
32.         System.out.println();
33.                
34.         //删除节点
35.         node2.setNextNode(node3);
36.         node3.setNextNodeF(node2);
37.         
38.         // 循环遍历
39.         System.out.println("*******删除node2.5*******");
40.         out(node1, node5);
41.         System.out.println();
42.         
43.     }
44.    
45.     //设置指针
46.     public static void setPoint()
47.     {
48.         //设置正向指针
49.         node1.setNextNode(node2);
50.         node2.setNextNode(node3);
51.         node3.setNextNode(node4);
52.         node4.setNextNode(node5);
53.         //设置反向指针
54.         node5.setNextNodeF(node4);
55.         node4.setNextNodeF(node3);
56.         node3.setNextNodeF(node2);
57.         node2.setNextNodeF(node1);
58.     }
59.    
60.     //循环遍历单链表
61.     public static void outLinked(Node startNode){
62.         Node node= new Node();
63.         node.setNextNode(startNode);
64.         do
65.         {
66.             node=node.getNextNode();
67.             System.out.print(node.getName()+"----");   
68.         }while(node.getNextNode()!=null);
69.     }
70.    
71.     //反向循环遍历单链表
72.     public static void outLinkedF(Node endNode){
73.         Node node= new Node();
74.         node.setNextNodeF(endNode);
75.         do
76.         {
77.             node=node.getNextNodeF();
78.             System.out.print(node.getName()+"----");   
79.         }while(node.getNextNodeF()!=null);
80.     }
81.    
82.     //循环遍历
83.     public static void out(Node startNode,Node endNode)
84.     {
85.         
86.         outLinked(startNode);
87.         System.out.println();
88.         outLinkedF(endNode);
89.         
90.     }
91.    
92.     //插入节点
93.     public static void addNode(Node preNode,Node nextNode)
94.     {
95.         Node node_add = new Node("name2.5");
96.         node_add.setNextNode(preNode.getNextNode());
97.         preNode.setNextNode(node_add);
98.         
99.         node_add.setNextNodeF(nextNode.getNextNodeF());
100.         nextNode.setNextNodeF(node_add);
101.     }
102.    
103.    
105.    
106. }
109. class Node {
110.     private String name;
111.     private Node nextNode;
112.     private Node nextNodeF;
113.     public void setName(String name)
114.     {
115.         this.name=name;
116.     }
117.     public void setNextNode(Node nextNode)
118.     {
119.         this.nextNode=nextNode;
120.     }
121.     public void setNextNodeF(Node nextNodeF)
122.     {
123.         this.nextNodeF=nextNodeF;
124.     }
125.     public String getName()
126.     {
127.         return this.name;
128.     }
129.     public Node getNextNode()
130.     {
131.         return this.nextNode;
132.     }
133.     public Node getNextNodeF()
134.     {
135.         return this.nextNodeF;
136.     }
137.     public Node(String name)
138.     {
139.         this.name=name;
140.         this.nextNode=null;
141.     }
142.     public Node( )
143.     {
144.         
145.     }
146.    
147. }

复制代码

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.     }
38.    
39. }

复制代码

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");
7.    

复制代码

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.         
7.         node_add.setNextNodeF(nextNode.getNextNodeF());
8.         nextNode.setNextNodeF(node_add);
9.     }

复制代码

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( ){}}