数据结构与算法_单向链表

链表

1. 什么是链表？

链表是一种物理存储上非连续、非顺序的存储结构，数据元素之间是通过指针链接起来的。

链表是由节点组成的，节点可在链表存储时动态生成。一个节点由它的数据域和指向下一个节点的指针域组成。

由于线性表在插入元素和删除元素时的时间复杂度为O(n)，而链表的时间复杂度O(1)，所以链表适合执行插入元素和删除元素。

但是链表没有索引，它的get方法是假索引，不支持角标操作，所以每次查找元素必须从头查找，即时间复杂度为O(n)；而线性表和顺序表镶银的时间复杂度为O(logn)和O(1)。因此，链表不适合用做元素的查询操作。

2. 什么是链表的头指针头节点？

链表由节点组成，链表的第一个节点我们称之为头节点，有真是头节点和虚拟头节点之分；头指针是指向第一个节点的指针，通常命名为head。
真实头节点：是链表的第一个节点用于存放数据元素。

虚拟头节点：是链表的第一个节点不许存放数据（本次以虚拟头节点为主）
尾指针：和头指针类似，只不过尾节点是链表的最后一个节点

链表的插入有头插法、尾插法和一般插入；
链表的删除有从头删除、从尾删除和一般删除。

链表的代码实现

list接口

/**
 * List线性表的最终父接口
 * @author Administrator
 *
 * @param <E>
 */
public interface List<E> {

	/**
	 * 获取线性表中元素的个数（线性表的长度）
	 * @return 线性表中有效元素的个数
	 */
	public int getSize();
	
	/**
	 * 判断线性表是否为空
	 * @return 是否为空的布尔类型值
	 */
	public boolean isEmpty();
	
	/**
	 * 在线性表中指定的index角标处添加元素e
	 * @param index 指定角标0<=index<size
	 * @param e要插入的元素
	 */
	public void add(int index,E e);
	
	/**
	 * 在线性表的表头位置插入一个元素
	 * @param e要插入的元素 指定在角标size处
	 */
	public void addFirst(E e);
	
	/**
	 * 在线性表的表尾位置插入一个元素
	 * @param e要插入的元素 指定在角标size处
	 */
	public void addLast(E e);
	
	/**
	 * 在线性表中获取指定Index角标处的元素
	 * @param index 指令的角标
	 * @return 该角标所对应的元素
	 */
	public E get(int index);
	
	/**
	 * 获取线性表中表头的元素
	 * @return	表头元素 index=0
	 */
	public E getFirst();
	
	/**
	 * 获取线性表中表尾的元素
	 * @return 表尾元素 index=size-1
	 */
	public E getLast();
	
	/**
	 * 修改线性表中指定Index 处的元素为新元素e
	 * @param index 指定的角标
	 * @param e	新元素
	 */
	public void set(int index,E e);
	
	/**
	 * 判断线性表中是否包含指定元素e 默认从前往后
	 * @param e 要判断是否存在的元素
	 * @return	元素的存在性布尔类型值
	 */
	public boolean contains(E e);
	
	/**
	 * 在线性表中获取指定元素e的角标 默认从前往后找
	 * @param e	查找的元素
	 * @return	查找到元素的索引
	 */
	public int find(E e);
	
	/**
	 * 在线性表中删除指定角标处的元素 并返回
	 * @param index 指定的角标0<index<size
	 * @return 删除掉老元素
	 */
	public E remove(int index);
	
	/**
	 * 删除线性表中的表头元素
	 * @return 表头元素
	 */
	public E removeFirst();
	
	/**
	 * 删除线性表中的表尾元素
	 * @return 表尾元素
	 */
	public E removeList();
	
	/**
	 * 在线性表中删除指定元素e
	 * @param e
	 */
	public void removeElement(E e);
	
	/**
	 * 清空线性表
	 */
	public void clear();
}

LinkedList链表的代码实现

LinkedList的内部类Node，用于创建节点

/**
	 * 单向链表的节点
	 * 
	 * @author Administrator
	 *
	 */
	private class Node {
		E data; // 数据域
		Node next; // 指针域

		public Node() {
			this(null, null);
		}

		public Node(E data, Node next) {
			this.data = data;
			this.next = next;
		}

		@Override
		public String toString() {
			return data.toString();
		}
	}

LinkedList的私有属性和构造方法

public class LinkedList<E> implements List<E> {
	private Node head; // 指向虚拟头节点的头指针
	private Node rear; // 指向尾节点的尾指针
	private int size; // 记录元素的个数

	public LinkedList() {
		head = new Node();
		rear = head;
		size = 0;
	}

	public LinkedList(E[] arr) {
		head = new Node();
		rear = head;
		size = 0;
	}
}

创建出来的空链表如图：

LinkedList的长度和判空方法

	@Override
	public int getSize() {

		return size;
	}

	@Override
	public boolean isEmpty() {

		return size == 0 && head.next == null;
	}

getSize()方法是返回链表的有效长度。定义LinkedList的方法时，将size属性定义为链表的长度，即（return size;）可以返回链表的长度。
isEmpty()方法是判断链表是否为空的方法。size属性是记录链表的长度，所以size= =0即可判断链表是否为空。为了安全起见可以加上头指针的下一跳，即head.next= =null加强判断。

LinkedList添加节点

	@Override
	public void add(int index, E e) {

		if (index < 0 || index > size) {
			throw new IllegalArgumentException("插入角标非法!");
		}
		Node n = new Node(e, null);
		if (index == 0) {// 头插

			n.next = head.next;
			head.next = n;
			if (size == 0) {
				rear = n;
			}

		} else if (index == size) {// 尾插

			rear.next = n;
			rear = rear.next;

		} else {// 一般插入

			Node p = head;
			for (int i = 0; i < index; i++) {
				p = p.next;
			}
			n.next = p.next;
			p.next = n;
		}
		size++;
	}

	@Override
	public void addFirst(E e) {

		add(0, e);
	}

	@Override
	public void addLast(E e) {

		add(size, e);
	}

add()方法是添加节点的方法，index是添加的位置，e是添加的元素的值。
分析：
当index传进的值小于0或者大于链表的长度size时，不能添加节点，所以抛出异常。
当index=0时，用头插法。即头节点的下一跳赋给新节点，头节点的下一跳指向新节点。且长度size+1。

当index=size时，用尾插法完成。即将n赋给尾节点的下一跳，并将尾节点的下一跳赋给尾节点。且长度size+1。

当0<index<size时，用一般插入的方法。

执行addFirst()和addLast()方法时，可以调用add()方法，传参为index=0,index=size即可。

LinkedList的获取元素的方法

@Override
	public E get(int index) {

		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("查找角标非法!");
		}
		if (index == 0) {
			return head.next.data;
		} else if (index == size - 1) {
			return rear.data;
		} else {
			Node p = head;
			for (int i = 0; i <= index; i++) {
				p = p.next;
			}
			return p.data;
		}
	}

	@Override
	public E getFirst() {

		return get(0);
	}

	@Override
	public E getLast() {

		return get(size - 1);
	}

get()方法是获取元素的方法，当index传进的值小于0或者大于链表的长度size时，不能添加节点，所以抛出异常。
分析：
当index等于0时，返回头节点的下一跳的元素值。
当index等于size-1时，返回尾节点的元素值。
当0<index<size-1时，从头查找，查找到index时，返回节点值。

LinkedList设置节点的值

@Override
	public void set(int index, E e) {

		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("修改角标非法!");
		}
		if (index == 0) {
			head.next.data = e;
		} else if (index == size - 1) {
			rear.data = e;
		} else {
			Node p = head;
			for (int i = 0; i <= index; i++) {
				p = p.next;
			}
			p.data = e;
		}
	}

和返回节点的值雷同，即：
当index等于0时，新元素元素取代头节点的下一跳的元素值。
当index等于size-1时，新元素元素取代尾节点的元素值。
当0<index<size-1时，从头查找，查找到index时，新元素元素取代节点值。

LinkedList的查找方法

@Override
	public boolean contains(E e) {

		return find(e) != -1;
	}

	@Override
	public int find(E e) {

		int index = -1;
		if (isEmpty()) {
			return index;
		}
		Node p = head;
		while (p.next != null) {
			p = p.next;
			index++;
			if (p.data == e) {
				return index;
			}
		}
		return -1;
	}

当链表为空时，返回-1；
当从头节点遍历链表，找到对应的元素时，返回元素在链表中的位置；
当遍历没有找到元素时，返回-1。
LinkedList的删除节点方法

@Override
	public E remove(int index) {

		if (index < 0 || index > size) {
			throw new IllegalArgumentException("删除角标非法!");
		}
		E res;
		if (index == 0) {// 头删
			Node p = head.next;
			res = p.data;
			head.next = p.next;
			p.next = null;
			p = null;
			if (size == 1) {
				rear = head;
			}
		} else if (index == size - 1) {
			Node p = head;
			res = rear.data;
			while (p.next != rear) {
				p = p.next;
			}
			p.next = null;
			rear = p;
		} else {
			Node p = head;
			for (int i = 0; i < index; i++) {
				p = p.next;
			}
			Node del = p.next;
			res = del.data;
			p.next = del.next;
			del.next = null;
			del = null;
		}
		size--;
		return res;
	}

	@Override
	public E removeFirst() {

		return remove(0);
	}

	@Override
	public E removeList() {

		return remove(size - 1);
	}

	@Override
	public void removeElement(E e) {
		int index = find(e);
		if (index == -1) {
			throw new IllegalArgumentException("删除角标非法!");
		}
		remove(index);
	}

头删法：

尾删法：

一般删法：

LinkedList的清空链表

@Override
	public void clear() {

		head.next = null;
		rear = head;
		size = 0;
	}

使头节点的下一跳指向空，尾节点指向头节点，链表长度为0；暴力清空。

重写toString方法

@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("size:" + getSize() + "\n");
		if (isEmpty()) {
			sb.append("[]");
		} else {
			sb.append("[");
			Node p = head;
			while (p.next != null) {
				p = p.next;
				if (p == rear) {
					sb.append(p.data+"]");
				} else {
					sb.append(p.data+",");
				}
			}
		}

		return sb.toString();
	}

练习题

解析：这个题是关于链表的概念理解，链表没有索引，它的索引是假索引，是将链表从头节点遍历到目标元素，在将目标元素的位置返回，即可以按照逆向思维完成索引的查找。

解析：这个题是问定义数组哪个是正确的，所以A正确。

解析：链表查找节点是将链表从头节点遍历到目标节点，而顺序表是按照索引查找。

解析：“==”是比较值，所以相等，即返回true。

解析：这个题是查找单链表中的元素，即对单链表遍历，查找的平均值。
最少1次 最多n次 平均(n+1)/2次

解析：在第一个位置插入移动127次，在最后一个位置插入移动0次。平均(127+0)/2次

解析：链表适用于插入和删除，顺序遍历时，所有的时间复杂度一样，所以选链表。

解析：
java的访问权限有public、protected、private和default的，default不能修饰变量
native修饰方法，native修饰的方法简单来说就是：一个Java方法调用了一个非Java代码的接口。
定义navtive方法时，并不提供实现体，因为其实现体是用非Java语言在外面实现的。native可以和任何修饰符连用，abstract除外。因为native暗示这个方法时有实现体的，而abstract却显式指明了这个方法没有实现体。
普通变量不能用abstract修饰，abstract一般修饰方法和类
被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的

在链表的末尾插入和删除一个节点时，需要修改其相邻节点的指针域。而寻找尾结点以及尾结点的前驱结点，只有带头结点的双循环链表所需要的时间最少。主要是寻找耗时。

解析：这个题有问题。至于选择正确的原因是将题看成(a+b).equals©。

public static void main(String[] args) {
		
		String a="a";
		String b="b";
		String c=a+b;
		String d=new String("ab");
		System.out.println(a.equals(b));
		System.out.println(a+b==c);
		System.out.println(c==d);
		System.out.println(c.equals(d));
	}`

输出：
false
false
false
true

237.删除链表中的节点
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。

思路：
当node= =null throw new NullpointerException(“链表为空”);
创建 ListNode next = node.next;
当next= =null，throw new RuntimeException(“不能删除最后一个节点”);
其他情况时，node.val=next.val;node.next=next.next;

上代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        ListNode next = node.next;
        if(next == null){
           throw new RuntimeException("不能删除最后一个节点");
        }
        node.val = next.val;
        node.next = next.next;
    }
}

83.删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3

解题思路：
因为该题的已排序，相等的元素会相邻；
定义指针p指向head;
遍历整个链表，当p.next.val==p.val,将p的下一个节点的下一个节点赋给p的下一个节点；
否则p=p.next;向后循环。
最后返回头节点head。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode p=head;
        while(p!=null&&p.next!=null){
            if(p.next.val==p.val){
                p.next=p.next.next;
            }else{
                p=p.next;
            }
        }
        return head;
    }
}