线性表的链式存储结构

前言

顺序存储结构的缺点：插入和删除时需要移动大量元素
链式存储结构的特点：用一组任意的存储单元存储线性表的数据元素

数据结构 存储分配方式 时间性能 空间性能 顺序存储结构 用一段连续的存储单元一次存储线性表的数据元素 查找:O(1) 插入删除：O(n) 需要预分配存储空间，分大了浪费，分小了易发生上溢 单链表结构 用一组任意的存储单元存放线性表的元素 查找:O(n) 插入删除：O(1) 动态调整

思路

1、定义接口

package com.stucture.list;  /**  * 线性表顺序存储结构的接口  * 指的是用一段地址连续的存储单元一次存储线性表的数据元素  * @ClassName: ISqList   */  public interface IList<T> {      /**      * 获得元素      * @param loc 需要获得的第loc个元素      * @return       */      public T getElem(int loc);      /**      * 插入元素      * @param loc 元素的插入位置      * @param t 需要插入的元素      * @return  是否成功插入      */      public boolean insertElem(int loc, T t);      /**      * 删除元素      * @param i 需要删除元素的位置      * @return      */      public T deleteElem(int i);  }  

2、定义节点类

package com.stucture.list.linkList;  /**  * 链表中的结点  * @ClassName: Node   * @author 小学徒  * @date 2013-2-27  */  public class Node<T> {      private T data;       //需要存储的数据信息      private Node<T> next; //后继结点      public T getData() {          return data;      }      public void setData(T data) {          this.data = data;      }      public Node<T> getNext() {          return next;      }      public void setNext(Node<T> next) {          this.next = next;      }  }  

3、实现链表和基本操作

package com.stucture.list.linkList;  import com.stucture.list.IList;  /**  * 单链表  * @ClassName: LinkList   */  public class LinkList<T> implements IList<T>{      private Node<T> head; //链表的结点      private int length; //链表的长度      public LinkList(Node<T> head) {          this.head = head;      }      //获取元素      public T getElem(int loc) {          int j = 1;  //计数器          Node<T> n = head; //指向第一个结点          while(n != null) {  //n不为空时，循环继续寻找第loc个结点              if(j == loc) {  //找到第一个元素时返回                  return n.getData();              }              n = n.getNext();              j++;          }          return null;      }      //插入元素      public boolean insertElem(int loc, T t) {          if(length + 1 < loc) {              System.out.println("非法插入");              return false;          }          if(head == null && loc == 1) {  //当第一次插入的时候              head = new Node<T>(); //第一次使用，必须创建对象              head.setData(t);              length++;          } else if(head != null && loc == 1) {   //但不是第一次插入，但是插入的位置是第一个时              Node<T> tempNode = new Node<T>();   //生成一个新的结点              tempNode.setData(t);              tempNode.setNext(head);               head = tempNode;    //把头换成新插入的结点              length++;          } else {    //当不是第一次插入并且插入的不是第一个时              Node<T> n = this.head;              int j = 1;  //计数器              while(n != null && j < loc - 1) {                  n = n.getNext();                  j++;              }              Node<T> tempNode = new Node<T>();   //生成一个新的结点              tempNode.setData(t);              tempNode.setNext(n.getNext());  //将n的后继结点赋值给新的结点的后继              n.setNext(tempNode);              length++;          }          return true;      }      //删除元素      public T deleteElem(int loc) {          if(head == null || loc > length) {              System.out.println("非法删除");              return null;          }          T old;          if(head != null && loc == 1) {              old = head.getData();              head = head.getNext();          } else {              Node<T> n = this.head;              int j = 1;  //计数器              while(n != null && j < loc - 1) {                  n = n.getNext();                  j++;              }              old = n.getNext().getData();              n.setNext(n.getNext().getNext());          }          length--;          return old;      }      public Node<T> getHead() {          return head;      }      public void setHead(Node<T> head) {          this.head = head;      }      public int getLength() {          return length;      }      public void setLength(int length) {          this.length = length;      }  }  

参考

http://hjj20040849.iteye.com/blog/1816941

线性表的顺序存储结构：
http://blog.csdn.net/iamcgt/article/details/78622878