Java数据结构和算法--链表

链表

//链表
public class LinkList {

    public static void main(String[] args) {
        LinkList l = new LinkList();
        // 增加
        l.insertFirst(1, 1d);
        l.insertFirst(2, 2d);
        l.insertFirst(3, 3d);
        l.displayList();
        // 查询
        Link findLink = l.find(6);
        if (findLink != null) {
            System.out.println(findLink.dData);
        }
        // 删除
        l.deleteLike(7);
        l.displayList();

    }

    // 第一个链接点的位置。
    public Link first;

    public LinkList() {
        first = null;
    }

    // 插入数据：插入的新数据为链表的收割链接点，并且将下一个链接点的地址指向插入前的首数据。
    public void insertFirst(int id, double dd) {
        // 新链接点
        Link link = new Link(id, dd);
        // 将新链接点的关系子段 next 指向旧的首链接点。
        link.next = first;
        // 将链表的第一个链接点指向新增的链接点地址。
        first = link;
    }

    // 删除：将当前first 指向第二个链接点断开和第一个链接点的连接，
    public Link deleteFirst() {
        Link temp = first;
        first = first.next;
        return first;
    }

    // 查询
    public Link find(int key) {
        // 将link
        Link current = first;
        // 如果当前link 不是要查询的 数据，则通过它next 子段，查询到下一个链接点。
        // 直到找到为止
        while (current.iData != key) {
            if (current.next != null) {
                // 如果不是要查询的数据，则通过关系访问下一个链接点，
                // 注意，这里没有下标的概念，所有查询通过关系来操作。
                current = current.next;
            } else {
                System.out.println("没有找到数据");
                current = null;
                break;
            }
        }
        return current;
    }

    // 删除：主需要将删除链接点的前一个链接点的next地址指向删除链接点的下一个链接点位置。
    // 链表删除不需要考虑链表中的其他数据，之需要改变删除连接之前链接点的地址而已。
    // 操作的对象只有删除链接点的前后两个链接点。其他链接点不需要操作，因为他们不像数组
    // 依靠位置来决定数据的，这里只是根据关系来操作，抽象说只是操作链接点指向，也就是改变关系。
    public void deleteLike(int key) {
        // 当前链接点
        Link current = first;
        // 前一个链接点
        Link privous = first;

        boolean isfind = true;

        // 判断是否是要删除的链接点
        while (current.iData != key) {
            // 如果还有下一个链接点，更换当前的两个链接点
            if (current.next != null) {
                // 两个链接点均想后移动一位，继续判断
                privous = current;
                current = current.next;
            } else {
                System.out.println("no find the Data");
                current = null;
                isfind = false;
                break;
            }
        }
        // 判断是否找到要删除的数据
        if (isfind == true) {
            // 如果要删除的是首个链接点，则将first 指向当前链接点的下一个点，first.next
            if (current == first) {
                first = first.next;
            } else {
                // 如果不是删除首链接点，则将要删除的链接点的前一个链接点的next地址指向
                // 删除点的下一个链接点即可。
                // 注意：删除操作只是改变的链接点的指向，并没有实际删除了数据。该数据将被回收机制处理。
                privous.next = current.next;
            }
        } else {
            System.out.println("no find the Data of delete");
        }

    }

    public Link displayList() {
        System.out.println("List (fist - -> last )");
        Link top = first;
        while (top != null) {
            top.displayLink();
            top = top.next;
        }
        ;
        return top;
    }

    public boolean isEmpty() {
        return (first == null);
    }
}

// 链接点对象
class Link {
    public int iData;
    public double dData;

    // 关系子段，用于存储下一个链接点的位置
    public Link next;

    public Link(int id, double dd) {
        this.iData = id;
        this.dData = dd;
    }

    public void displayLink() {
        System.out.println("{" + iData + "," + dData + "}");
    }
}

(1)简单链表

package ChapterFive;

class Link<E> {

	public E data;

	public Link<E> next;

	public Link(E data) {
		this.data = data;
	}
}

class LinkList<E> {

	public Link<E> first;
	//链表中数据项的个数
	public int size;

	public LinkList() {
		first = null;
		size = 0;
	}
	//在表头插入新的数据
	public void insertFirst(E value) {
		Link<E> link = new Link<E>(value);
		link.next = first;
		first = link;
		size++;
	}
	//判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//删除表头
	public Link<E> deleteFirst() {
		Link<E> temp = first;
		first = first.next;
		size--;
		return temp;
	}
	//输出链表中的所有数据
	public void display() {
		Link<E> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
	//返回链表中数据项的个数
	public int size() {
		return size;
	}
	//获取从头至尾的第i个数据项
	public Link<E> get(int i) {
		if (i > size() - 1 || i < 0)
			try {
				throw new IndexOutOfBoundsException();
			} catch (Exception e) {
				e.printStackTrace();
			}
		Link<E> curr = first;
		for (int n = 0; n < size(); n++) {
			if (n == i)
				return curr;
			else
				curr = curr.next;
		}
		return null;
	}
	//输出从头至尾的第i个数据项
	public void remove(int i) {
		if (i == 0)
			deleteFirst();
		else if (i == size() - 1)
			get(i - 1).next = null;
		else {
			get(i - 1).next = get(i + 1);
		}
		size--;
	}
}

public class Link_list {
	public static void main(String[] args) {
		LinkList<Long> ll = new LinkList<Long>();
		for (int i = 0; i < 10; i++) {
			Long value = (long) (Math.random() * 100);
			ll.insertFirst(value);
		}
		ll.display();
		while (!ll.isEmpty()) {
			ll.deleteFirst();
			ll.display();
		}
		System.out.println("Ok");
	}
}

(2)链栈

package ChapterFive;

class LinkStack<E> {

	LinkList<E> linkList;

	int size;

	public LinkStack() {
		size = 0;
		linkList = new LinkList<E>();
	}
	//入栈
	public void push(E value) {
		linkList.insertFirst(value);
		size++;
	}
	//出栈
	public Link<E> pop() {
		size--;
		return linkList.deleteFirst();
	}
	//返回栈顶元素
	public Link<E> top() {
		return linkList.first;
	}
	//判断栈是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//显示栈中的全部数据
	public void display() {
		linkList.display();
	}
}

public class Link_stack {
	public static void main(String[] args) {
		LinkStack<Long> ls = new LinkStack<Long>();
		for (int i = 0; i < 10; i++) {
			Long value = new Long((long) (Math.random() * 100));
			ls.push(value);
		}
		while (!ls.isEmpty()) {
			ls.pop();
			ls.display();
		}
		System.out.println("Ok");
	}
}

(3)有序表

package ChapterFive;

class SortedLink {

	public Link<Long> first;

	int size;

	public SortedLink() {
		first = null;
		size = 0;
	}
	//向有序链表中插入数据
	public void insert(long value) {
		Link<Long> newLink = new Link<Long>(value);
		Link<Long> previous = null;
		Link<Long> curr = first;
		while (curr != null && (value > curr.data)) {
			previous = curr;
			curr = curr.next;
		}
		if (previous == null)// 链表为空(在表头插入)
			first = newLink;
		else
			previous.next = newLink;//插入新的节点
		newLink.next = curr;
		size++;
	}
	//删除第一个节点
	public Link<Long> remove() {
		Link<Long> temp = first;
		first = first.next;
		size--;
		return temp;
	}
	//判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//输出链表的所有数据
	public void display() {
		Link<Long> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
}

public class SortedLinkApp {
	public static void main(String[] args) {
		SortedLink sl = new SortedLink();
		for (int i = 0; i < 10; i++) {
			sl.insert((long) (Math.random() * 100));
		}
		while (!sl.isEmpty()) {
			sl.remove();
			sl.display();
		}
	}
}

(4)双向链表

package ChapterFive;

class DoubleLink<E> {

	public Link<E> first;

	public Link<E> last;

	int size;

	@SuppressWarnings("hiding")
	class Link<E> {
		public E data;

		public Link<E> next;// 链表的下一项

		public Link<E> previous;// 链表的前一项

		public Link(E value) {
			this.data = value;
		}
	}

	public DoubleLink() {
		first = null;
		last = null;
		size = 0;
	}

	// 在链表的首部插入一项
	public void insertFirst(E value) {
		Link<E> newLink = new Link<E>(value);
		if (isEmpty())// 如果链表为空则first == last
			last = newLink;
		else
			first.previous = newLink;// 确定原first与newLink的前后关系
		newLink.next = first;
		first = newLink;// 设置新的first值
		size++;
	}

	// 在链表的尾部插入一项
	public void insertLast(E value) {
		Link<E> newLink = new Link<E>(value);
		if (isEmpty())// 如果链表为空则last == first
			first = newLink;
		else {
			last.next = newLink;// 确定原last与newLink的前后关系
			newLink.previous = last;
		}
		last = newLink;// 设置新的last值
		size++;
	}

	// 删除双向链表的表头
	public Link<E> deleteFirst() {
		Link<E> temp = first;
		if (first.next == null)// 链表中只有一项数据
			last = null;
		else
			first.next.previous = null;// 销毁原链表的头部
		first = first.next;
		size--;
		return temp;
	}

	// 删除链表的最后一项
	public Link<E> deleteLast() {
		Link<E> temp = last;
		if (first.next == null)// 链表中只有一项数据
			first = null;
		else
			last.previous.next = null;// 销毁原链表的尾部
		last = last.previous;
		size--;
		return temp;
	}

	// 判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}

	// 输出链表中的所有数据项
	public void display() {
		Link<E> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
}

public class DoubleLinkApp {
	public static void main(String[] args) {
		DoubleLink<Integer> dl = new DoubleLink<Integer>();
		for (int i = 0; i < 5; i++) {
			dl.insertFirst((int) (Math.random() * 100));
		}
		for (int i = 0; i < 5; i++) {
			dl.insertLast((int) (Math.random() * 100));
		}
		dl.display();
		while (!dl.isEmpty()) {
			dl.deleteFirst();
			dl.deleteLast();
			dl.display();
		}
		System.out.println("Ok");
	}
}