2、线性表的实现：链式存储、单链表

  1 package ren.laughing.datastructure.baseImpl;
  2
  3 import ren.laughing.datastructure.base.List;
  4 import ren.laughing.datastructure.base.Strategy;
  5 import ren.laughing.datastructure.exception.OutOfBoundaryException;
  6 /**
  7  * 线性表的实现：链式存储结构：单链表
  8  * @author Laughing_Lz
  9  * @time 2016年4月5日
 10  */
 11 public class SLinkList implements List{
 12     private Strategy strategy;//数据元素比较策略
 13     private SLNode head;//单链表首结点引用
 14     private int size;//数据元素个数
 15
 16
 17     public SLinkList() {
 18         this(new DefaultStrategy());
 19     }
 20
 21     public SLinkList(Strategy strategy) {
 22         this.strategy = strategy;
 23         head = new SLNode();
 24         size = 0;
 25     }
 26     //辅助方法：获取数据元素为e的前驱结点
 27     public SLNode getPreNode(Object obj){
 28         int index = indexOf(obj);
 29         if(index >=0){
 30             SLNode p = getPreNode(index);
 31             return p;
 32         }else{
 33             return null;
 34         }
 35     }
 36     //辅助方法：获取序号为0<=i<size的前驱结点
 37     public SLNode getPreNode(int i){
 38         if(i>=1){
 39             SLNode p = getNode(i-1);
 40             return p;
 41         }else{
 42             return head;
 43         }
 44     }
 45     //辅助方法：获取序号为 0<=i<size 的元素所在结点
 46     public SLNode getNode(int i){
 47         SLNode p = head.getNext();//head不存储任何实质对象,仅作a0的前驱结点
 48         for(int j= 0;j<i;j++){
 49             p=p.getNext();
 50         }
 51         return p;
 52     }
 53     @Override
 54     public int getSize() {
 55         return this.size;
 56     }
 57
 58     @Override
 59     public boolean isEmpty() {
 60         if(this.size == 0){
 61             return true;
 62         }else{
 63             return false;
 64         }
 65     }
 66
 67     @Override
 68     public boolean contains(Object e) {
 69         SLNode p = head.getNext();//定义一个指针P，起始点为head结点
 70         while(p!=null){
 71             if(strategy.equal(p.getData(), e)){
 72                 return true;
 73             }else{
 74                 p=p.getNext();
 75             }
 76         }
 77         return false;
 78     }
 79
 80     @Override
 81     public int indexOf(Object e) {
 82         SLNode p = head.getNext();//定义一个指针P，起始点为a0结点
 83         int index = 0;
 84         while(p!=null){
 85             if(strategy.equal(p.getData(), e)){
 86                 return index;
 87             }else{
 88                 index++;
 89                 p=p.getNext();
 90             }
 91         }
 92         return -1;
 93     }
 94
 95     @Override
 96     public void insert(int i, Object e) throws OutOfBoundaryException {
 97         if(i<0||i>=size){
 98             throw new OutOfBoundaryException("指定插入位置的序号越界");
 99         }
100         SLNode p = getPreNode(i);//得到前驱结点
101         SLNode q = new SLNode(e, p.getNext());//定义新结点并插入
102         p.setNext(q);//与原始结点相连
103         size++;
104     }
105     //将数据元素 e 插入到元素 obj 之前
106     @Override
107     public boolean insertBefore(Object obj, Object e) {
108 //        int index = indexOf(obj);//获取obj位置
109 //        if(index>=0&&index<size){
110 //            insert(index, e);
111 //            return true;
112 //        }else{
113 //            return false;
114 //        }
115         SLNode p = getPreNode(obj);
116         if(p!=null){
117             SLNode q = new SLNode(e, p.getNext());
118             p.setNext(q);
119             size++;
120             return true;
121         }else{
122             return false;
123         }
124     }
125     //将数据元素 e 插入到元素 obj 之后
126     @Override
127     public boolean insertAfter(Object obj, Object e) {
128         SLNode p = head.getNext();
129         while(p!=null){
130             if(strategy.equal(p.getData(), obj)){
131                 SLNode q = new SLNode(e, p.getNext());
132                 p.setNext(q);
133                 size++;
134                 return true;
135             }else{
136                 p = p.getNext();
137             }
138         }
139         return false;
140     }
141
142     @Override
143     public Object remove(int i) throws OutOfBoundaryException {
144         if (i<0||i>=size){
145             throw new OutOfBoundaryException("错误，指定的删除序号越界。");
146         }
147         SLNode p = getPreNode(i);//首先找到该位置结点和前驱结点
148         SLNode q = getNode(i);
149         p.setNext(q.getNext());//将前驱结点和后继结点相连
150         size--;
151         return q.getData();//返回删除的结点数据元素
152     }
153
154     @Override
155     public boolean remove(Object e) {
156 //        int index = indexOf(e);
157 //        if(index >=0&&index<size){
158 //            remove(index);
159 //            return true;
160 //        }else{
161 //            return false;
162 //        }
163         SLNode p = getPreNode(e);
164         if(p!=null){
165             p.setNext(p.getNext().getNext());
166             size--;
167             return true;
168         }else{
169             return false;
170         }
171     }
172
173     @Override
174     public Object replace(int i, Object e) throws OutOfBoundaryException {
175         if (i<0||i>=size){
176             throw new OutOfBoundaryException("错误，指定替代位置的序号越界。");
177         }
178         SLNode p = getNode(i);
179         Object obj = p.getData();
180         p.setData(e);//只需替换该结点数据元素
181         return obj;
182     }
183
184     @Override
185     public Object get(int i) throws OutOfBoundaryException {
186         if(i<0||i>size){
187             throw new OutOfBoundaryException("指定序号越界");
188         }
189         SLNode p = getNode(i);
190         return p.getData();
191     }
192
193 }