数据结构学习之单链表

定义节点类Node，其中包括数据域data和指针域next。

public class Node<T> {
	//数据域	
    public T data;
	//指针域
    public Node<T> next;
	
    public Node() {
		
    }
	
    public Node(T data) {
		this.data=data;
	 }
   
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }
}

定义链表类，通过构造方法初始化一个新的链表

public class LinkList<T> {
	//头指针
    Node<Object> head; 
	//结点个数
    int size;
    /**
     * 初始化一个空链表
     */
    public LinkList(){
    	this.head=new Node<Object>(null);
    	this.size=0;
    }
}

1、insert（Object obj），往链表中插入某个元素

      /**
       * 在链表中插入元素
      */
	
	public void insert(Object obj) {
		
		// 实例化一个节点
        Node<Object> node = new Node<>(obj);
         //如果head为空，插入数据到head
         if (head == null) {
             head = node;
             return;
         }
         
         Node<Object> tmp = head;
         //从head开始遍历，直到找到链表中最后一个节点
         while (tmp.next != null) {
             tmp = tmp.next;
         }
         //插入数据到链表最后一个节点
         tmp.next = node;
        //每插入一个元素，节点个数+1
       size++;
	}

 插入元素测试，调用traverse()方法遍历

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     linkList.insert(2);
     linkList.insert("aa");
     linkList.insert(7.5D);
     linkList.insert(5.5);
     linkList.insert(null);
		
     linkList.traverse();
}

打印结果
true 2 aa 7.5 5.5 null 

下面是traverse()方法的代码

	/**
     * 遍历链表
     *
     */
    public void traverse() {
    	Node<Object> tmp = head;
        //从head开始遍历
        while (tmp.next != null) {
            System.out.print(tmp.next.data+" ");
            tmp = tmp.next;
        }
    }

2、size（），获取链表的节点个数

    /**
     *获取链表节点个数
     */
     public int size() {
		
       return this.size;
    }

测试：

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     linkList.insert(2);
     linkList.insert("aa");
     linkList.insert(7.5D);
     linkList.insert(5.5);
     linkList.insert(null);
     // 获取链表元素个数
     int size = linkList.size();
     System.out.println("链表元素个数:"+size);
}

打印结果：
链表元素个数:6

3、delete(int index)删除链表中某个index节点的元素

     /**
     * 删除链表中某个index节点的元素
     */
	public void delete(int index) {
		// 范围校验
		if (index >= this.size  || index<0) {
			throw new IndexOutOfBoundsException();
		}
		Node<Object> temp = head;
		Node<Object> cur = head;
		// 先让temp指针走size-index步
		for (int i = size-index; i >0; i--) {
			temp = temp.next;
		}
		//现在第二个指针开始走，等到第一个走完第二个指针所处的位置就是要删除的元素
		while (temp.next != null) {
			temp = temp.next;
			cur = cur.next;
		}
		cur.next=cur.next.next;
		size--;
	}

测试

public static void main(String[] args) {
       // 插入元素测试
       LinkList<Object> linkList = new LinkList<>();
       linkList.insert(true);
       linkList.insert(2);
       linkList.insert("aa");
       linkList.insert(7.5D);
       linkList.insert(5.5);
       linkList.insert(null);
       // 删除指定节点的元素
       linkList.delete(3);
       linkList.traverse();
}

打印结果：
true 2 aa 5.5 null 

4、 deleteObj(Object obj) 删除链表中指定的元素

/**
	 * 删除链表中指定的元素
	 */
	public void deleteObj(Object obj){
		 //范围校验
         if(obj==null){
              throw new IllegalArgumentException();
         }
         Node<Object> temp = head;
         while(temp.next != null){
            if (temp.next.data.equals(obj)) {
               temp.next = temp.next.next;
               size--;
               return;
             }
           temp = temp.next;
         }
	}

测试

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     linkList.insert(2);
     linkList.insert("aa");
     linkList.insert(7.5D);
     linkList.insert(5.5);
     linkList.insert(null);
     // 删除指定元素
     linkList.deleteObj("aa");
     linkList.traverse();
}

打印结果：
true 2 7.5 5.5 null 

5、get(int index)获取链表中指定节点的元素

/**
* 获取链表中指定节点的元素
 */
public Node<Object> get(int index){
				// 范围校验
  if (index >= this.size  || index<0) {
     throw new IndexOutOfBoundsException();
  }
  Node<Object> tmp = head;
 //从head开始遍历，直到找到链表中最后一个节点
  while (index>=0) {
     tmp = tmp.next;
      index--;
   }
   return tmp;
}

测试

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     linkList.insert(2);
     linkList.insert("aa");
     linkList.insert(7.5D);
     linkList.insert(5.5);
     linkList.insert(null);
     // 获取指定节点的元素
     Object obj = linkList.get(2).data;
     System.out.println("指定节点的元素:"+obj);
}
打印结果：
指定节点的元素:aa

6、isEmpty()判断链表是否为空

/**
* 判空
*/
public boolean isEmpty() {
  if (size == 0) {
    return true;
  }
    return false;
}

测试

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     boolean empty = linkList.isEmpty();
     System.out.println("判空:"+empty);

     LinkList<Object> linkList1 = new LinkList<>();
     boolean empty = linkList1.isEmpty();
     System.out.println("判空:"+empty);
}

false  true

7、 update(int index,Object obj) 修改节点元素   

/**
* 修改节点元素   
*/
public void update(int index,Object obj) {
// 范围校验
   if (index >= this.size  || index<0) {
       throw new IndexOutOfBoundsException();
   }
   this.get(index).data=obj;
} 

测试

public static void main(String[] args) {
     // 插入元素测试
     LinkList<Object> linkList = new LinkList<>();
     linkList.insert(true);
     linkList.insert(2);
     linkList.insert("aa");
     linkList.insert(7.5D);
		
     // 修改指定节点元素
     linkList.update(2,900);
     linkList.traverse();
}

打印结果：
true 2 900 7.5

源码链接：https://download.csdn.net/download/xuewenyong/11110536

以上源码可直接运行。