数据结构学习之单链表

定义节点类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) {
			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;
                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<0 || index>this.size){
			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()判断链表是否为空

/**
	 * 判空
	 * @return
	 */
	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) {
		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

数据结构学习之单链表

猜你喜欢