致我曾经敲过的代码——初涉JAVA 自定义链表的实现

1.链表结构是什么样的？

链表自然就是链式的结构

 

2.链表的组成

链表是由头节点，中间节点和尾节点组成

节点是由两个部分组成：

1.数据域-- 如果有多个数据，存储为一个

2.引用域-- 单链表就只有一个引用双链表两个引用

 

3.链表的实现

Node{

数据域

引用域

}

MyLinkedList{

记录元素总数的属性

头节点属性

Noderoot;

尾节点属性

Nodetrail;

 

添加元素的方法

移除元素的方法

插入元素的方法

修改元素的方法

获取元素的方法

获取元素总数的方法

}

 

具体的实现

 

//节点的类
package Link;

public class Node2<E> {

	private Object obj;// 节点内的数据对象

	private Node2<E> parent;// 对父节点的引用
	private Node2<E> kid;// 对子节点的引用

	// 在创建节点对象的时候 就传入节点中的数据对象
	public Node2(Object obj) {
		this.obj = obj;
	}

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}

	public Node2<E> getParent() {
		return parent;
	}

	public void setParent(Node2<E> parent) {
		this.parent = parent;
	}

	public Node2<E> getKid() {
		return kid;
	}

	public void setKid(Node2<E> kid) {
		this.kid = kid;
	}

}
//MyLinkedList链表类

package Link;

import java.util.ArrayList;

public class MyLinkedList2<E> {

	private int size;
	private Node2<E> root;// 头节点
	private Node2<E> trail;// 尾节点

	/**
	 * 添加元素的方法
	 * 
	 * @param e要添加的新元素对象
	 */
	public void add(E e) {
		// 创建Node对象
		Node2<E> node = new Node2<E>(e);

		// 如果是第一次添加节点
		if (root == null) {
			root = node;
			trail = node;
		} else {// 表示不是第一次添加节点
				// 将新节点做为尾节点
			trail.setKid(node);
			trail = node;
		}

		size++;// 记录元素总数属性增加1
	}

	/**
	 * 移除指定索引位置元素的方法
	 * 
	 * @param index索引位置
	 * @return 返回移除后的数据
	 */
	public E remove(int index) {
		// 判断index是否在范围之内
		if (index < 0 || index >= size)
			return null;
		if (index == 0) {
			E e = (E) root.getObj();
			root = root.getKid();
			size--;
			return e;
		}
		Node2<E> t_node = root;
		// 找index的上一个节点
		for (int i = 0; i < index - 2; i++) {
			t_node = t_node.getKid();
		}
		Node2<E> r_node = t_node.getKid();
		Node2<E> r_n_node = r_node.getKid();

		// 构建关系
		t_node.setKid(r_n_node);

		// 记录元素的总数属性减少1
		size--;

		return (E) r_node.getObj();
	}

	/**
	 * 获取指定索引位置元素的方法
	 * 
	 * @param index索引位置
	 * @return 返回index对应的元素
	 */
	public E get(int index) {
		// 判断index是否在范围之内
		if (index < 0 || index >= size)
			return null;
		Node2<E> t_node = root;
		// 找index位置节点
		for (int i = 0; i < index - 1; i++) {
			t_node = t_node.getKid();
		}
		return (E) t_node.getObj();
	}

	/**
	 * 根据索引删除节点
	 * 
	 * @param index
	 *            :索引
	 */
	public void delete(int index2) {
		// if (index < 0 || index >= size)
		int index = index2 - 1;
		if (this.getLength() < index || index < 0) {
			throw new java.lang.RuntimeException("下标越界" + index + ",size:"
					+ this.getLength());
		} else {
			Node2<E> node = this.getNode(index);
			Node2<E> parent = node.getParent();
			Node2<E> kid = node.getKid();
			if (parent == null) {
				root = kid;
			} else if (kid == null) {
				parent.setKid(null);
			} else {
				parent.setKid(kid);
				kid.setParent(parent);
			}
		}
		size -= index;
	}

	/**
	 * 获取链表的长度
	 * 
	 * @return 链表
	 */
	public int getLength() {
		int count = 0;
		if (root == null) {
			return count;
		}
		Node2<E> node = root.getKid();
		while (null != node) {
			count++;
			node = node.getKid();
		}
		return count + 1;
	}

	/**
	 * 插入一个新数据
	 * 
	 * @param index2
	 *            对象的索引
	 * @param obj
	 *            插入的元素
	 */
	public void insert(int index2, Object obj) {
		int index = index2 - 1;
		if (this.getLength() < index || index < 0) {
			throw new java.lang.RuntimeException("下标越界" + index + ",size:"
					+ this.getLength());
		} else {
			Node2<E> newNode = new Node2<E>(obj);
			Node2<E> node = this.getNode(index2);
			if (index == 0)
				root = newNode;
			else {
				Node2<E> fNode = node.getParent();
				fNode.setKid(newNode);
				newNode.setParent(fNode);
			}
			newNode.setKid(node);
			node.setParent(newNode);
		}
	}

	/**
	 * 修改对象节点
	 * 
	 * @param index
	 *            ：对象节点的索引
	 * @param obj
	 *            ：修改对象的内容
	 */
	public void update(int index2, Object obj) {
		int index = index2 - 1;
		if (this.getLength() < index || index < 0) {
			throw new java.lang.RuntimeException("下标越界" + index + ",size:"
					+ this.getLength());
		} else {
			Node2<E> node = this.getNode(index);
			node.setObj(obj);
			Node2<E> parent = node.getParent();
			Node2<E> kid = node.getKid();
		}
	}

	/**
	 * 根据索引取出节点
	 * 
	 * @param index
	 *            ：索引
	 * @return 返回的节点
	 */
	public Node2<E> getNode(int index) {
		if (this.getLength() < index || index < 0) {
			throw new java.lang.RuntimeException("下标越界" + index + ",size:"
					+ this.getLength());
		} else {
			int num = 0;
			Node2<E> node = root;
			while (num != index) {
				node = node.getKid();
				num++;
			}
			return node;
		}
	}

	/**
	 * 遍历链表
	 * 
	 * @param root
	 *            ：链表的根据点
	 */
	public void print(Node2<E> root) {
		if (null != root) {
			Object data = root.getObj();
			System.out.print(data + "  ");
			Node2<E> tmp = root.getKid();
			print(tmp);
		}
	}

	/**
	 * 获取链表元素的总数的方法
	 * 
	 * @return 返回size属性
	 */
	public int size() {
		return size;
	}
}
//测试的主类
package Link;

import java.util.Random;

/**
 * 差不多就是测试的东西吧
 * 
 * @author Natsu
 * 
 */
public class Manager2 {
	public static Node2<String> front = null;
	public Node2<String> last = null;

	public static void main(String[] args) {
		MyLinkedList2<String> mll = new MyLinkedList2<String>();

		Random rand = new Random();

		for (int i = 0; i < 10; i++) {
			char c = (char) (rand.nextInt(26) + 97);
			mll.add(c + "");
		}

		// for (int i = 0; i < mll.size(); i++) {
		// 遍历链表的方法
		mll.print(mll.getNode(0));
		// }
		System.out.println();
		mll.print(mll.getNode(0));
		System.out.println();
		System.out.println("++++++++++++++++++++++++++++++++");
		mll.delete(3);
		// 遍历链表的方法
		mll.print(mll.getNode(0));
		System.out.println();
		System.out.println("++++++++++++++++++++++++++++++++");
		// 移除第五位
		mll.remove(4);
		mll.print(mll.getNode(0));
		System.out.println();
		System.out.println("++++++++++++++++++++++++++++++++");
		mll.update(3, "e");
		mll.print(mll.getNode(0));
		System.out.println();
		System.out.println("++++++++++++++++++++++++++++++++");
		mll.insert(3, "r");
		mll.print(mll.getNode(0));
	}

}

 

版权声明：本文为博主原创文章，未经博主允许不得转载。