数据结构链表java

1. java数据结构有哪几种

JAVA数据结构有以下几种：

1、List：

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组。

2、Vector：

基于数组（Array）的List，其实就是封装了数组所不具备的一些功能方便我们使用，所以它难易避免数组的限制，同时性能也不可能超越数组。

另外很重要的一点就是Vector是线程同步的(sychronized)的，这也是Vector和ArrayList 的一个的重要区别。

3、ArrayList：

同Vector一样是一个基于数组上的链表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector好一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。

4、LinkedList：

LinkedList不同于前面两种List，它不是基于数组的，所以不受数组性能的限制。 它每一个节点（Node）都包含两方面的内容：节点本身的数据（data），下一个节点的信息（nextNode）。

所以当对LinkedList做添加，删除动作的时候就不用像基于数组的ArrayList一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了，这是LinkedList的优势。

5、HashSet：

虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。

但是Set则是在 HashMap的基础上来实现的，这就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。

6、HashMap：

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。(除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

7、HashTable：

Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。

Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为nul

2. java 链表的输出问题

几位的回答都比较清楚了，我想另外说点问题

你本就不应该加入‘表尾’这个属性，在数据结构中链表的特点就是能用一个地址带一个长串数据链的，不用这个属性的话思路会更加清晰。我也用java模拟过一些基本数据结构：

public class MyNode<T> {

public T value;
public MyNode<T> next;

public MyNode() {
}

public MyNode(T value) {
this.value = value;
}

public MyNode(MyNode<T> t) {
this.value = t.value;
this.next = t.next;
}

public void connect(MyNode<T> t){
this.next = t;
}

@Override
public String toString() {
return null==value?"":value+"->";
}
}

在这个节点定义的基础上的链表定义：
public class MyLinkList<T>{

public MyNode<T> next;

public MyLinkList() {
this.next = new MyNode<T>();
}

public MyLinkList(T[] tList) {
if(tList.length==0)return;
next = new MyNode<T>(tList[0]);
MyNode<T> temp = next;
for (int i = 1; i < tList.length; i++) {
temp.connect(new MyNode<T>(tList[i]));
temp = temp.next;
}
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
MyNode<T> t = next;
while (null != t) {
sb.append(t);
t = t.next;
}
return sb.toString();
}

}

然后是相关的操作类：

public class LinkListAction {

MyLinkList<Comparable> list;

public LinkListAction(MyLinkList<Comparable> list) {
this.list = list;
}

/**
* 头插法建立单链表(数组)
* */
public void createFromHead(Comparable...objects){
MyNode<Comparable> start;
for (int i = 0; i < objects.length; i++) {
start = new MyNode<Comparable>(objects[i]);
start.next = list.next;
list.next = start;
}
}
/**
* 尾插法建立单链表(数组)
* */
public void createFromTail(Comparable...objects){
MyNode<Comparable> start;
MyNode<Comparable> end = list.next;
for (int i = 0; i < objects.length; i++) {
start = new MyNode<Comparable>(objects[i]);
end.next = start;
end = start;
}
end.next = null;
}

/**
* 在单链表中查找第i个结点
* */
public MyNode<Comparable> get(int i){
if(i < 0)return null;
MyNode<Comparable> node = list.next;
int index = 0;
while (node != null && index < i) {
node = node.next;
index++;
}
return node;
}

/**
* 在单链表中的按值查找
* */
public MyNode<Comparable> locate(Comparable obj){
if(null == obj)return new MyNode<Comparable>();
MyNode<Comparable> node = list.next;
while (node != null && !obj.equals(node.value)) {
node = node.next;
}
return node;
}

/**
* 求单链表的长度
* */
public int getLength(){
int length = 0;
MyNode<Comparable> node = list.next;
while(null != (node = node.next)){
length++;
}
return length;
}

/**
* 单链表的插入操作(按位置)
* */
public void insert(Comparable obj,int location){
int length = 0;
MyNode<Comparable> node = list.next;
while(node!=null && location != length++){node = node.next;}
if(null == node)throw new RuntimeException("插入位置有误！");
MyNode<Comparable> inserter = new MyNode<Comparable>(obj);
inserter.next = node.next;
node.next = inserter;
}

/**
* 删除数据
* */
public Comparable delete(int i){
int length = 0;
MyNode<Comparable> node = list.next;
while(node!=null && i != length++){node = node.next;}
if(null == node)throw new RuntimeException("删除位置有误！");
Comparable o = node.next.value;
node.next = node.next.next;
return o;
}

/**
* 合并两个有序的单链表
* */
public static MyLinkList<Comparable> mergeLinkList(MyLinkList<Comparable> la,MyLinkList<Comparable> lb){
MyLinkList<Comparable> lc = new MyLinkList<Comparable>();
MyNode<Comparable> pc = lc.next;
MyNode<Comparable> pa = la.next.next;
MyNode<Comparable> pb = lb.next.next;
while(null != pa || null != pb){
if(null == pa){
pc.next = pb;
break;
}
if(null == pb){
pc.next = pa;
break;
}
if(pa.value.compareTo(pb.value) <= 0){
pc.next = pa;
pa = pa.next;
}
else {
pc.next = pb;
pb = pb.next;
}
pc = pc.next;
}
return lc;
}

@Override
public String toString() {
return list.toString();
}

public static void main(String[] args) {
MyLinkList<Comparable> list1 = new MyLinkList<Comparable>();
MyLinkList<Comparable> list2 = new MyLinkList<Comparable>();
LinkListAction lla = new LinkListAction(list1);
// lla.createFromHead(1,3,4,6,8,10);
lla.createFromTail(1,3,4,6,8,10);
LinkListAction llb = new LinkListAction(list2);
llb.createFromTail(2,5,7,9,11);
System.out.println(lla);
System.out.println(llb);
// System.out.println(lla.locate(7));
// System.out.println(lla.getLength());
//
// lla.insert(20, 6);
// System.out.println(lla);
// System.out.println(lla.delete(4));

System.out.println(LinkListAction.mergeLinkList(lla.list, llb.list));
System.out.println(lla);
System.out.println(llb);
}

}

我还写了一些其他的简单数据结构，感兴趣的话，你可以Hi我一下，呵呵。
圣诞快乐！

3. java 中什么是链表,链表结构有什么好处。

比如linkedlist,链表的好处是删除快，但是在增添的时候速度慢，普通arraylist，linklist,10w个以上数据的读写中就比较容易看出速度上的差别了。 arraylist是普通数组，在删除时要移位，数量级大的情况下速度非常慢。linkedlist在java实现中应为模拟链表结构，在添加操作时增加了很多运算次数，但是删除时不需要移位，只需要重新标记地址，所以删除比较快。

以上为例子，其实基于链表的集合还有不少，java方便的提供了很多api，其实数据结构都是一样的，无论是哪个语言实现。