java 单向和双向链表的详解

Java 链表的使用

浅谈自己学习链表之后的理解：

链表是一种重要的数据结构，有单链表和双链表之分

单链表（单向链表）：由两部分组成 数据域（Data）和结点域(Node),单链表就像是一条打了很多结的绳子，每一个绳结相当于一个结点，每个节结点间都有绳子连接，这样原理的实现是通过Node结点区的头指针head实现的，每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,这样一来就连成了上述所说绳子一样的链，对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。

单链表的操作：

添加：上图可以看出 单向链表只有一个指向，原来head为p，p指向s，添加结点只需要把p指向q,q指向s就可以了，即：p--->q ;  q--->s ； 这样就实现了单向链表的添加；

   删除：原理与添加相反，若此时链表为 p---> q --->s ; 若删除q节点只需要更改p的指向就可以了 p--->s，这样就删掉了；

   查找：查找操作需要对整个但链表进行遍历，直到满足查找条件为止；

   修改：此操作一般建立在查找之上进行，找到借点之后对值进行修改；

 

首先构建一个节点类，设置一个数据区和节点区

使用构造方法便于使用

[java]  view plain  copy

1. public class Node{  
2.     public Node data;   //数据区  
3.     public Node next;   //指针区  
4. public Node (Node data,Node next){  
5.     this.data = data ;  
6.     this.next = next;  
7. }  
8. public Node(){  
9. }  
10. public void setData(Node data){  
11.     this.data = data;  
12. }  
13. public Node getData(){  
14.     return data;  
15. }  
16. public void setNext(Node next){  
17.         this.next=next;  
18.     }  
19.     public Node getNext(){  
20.         return next;  
21.     }  
22. }  
23. public class LinkList{  
24.     public  Node  head; //头节点  
25.     public  int  count;     //记录节点的长度  
26.     public  LinkList（）{ //构造函数用来初始化  
27.         head = null;  
28.         count = 0;  
29.     }  
30.     //节点的添加  
31.     public void addNode(Node data){  
32.         Node node = new Node(data,null);  
33.         Node temp = null;  
34.         If(head!= null){  
35.             temp = head;  
36.             while(temp.getNext()!=null){  
37.                 Temp = temp.getNext();  
38.             }  
39.         temp.setNext(node);  
40.         }else{  
41.             head = node;  
42.             temp = node;  
43.         }  
44.     count++;  
45.     }  
46.     //节点的删除  
47.     public void delNode(Node data){  
48.           
49.             Node  front = null; //定义一个空节点，用于接收和判断被删除节点的前面还有没有节点  
50.             while(head!= null){  
51.                 If(head.equals(data)){  
52.                     break;  
53.                 }  
54.                 front=head;  
55.                 head = head.getNext();  
56.             }  
57.             If(head!=null){  
58.                 If(front==null){  
59.                     head = head.getNext();  
60.                 }else{  
61.                     front.setNext(head.getNext());  
62.                 }  
63.                 count--;  
64.             }else{  
65.                 Count--;  
66.             }  
67.           
68.     }  
69.     //给定下标删除节点  
70.     public void delNode_count(int index){  
71.         if(index<0||index>count-1){  
72.             System.out.println("链表索引越界");  
73.         }  
74.         Node temp = head;   //作用同上  
75.         //找到要删除节点的前一个节点  
76.         for(int i=0;i<index-1;i++){  
77.             temp=temp.getNext();  
78.         }  
79.                                 //找到之后 此节点的前节点和此节点的后节点进行连接  
80.                                 //让要删除节点的前一个节点，指向被删除节点的后一个节点，也就是指向要删除节点的后后一个节点  
81.         temp.setNext(temp.getNext().getNext());     //把要删除的节点隔过去进行连接，也就是实现了删除节点的操作  
82.         //删除之后链表的长度变短了1位  
83.         count--;  
84.     }  
85.         //以给出的index 查找节点  
86.       
87.       
88.     public Node findNode(int index){  
89.         if(index<0||index>count-1){  
90.             System.out.println("链表索引越界");             
91.         }  
92.         Node temp = head;  
93.         for(int i=0;i<index-1;i++){  
94.             temp=temp.getNext();    //找到之后获取index在链表中的位置，表示链表中第index个节点的值是temp.getData;  
95.         }  
96.         return temp;    //根据需要可返回找到的数据对象，也可不返回，此处建议返回，这样可以把链表封装起来  
97.     }  
98.       
99.     //以对象查找节点  
100.     public Node findNode(NodeData data){  
101.             Node temp = head;  
102.             while(temp!=null){  
103.                 if(temp.equals(data)){  
104.                     return temp;  
105.                 }  
106.                 temp.setNext(temp.getNext());  
107.             }  
108.             return null;  
109.     }  
110.     //修改  
111.     public void updateNode(NodeData data){  
112.         Node temp = findNode(data);  
113.         if(temp!=null){  
114.             temp.setData(data);  
115.         }  
116.     }  
117.     //打印  
118.     public void print(){  
119.         Node temp=head;  
120.         while(temp!=null){  
121.             temp.print();  
122.             //temp.print(temp.getData().toString());  
123.             temp=temp.getNext();  
124.         }  
125.     }  
126. }  

双链表（双向链表）：双链表和单链表相比，多了一个指向尾指针（tail），双链表的每个结点都有一个头指针head和尾指针tail,双链表相比单链表更容易操作，双链表结点的首结点的head指向为null，tail指向下一个节点的tail;尾结点的head指向前一个结点的head，tail 指向为null，是双向的关系；

双链表的操作：

[java]  view plain  copy

1. package soft1;  
2.   
3. public class LinkList {  
4.     Node head;  
5.     Node tail;  
6.     int count;  
7.     public LinkList(Node head,Node tail,int count){  
8.         this.head=null;  
9.         this.tail=null;  
10.         this.count=0;  
11.     }  
12.     public LinkList(){  
13.           
14.     }  
15.     //尾插法添加节点  
16.     public void addHeadNode(NodeData data){  
17.         Node node = new Node(data,null,null);  
18.         if(head==null&&tail==null){  
19.             head=node;  
20.             head.setFront(null);  
21.             tail=node;  
22.             tail.setNext(null);  
23.         }else{  
24.             head.setFront(node);  
25.             node.setNext(head);  
26.             head=node;  
27.             head.setFront(null);  
28.         }  
29.         count++;  
30.     }  
31.     //头插法添加节点  
32.     public void addTailNode(NodeData data){  
33.         Node node = new Node(data,null,null);  
34.         if(head==null&&tail==null){  
35.             head=node;  
36.             head.setFront(null);  
37.             tail=node;  
38.             tail.setNext(null);  
39.         }else{  
40.             tail.setNext(node);  
41.             node.setFront(tail);  
42.             tail=node;  
43.             tail.setNext(null);  
44.         }  
45.         count++;  
46.   
47.     }  
48.     //查找节点  
49.     public Node findNode(NodeData data){  
50.         Node temp=head;  
51.         if(head!=null){  
52.             while(temp!=null){  
53.                 if(temp.data.compare(data)){  
54.                     return temp;  
55.                 }  
56.                 temp=temp.getNext();  
57.             }  
58.         }  
59.         return null;  
60.     }  
61.     //删除节点  
62.     public void delNode(NodeData data){  
63.         Node temp=findNode(data);  
64.         if(temp!=null){  
65.             if(temp.getFront()==null){  
66.                 head=temp.getNext();  
67.                 head.setFront(null);  
68.             }else if(temp.getNext()==null){  
69.                 tail=tail.getFront();  
70.                 tail.setNext(null);  
71.             }else{  
72.                 temp.getFront().setNext(temp.getNext());  
73.                 temp.getNext().setFront(temp.getFront());  
74.             }  
75.             count--;  
76.         }  
77.     }  
78.     //修改更新  
79.     public void updNode(NodeData data){  
80.         Node temp=findNode(data);  
81.         if(temp!=null){  
82.             temp.setNodeData(data);  
83.         }  
84.     }  
85.     //打印链表  
86.     public void printNode(){  
87.         Node temp = head;  
88.         while(temp!=null){  
89.             temp.print();  
90.             temp=temp.getNext();  
91.         }  
92.     }  
93. }  

需要把自己写过的代码总结之后都放在网上，不过就是有点慢，急不得啊 哈哈

转载地址：http://blog.csdn.net/Sun_Ru/article/details/51784058