链表与双向链表

链表与双向链表

一、特点

1）数组列表

 

缺点 ：添加很慢

 

优点：查询快、元素是整块出现的

 

大小是可变的

 

可以删除

 

2）链表：

 

优点：添加很快 删除

 

缺点：查询慢、元素是零散出现的数组列表

链表是一个一个的结点相连接，需要定义结点，是链式的数据结构。

二、链表实现

1）定义一个结点

public class Node {

public Object data;//节点数据

public Node next;//下一个节点

}

2）测试功能

public class test {

private int size=6;

// 初始化6个节点

public Node createlink() {
Node root = new Node();
String s0 = "a";
Object o = (String) s0;
root.data = o;
 
Node next1 = new Node();
String s1 = "b";
Object o1 = (String) s1;
next1.data = o1;
 
Node next2 = new Node();
String s2 = "c";
Object o2 = (String) s2;
next2.data = o2;
 
Node next3 = new Node();
String s3 = "d";
Object o3 = (String) s3;
next3.data = o3;
 
Node next4 = new Node();
String s4 = "e";
Object o4 = (String) s4;
next4.data = o4;
 
Node next5 = new Node();
String s5 = "f";
Object o5 = (String) s5;
next5.data = o5;

//建立各结点之间的链接关系
root.next = next1;
next1.next = next2;
next2.next = next3;
next3.next = next4;
next4.next = next5;
 
return root;
}
 
de();
root.next = add_node;
add_node.data = data;
size++;
}

// 在末尾增加一个节点的数据
public void add(Node root, Object data) {
while (null != root.next) {
root = root.next;
}
Node add_node = new No

// 在指定位置增加一个节点

public boolean add(Node root, Object data, int index) {
if (index < 0 || index > size) {
return false;
}
 
for (int i = 1; i < index - 1; i++) {
root = root.next;
 
}
Node tmp = root.next;
Node add_node1 = new Node();
root.next = add_node1;
add_node1.data = data;
 
add_node1.next = tmp;
size++;
return true;
}

 

// 遍历输出链表

public Node println(Node root) {
int i = 1;
while (null != root) {
Object data = root.data;
root = root.next;
System.out.println("第" + i + "个节点是" + data);
i++;
 
}
return root;
}

 

// 删除指定位置的数据

public Object delete(Node root, int index) {
if (index == 1) {
root = root.next;
return root;
} else {
Node temp = root;
for (int i = 1; i < index - 1; i++) {
root = root.next;
}
root.next = root.next.next;
return temp.data;
}
 
}

 

// 主函数

public static void main(String[] args) {
test te = new test();
Node root = te.createlink();
te.println(root);
System.out.println("  ");
root.data = te.delete(root, 3);
te.println(root);
System.out.println("  ");
 
te.add(root, "hello");
te.println(root);
System.out.println("  ");
 
te.add(root, "world", 4);
te.println(root);
}
}

三、运行结果

 

四。双向链表的实现

1.定义节点

public class Double_Node<E> {
Double_Node<E> next;
Double_Node<E> last;
public E data;
public Double_Node(E e) {
data = e;
}
}

2.功能实现

public class Double_Link<E> implements MyArrayList<E> {
private Double_Node<E> head;
private Double_Node<E> tail;
private int size = 0;

// 末尾增加一个节点
public void add(E e) {
Double_Node<E> newnode = new Double_Node<E>(e);
if (size == 0) {
head = newnode;
tail = newnode;
} else {
newnode.last=tail;
tail.next = newnode;
tail = newnode;
}
size++;
}

//指定位置增加节点
public boolean add(int index, E e) {
Double_Node<E> newnode = new Double_Node<E>(e);

// 临时节点
Double_Node<E> tmpNode = head;
if (index < 0 || index > size)
return false;
else {
if (index == 1) {
head.last = newnode;
newnode.next = head;
head = newnode;
} else {
tmpNode = getNode(tmpNode, index - 1);
newnode.last = tmpNode.last;
newnode.next = tmpNode;
tmpNode.last.next = newnode;
tmpNode.last = newnode;
}

// 长度
size++;
return true;
}
}

//删除某个节点
public boolean remove( int index) {
Double_Node<E> tmpNode = head;
if (size == 0 || index > size) // 对外界操作进行限定
return false;
else {
if (index == 1) {
head = head.next;
} else {
// 1、找到这个位置的节点
tmpNode = getNode(tmpNode, index - 1);
// 2、更改上一个节点的后指针
tmpNode.last.next = tmpNode.next;
// 3、更改下一个节点的前指针
tmpNode.next.last = tmpNode.last;
}
size--;
return true;
}
 
}

//更新某个节点的数据
public boolean update(int index, E newE) {
Double_Node<E> tmpNode = head;
if (size == 0 || index > size) // 对外界操作进行限定
return false;
else {
// 1、找到这个位置的节点
tmpNode = getNode(tmpNode, index - 1);
 
// 2、改变此位置节点值
tmpNode.data = newE;
return true;
}
}

//获取各结点的数据
public E get(int index) {
// 新建一个节点，等于头节点
Double_Node<E> node = head;
for (int i = 0; i < index; i++) {
// 往后移动一个
node = node.next;
}
             return node.data;
}
//获取链表长度
public int size() {
return size;
}
//获取链表数据
public Double_Node<E> getNode(Double_Node head, int index) {
// 新建一个节点，等于头节点
Double_Node<E> node = head;
for (int i = 0; i < index; i++) {
// 往后移动一个
node = node.next;
}
return node;
}
}

 

3.主函数调用

 public class Manager {
public static void main(String[] args) {
Double_Link<String> newNode = new Double_Link<String>();
newNode.add("a");
newNode.add("b");
newNode.add("c");
newNode.add("d");
newNode.add("e");
newNode.add("f");
newNode.add("g");
         for(int i=0;i<newNode.size();i++){
 System.out.println( newNode.get(i));
}
 
 newNode.remove(1);
         for(int i=0;i<newNode.size();i++){
  System.out.println( newNode.get(i));
}
 
newNode.update(1, "改变节点");
newNode.add(1,"hhhh");
for(int i=0;i<newNode.size();i++){
System.out.println( newNode.get(i));
}
}
}

运行结果