致我曾经敲过的代码——初涉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() {
b56c

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));
}

}