Java数据结构-02单链表

一.链式存储：　

　　　　①简述：线性表的链式存储结构的特色是用一组任意的存储单元存储线性表的数据元素，这组存储单元能够是连续的，也能够是不连续的。存储单元由两部分组成，数据源和指针，数据源放数据，指针指向下个存储单元(如图)。LinkedList采用的就是链式存储线性表。

　　　　

 

　　　　②特色：数据是非连续的，链表的运输必须从头指针开始；

　　　　③与顺序表的区别：

　　　　　　链式线性表删除和插入效率高，查询效率低
　　　　　　顺序表查询效率高，删除和插入效率低。

　　　　④单链表相关操做：

　　　　　　A.插入操做

　　　　　　　　

 

 

 　　　　　　B.删除操做

　　　　　　　　

 

　　　　⑤代码实现：　

  1 package com.atguigu.test03;
  2 
  3 public class SingleLinkedList {
  4     //这里不须要数组，不须要其余的复杂的结构，我只要记录单向链表的“头”结点
  5     private Node first;//first中记录的是第一个结点的地址
  6     private int total;//这里我记录total是为了后面处理的方便，例如：当用户获取链表有效元素的个数时，不用现数，而是直接返回total等
  7     
  8     
  9     private class Node{
 10         Object data;//由于数据能够是任意类型的对象，因此设计为Object
 11         Node next;//由于next中记录的下一个结点的地址，所以类型是结点类型
 12         
 13         Node(Object data, Node next){
 14             this.data = data;
 15             this.next = next;
 16         }
 17     }
 18     
 19     public void add(Object obj){
 20     
 21         Node newNode = new Node(obj, null);
 22         
 23         //①当前新结点是第一个结点
 24         if(first == null){
 25             //说明newNode是第一个
 26             first = newNode;
 27         }else{
 28             //②先找到目前的最后一个，把新结点连接到它的next中
 29             Node node = first;
 30             while(node.next != null){
 31                 node = node.next;
 32             }
 33             //退出循环时node指向最后一个结点
 34             
 35             //把新结点连接到它的next中
 36             node.next = newNode;
 37         }
 38         
 39         total++;
 40     }
 41     
 42     public int size(){
 43         return total;
 44     }
 45     
 46     public Object[] getAll(){
 47         //(1)建立一个数组，长度为total
 48         Object[] all = new Object[total];
 49         
 50         //(2)把单向链表的每个结点中的data，拿过来放到all数组中
 51         Node node = first;
 52         for (int i = 0; i < total; i++) {
 53 //            all[i] = 结点.data;
 54             all[i] = node.data;
 55             //而后node指向下一个
 56             node = node.next;
 57         }
 58         
 59         //(3)返回数组
 60         return all;
 61     }
 62     
 63     public void remove(Object obj){
 64         if(obj == null){
 65             //(1)先考虑是不是第一个
 66             if(first!=null){//链表非空
 67                 
 68                 //要删除的结点正好是第一个结点
 69                 if(first.data == null){
 70                     //让第一个结点指向它的下一个
 71                     first = first.next;
 72                     total--;
 73                     return;
 74                 }
 75                 
 76                 //要删除的不是第一个结点
 77                 Node node = first.next;//第二个结点
 78                 Node last = first;
 79                 while(node.next!=null){//这里不包括最后一个，由于node.next==null，不进入循环，而node.next==null是最后一个
 80                     if(node.data == null){
 81                         last.next = node.next;
 82                         total--;
 83                         return;
 84                     }
 85                     last = node;
 86                     node = node.next;
 87                 }
 88                 
 89                 //单独判断最后一个是不是要删除的结点
 90                 if(node.data == null){
 91                     //要删除的是最后一个结点
 92                     last.next = null;
 93                     total--;
 94                     return;
 95                 }
 96             }
 97         }else{
 98             //(1)先考虑是不是第一个
 99             if(first!=null){//链表非空
100                 
101                 //要删除的结点正好是第一个结点
102                 if(obj.equals(first.data)){
103                     //让第一个结点指向它的下一个
104                     first = first.next;
105                     total--;
106                     return;
107                 }
108                 
109                 //要删除的不是第一个结点
110                 Node node = first.next;//第二个结点
111                 Node last = first;
112                 while(node.next!=null){//这里不包括最后一个，由于node.next==null，不进入循环，而node.next==null是最后一个
113                     if(obj.equals(node.data)){
114                         last.next = node.next;
115                         total--;
116                         return;
117                     }
118                     last = node;
119                     node = node.next;
120                 }
121                 
122                 //单独判断最后一个是不是要删除的结点
123                 if(obj.equals(node.data)){
124                     //要删除的是最后一个结点
125                     last.next = null;
126                     total--;
127                     return;
128                 }
129             }
130         }
131     }
132 
133     public int indexOf(Object obj){
134         if(obj == null){
135             Node node = first;
136             for (int i = 0; i < total; i++) {
137                 if(node.data == null){
138                     return i;
139                 }
140                 node = node.next;
141             }
142         }else{
143             Node node = first;
144             for (int i = 0; i < total; i++) {
145                 if(obj.equals(node.data)){
146                     return i;
147                 }
148                 node = node.next;
149             }
150         }
151         return -1;
152     }
153 }