自定义数据结构 链表(单项 ,双向,环形)

 

   链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的

 

   

单项链表;数据从第一个指向最后一个

 

实现代码:

 

    

//定义动态链表
class  Node<E>{
	
	E e;//定义的节点
	Node next;//节点的下一个
	Node front ;//节点的前一个


	public Node(E e){
        this.e =(E)e;
	}


	public  String toString(){
		return (String)e;
	}
}

//创建单项链表类
public class LinkedList{
	public static void main(String[] args) {
		LinkedList list  = new LinkedList();
		Node node=list.creatNode();
		list.printlist(node);
	}


	public Node<String> creatNode(){

	Node<String> node = new  Node<String>("节点一");
	Node<String> node2 = new  Node<String>("节点二");
	Node<String> node3 = new  Node<String>("节点三");
    Node<String> node4 = new  Node<String>("节点四");	
	

	node.next = node2;
	node2.next = node3;
	node3.next = node4;

	node4.front = node3;
	node3.front = node2;
	node2.front = node;

	return node;
	
	}


	public void printlist(Node node){
       while(node!=null){
		   System.out.println(node);
		   node = node.next;
	   }
	}

}

 运行结果:

节点一

节点二

节点三

节点四

 

 

 

双向链表:可以指定前面节点也可以指向后面数据的节点

    实现链表的增删改查 等方法

 

    

/**
 * 节点类
 * 
 * @author kowloon
 * 
 */
public class Node<E> {

	E e;// 节点中的元素
	
	Node<E> front;// 对前一个节点的引用
	Node<E> next;// 对下一个节点的引用

	public Node(E e) {
		this.e = e;
	}

	@Override
	public String toString() {
		return (String) e;
	}

}

 

节点的方法

package trr0717链表;

public class LinkedList1 {
	Node head = null;
	Node foot = null;
	int count = 0;

	public Node getHead() {
		return head;
	}

	// 直接在后面增加节点
	public void add(String s) {
		Node node = new Node(s);

		if (head == null) {// 当没有头节点的时候
			head = node;
			foot = node;
		} else {// 双链表
			foot.next = node;
			node.front = foot;
		}
		foot = node;
		count++;
	}

	// 直接在后面增加节点
	public void add(int index, String s) {
		if (index < 0 || index >= size()) {// 若数组越界就抛出异常
			throw new IndexOutOfBoundsException("数组的个数：" + size() + "第几个数组"
					+ index);
		}
		Node nodenew = new Node(s);

		Node node = getNode(index);
		if (index == 0) {// 若是o下标
			node.front = nodenew;
			nodenew.next = node;

			head = nodenew;
			/* System.out.println(head+"<><><><"); */
		} else {

			Node frontnode = node.front;
			Node nextnode = node.next;

			frontnode.next = nodenew;
			nodenew.next = nextnode;
			nodenew.front = frontnode;
			nextnode.front = nodenew;
		}
		count++;
	}

	// 移除指定位置的节点
	public void remove(int index) {
		if (index < 0 || index >= size()) {// 若数组越界就抛出异常
			throw new IndexOutOfBoundsException("数组的个数：" + size() + "第几个数组"
					+ index);
		}
		if (index == 0) {
			Node n = head.next;// 先要接触引用关系
			head.next = null;
			n.front = null;
			head = n;
		}

		else {
			Node node = getNode(index);// 得到指定位置上下一个节点
			Node fnode = node.front;
			Node nextnode = node.next;
			fnode.next = nextnode;// 把指定位置的下一个节点给他上一个节点
			nextnode.front = fnode;

		}

		count--;

	}

	// 移除指定内容的节点
	public void remove(String s) {
		Node node = head;
		for (int i = 0; i < size(); i++) {
			if (node.e.equals(s)) {// 若相等
				remove(i);
				break;
			}
			node = node.next;
		}
	}

	// 修改指定地点的节点内容
	public void set(int index, String s) {
		Node n = getNode(index);
		n.e = s;
	}

	// 取得某个节点对象
	public Node getNode(int index) {
		if (index < 0 || index >= size()) {// 若数组越界就抛出异常
			throw new IndexOutOfBoundsException("数组的个数：" + size() + "第几个下标"
					+ index);
		}
		int i = 0;
		Node node = head;// 把head也放到队列里面
		while (i < index) {
			i++;
			node = node.next;

		}
		/* System.out.println("第"+i+"个节点："+node); */

		return node;
	}

	// 链表的大小
	public int size() {
		System.out.println("数组个数：" + count);
		return count;
	}

	// 遍历链表的方法
	public static void linkedVist(Node head) {
		if (head != null) {
			System.out.println(head);
			Node node = head.next;
			linkedVist(node);
		}
	}
}