數據結構鏈表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，其實數據結構都是一樣的，無論是哪個語言實現。