数据结构学习笔记--(4) 链表--第二节

一、链表

      链表是一个接一个排列的元素序列，每个元素都通过一个“指针”连接到下一个元素。

二、使用链表实现的包ADT

package jiangning.node;

public class IntLinkedBag {
        private IntNode head ;//引向链表结点的引用
      private int manyNodes ;//链表中结点的数量

      //初始化生成一个空包
      public IntLinkedBag(){
            head = null ;
            manyNodes = 0;
     }
      /**
      * 向该包中添加一个新元素
      * @param element
      */
      public void add(int element){
            head = new IntNode(element, head);
            manyNodes++;
     }
    
      /**
      * 将另一个包中的内容追加到当前包
      * @param addend
      */
      public void addAll(IntLinkedBag addend){
           IntNode[] copyInfo;
            if(addend == null){
                  throw new IllegalArgumentException("addend is null");
           }
            if(addend.manyNodes >0){
                 copyInfo = IntNode. listCopyWithTrail(addend.head);//复制链表，返回首尾结点
                 copyInfo[1].setLink( head);//将副本尾结点链接到自己的头结点出
                  head = copyInfo[0];//见自己的头结点设置成副本的头结点
                  manyNodes += addend.manyNodes ;
           }
          
     }
    
      /**
      * 将可变数量的新元素追加到当前包
      * @param element
      */
      public void addMany(int ...elements){
            for(int i : elements){
                 add(i); //调用普通add方法
           }
     }
    
      /**
      * 生成当前包的一个副本
      */
      public IntLinkedBag clone(){
            IntLinkedBag answer;
            try {
                 answer = ( IntLinkedBag) super.clone();
           } catch (CloneNotSupportedException e) {
                  throw new RuntimeException("This class does not imlement Cloneable.");
           }
           answer. head = IntNode.listCopy( head);
            return answer;
     }
    
      /**
      * 存取方法，统计某个指定元素在包中出现的次数
      * @param target
      * @return
      */
      public int countOccurrences(int target){
            int answer = 0;
            while(head != null){
                  if(target == head .getData()){
                       answer++;
                 }
           }
            return answer;
     }
    
    
      /**
      * 存取方法，从包中检索某个随机元素
      * @return
      */
      public int grab(){
           int i;
           IntNode cursor;
           if(manyNodes == 0){
               throw new IllegalArgumentException("Bag size is zero.");
           }
           i = ( int)(Math.random() * manyNodes)+1;
           //Math.random()获取的值是一个0到1直接的一个随机小数。
           cursor = IntNode. listPosition(head, i);
           return cursor.getData();
     }
    
      /**
      * 将指定元素从当前包中删除
      * @param args
      */
      public boolean remove(int target) {
//        1.找到这个元素
//            2.将节点指向下一个，若是最后一个元素，指向null
        IntNode targetNode;
        targetNode = IntNode. listPosition(head, target);
        if(targetNode == null){
              return false ;//没有 找到target
        } else{//找到target元素
              targetNode.setData( head.getData());//将第一元素的值设置为要删除的元素的值
              //这样会有两个都是头结点元素的值
              head = head.getLink();//将头结点指向第二个结点。这样链表从头结点开始就会少一个值
              manyNodes--;//总结点数少一
              return true ;
        }
     }
    
      /**
      * 存取方法，确定包中元素个数
      * @return
      */
      public int size(){
           return manyNodes ;
     }
    
      /**
      * 创建一个包含来自其他两个包的所有元素的新包
      * @param b1
      * @param b2
      * @return
      */
      public static IntLinkedBag union(IntLinkedBag b1,IntLinkedBag b2){
           IntLinkedBag answer = new IntLinkedBag();
           answer.addAll(b1);
           answer.addAll(b2);
           return answer;
          
     }
    
      public IntNode getHead() {
            return head ;
     }
      public void setHead(IntNode head) {
            this.head = head;
     }
      public int getManyNodes() {
            return manyNodes ;
     }
      public void setManyNodes(int manyNodes) {
            this.manyNodes = manyNodes;
     }
      public static void main(String[] args) {

     }

}