线性表之链式存储结构

package com.stucture.list.linkList;  


/** 
 * 单链表 
 * @ClassName: LinkList  
 * @author 景帅
 * @date 2015-2-13 
 */  
public class LinkList<T>{  
    private Node<T> head; //链表的结点  
    private int length; //链表的长度  
      
    public LinkList(Node<T> head) {  
        this.head = head;  
    }
    /** 
     * 头插法初始化
     * @param initsu 需要插入的对象数组
     * @return  
     */  
    public void topinit(T initsu[]){
    	Node<T> newnode = null;
    	Node<T> oldnode = null;
    	for (T i : initsu) {//1 
    		if(head==null){
    			head = new Node<T>(); //第一次使用，必须创建对象 
                oldnode = head;
    		}
   			newnode = new Node<T>(); //创建新节点 new 2 old 7 17
   			newnode.setData(i); 
   			newnode.setNext(oldnode.getNext());//new 17 old 7
   			oldnode.setNext(newnode);//new 17 old 7 17
   			
            length++;
		}
    	
    }
    /** 
     * 尾插法初始化
     * @param initsu 需要插入的对象数组
     * @return  
     */ 
    public void tailinit(T initsu[]){
    	Node<T> p = null;
    	Node<T> p2 = null;
    	for (T i : initsu) {//1 2
    		if(head==null){
    			head = new Node<T>(); //第一次使用，必须创建对象 
    			head.setNext(null);
    			p2 = head;
    		}
    		p = new Node<T>(); //创建新节点
    		p.setData(i);
    		p2.setNext(p);
    		//p.setNext(head.getNext());
    		//head.setNext(p);
    		p2 = p;
    		length++;
    	}
    	
    }
    /** 
     * 获得元素 
     * @param loc 需要获得的第loc个元素 
     * @return  
     */   
    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;  
    }  

    /** 
     * 插入元素 
     * @param loc 元素的插入位置 
     * @param t 需要插入的元素 
     * @return  是否成功插入 
     */ 
    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的后继结点赋值给新的结点的后继   1 2 3 4 5 6     
            n.setNext(tempNode);  
            length++;  
        }  
        return true;  
    }  

    /** 
     * 删除元素 
     * @param i 需要删除元素的位置 
     * @return 
     */ 
    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;  
    }  
      
} 
/** 
 * 链表中的结点 
 * @ClassName: Node  
 * @author 景帅 
 * @date 2015-2-13 
 */  
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;  
    }  
      
      
}

调用代码

package com.stucture.list.linkList;  
 
import java.util.Random;  
 
public class LinkListTest {  
    final int MAX = 25;  
    Random r = new Random();  
    LinkList<Integer> linkList;  
      
    public LinkListTest() {  
        //initSeqList();  
    }  
      
    //创建一个线性表顺序存储结构  
    public void initSeqList() {  
        linkList = new LinkList<Integer>(null);   
        Integer s[] = new Integer[10];
        for (int i = 1; i <= 10; i++) {  //为生成的链表赋值，同时也测试了插入值的方法  
            int j =r.nextInt(MAX);
            System.out.print(j+" ");
            s[i-1] = j;  
        }
        System.out.println();
        //linkList.topinit(s);
        linkList.tailinit(s);
        
        System.out.println("\n原始链表是 ：");  
        display(linkList);  
    }  
      
    //测试删除方法  
    public void deleteElem() {  
        int i = r.nextInt(MAX);  
        System.out.println("\n\n删除的位置是：" + i);  
        Integer deleteNumber = linkList.deleteElem(i);  
          
        if( deleteNumber == null) {  
            System.exit(0);  
        } else {  
            System.out.println("删除的元素是 ： " + deleteNumber);  
            System.out.println("删除元素后链表是 ：");  
            display(linkList);  
        }  
    }  
      
    //测试随机插入方法  
    public void insertByRandom() {  
        int i = r.nextInt(MAX);  
        System.out.println("\n\n随机插入位置是 ：" + i);  
        int elem = r.nextInt(MAX);  
        System.out.println("随机插入数据是 ：" + elem);  
        linkList.insertElem(i, elem);  
        System.out.println("随机插入数据后链表是 ：");  
        display(linkList);  
    }  
      
    //数据展示  
    public  void display(LinkList<Integer> linkList) {  
        Node<Integer> node = linkList.getHead();  
        while(node != null) {  
            System.out.print(node.getData() + " ");  
            node = node.getNext();  
        }  
        System.out.println("链表的长度为 ：" + linkList.getLength());  
    }  
      
    //获取元素  
    public void getElem() {  
        int i = r.nextInt(MAX);  
        System.out.println("\n获取位置为 ：" + i);  
        System.out.println("获取到的元素为 : " + linkList.getElem(i));  
          
          
    }  
      
    public static void main(String[] args) {  
        LinkListTest s = new LinkListTest();  
        /*s.insertByRandom();  
        s.deleteElem();  
        s.getElem(); */
        s.initSeqList();
    }  
}