今天就跟大家聊聊有關java中線性表的存儲結構是什么，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。
Java數據結構學習筆記第一篇：
用程序后在那個的數據大致有四種基本的邏輯結構：
集合：數據元素之間只有"同屬于一個集合"的關系
線性結構：數據元素之間存在一個對一個的關系
樹形結構：數據元素之間存在一個對多個關系
圖形結構或網狀結構：數據元素之間存在多個對多個的關系
對于數據不同的邏輯結構，計算機在物理磁盤上通常有兩種屋里存儲結構
順序存儲結構
鏈式存儲結構
本篇博文主要講的是線性結構，而線性結構主要是線性表，非線性結構主要是樹和圖。
線性表的基本特征：
總存在唯一的第一個數據元素
總存在唯一的最后一個數據元素
除第一個數據元素外，集合中的每一個數據元素都只有一個前驅的數據元素
除最后一個數據元素外，集合中的每一個數據元素都只有一個后繼的數據元素
1.線性表的順序存儲結構：是指用一組地址連續的存儲單元一次存放線性表的元素。為了使用順序結構實現線性表，程序通常會采用數組來保存線性中的元素，是一種隨機存儲的數據結構，適合隨機訪問。java中ArrayList類是線性表的數組實現。
import java.util.Arrays;
public class SequenceList<T>
{
private int DEFAULT_SIZE = 16;
//保存數組的長度。
private int capacity;
//定義一個數組用于保存順序線性表的元素
private Object[] elementData;
//保存順序表中元素的當前個數
private int size = 0;
//以默認數組長度創建空順序線性表
public SequenceList()
{
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
}
//以一個初始化元素來創建順序線性表
public SequenceList(T element)
{
this();
elementData[0] = element;
size++;
}
/**
* 以指定長度的數組來創建順序線性表
* @param element 指定順序線性表中第一個元素
* @param initSize 指定順序線性表底層數組的長度
*/
public SequenceList(T element , int initSize)
{
capacity = 1;
//把capacity設為大于initSize的最小的2的n次方
while (capacity < initSize)
{
capacity <<= 1;
}
elementData = new Object[capacity];
elementData[0] = element;
size++;
}
//獲取順序線性表的大小
public int length()
{
return size;
}
//獲取順序線性表中索引為i處的元素
public T get(int i)
{
if (i < 0 || i > size - 1)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
return (T)elementData[i];
}
//查找順序線性表中指定元素的索引
public int locate(T element)
{
for (int i = 0 ; i < size ; i++)
{
if (elementData[i].equals(element))
{
return i;
}
}
return -1;
}
//向順序線性表的指定位置插入一個元素。
public void insert(T element , int index)
{
if (index < 0 || index > size)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
ensureCapacity(size + 1);
//將index處以后所有元素向后移動一格。
System.arraycopy(elementData , index , elementData
, index + 1 , size - index);
elementData[index] = element;
size++;
}
//在線性順序表的開始處添加一個元素。
public void add(T element)
{
insert(element , size);
}
//很麻煩，而且性能很差
private void ensureCapacity(int minCapacity)
{
//如果數組的原有長度小于目前所需的長度
if (minCapacity > capacity)
{
//不斷地將capacity * 2，直到capacity大于minCapacity為止
while (capacity < minCapacity)
{
capacity <<= 1;
}
elementData = Arrays.copyOf(elementData , capacity);
}
}
//刪除順序線性表中指定索引處的元素
public T delete(int index)
{
if (index < 0 || index > size - 1)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
T oldValue = (T)elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
{
System.arraycopy(elementData , index+1
, elementData, index , numMoved);
}
//清空最后一個元素
elementData[--size] = null;
return oldValue;
}
//刪除順序線性表中最后一個元素
public T remove()
{
return delete(size - 1);
}
//判斷順序線性表是否為空表
public boolean empty()
{
return size == 0;
}
//清空線性表
public void clear()
{
//將底層數組所有元素賦為null
Arrays.fill(elementData , null);
size = 0;
}
public String toString()
{
if (size == 0)
{
return "[]";
}
else
{
StringBuilder sb = new StringBuilder("[");
for (int i = 0 ; i < size ; i++ )
{
sb.append(elementData[i].toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2 , len).append("]").toString();
}
}
} 2.線性表鏈式存儲結構:將采用一組地址的任意的存儲單元存放線性表中的數據元素。
鏈表又可分為：
單鏈表：每個節點只保留一個引用，該引用指向當前節點的下一個節點，沒有引用指向頭結點，尾節點的next引用為null。
循環鏈表：一種首尾相連的鏈表。
雙向鏈表：每個節點有兩個引用，一個指向當前節點的上一個節點，另外一個指向當前節點的下一個節點。
下面給出線性表雙向鏈表的實現：java中LinkedList是線性表的鏈式實現，是一個雙向鏈表。
public class DuLinkList<T>
{
//定義一個內部類Node，Node實例代表鏈表的節點。
private class Node
{
//保存節點的數據
private T data;
//指向上個節點的引用
private Node prev;
//指向下個節點的引用
private Node next;
//無參數的構造器
public Node()
{
}
//初始化全部屬性的構造器
public Node(T data , Node prev , Node next)
{
this.data = data;
this.prev = prev;
this.next = next;
}
}
//保存該鏈表的頭節點
private Node header;
//保存該鏈表的尾節點
private Node tail;
//保存該鏈表中已包含的節點數
private int size;
//創建空鏈表
public DuLinkList()
{
//空鏈表，header和tail都是null
header = null;
tail = null;
}
//以指定數據元素來創建鏈表，該鏈表只有一個元素
public DuLinkList(T element)
{
header = new Node(element , null , null);
//只有一個節點，header、tail都指向該節點
tail = header;
size++;
}
//返回鏈表的長度
public int length()
{
return size;
}
//獲取鏈式線性表中索引為index處的元素
public T get(int index)
{
return getNodeByIndex(index).data;
}
//根據索引index獲取指定位置的節點
private Node getNodeByIndex(int index)
{
if (index < 0 || index > size - 1)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
if (index <= size / 2)
{
//從header節點開始
Node current = header;
for (int i = 0 ; i <= size / 2 && current != null
; i++ , current = current.next)
{
if (i == index)
{
return current;
}
}
}
else
{
//從tail節點開始搜索
Node current = tail;
for (int i = size - 1 ; i > size / 2 && current != null
; i++ , current = current.prev)
{
if (i == index)
{
return current;
}
}
}
return null;
}
//查找鏈式線性表中指定元素的索引
public int locate(T element)
{
//從頭節點開始搜索
Node current = header;
for (int i = 0 ; i < size && current != null
; i++ , current = current.next)
{
if (current.data.equals(element))
{
return i;
}
}
return -1;
}
//向線性鏈式表的指定位置插入一個元素。
public void insert(T element , int index)
{
if (index < 0 || index > size)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
//如果還是空鏈表
if (header == null)
{
add(element);
}
else
{
//當index為0時，也就是在鏈表頭處插入
if (index == 0)
{
addAtHeader(element);
}
else
{
//獲取插入點的前一個節點
Node prev = getNodeByIndex(index - 1);
//獲取插入點的節點
Node next = prev.next;
//讓新節點的next引用指向next節點，prev引用指向prev節點
Node newNode = new Node(element , prev , next);
//讓prev的next指向新節點。
prev.next = newNode;
//讓prev的下一個節點的prev指向新節點
next.prev = newNode;
size++;
}
}
}
//采用尾插法為鏈表添加新節點。
public void add(T element)
{
//如果該鏈表還是空鏈表
if (header == null)
{
header = new Node(element , null , null);
//只有一個節點，header、tail都指向該節點
tail = header;
}
else
{
//創建新節點,新節點的pre指向原tail節點
Node newNode = new Node(element , tail , null);
//讓尾節點的next指向新增的節點
tail.next = newNode;
//以新節點作為新的尾節點
tail = newNode;
}
size++;
}
//采用頭插法為鏈表添加新節點。
public void addAtHeader(T element)
{
//創建新節點，讓新節點的next指向原來的header
//并以新節點作為新的header
header = new Node(element , null , header);
//如果插入之前是空鏈表
if (tail == null)
{
tail = header;
}
size++;
}
//刪除鏈式線性表中指定索引處的元素
public T delete(int index)
{
if (index < 0 || index > size - 1)
{
throw new IndexOutOfBoundsException("線性表索引越界");
}
Node del = null;
//如果被刪除的是header節點
if (index == 0)
{
del = header;
header = header.next;
//釋放新的header節點的prev引用
header.prev = null;
}
else
{
//獲取刪除點的前一個節點
Node prev = getNodeByIndex(index - 1);
//獲取將要被刪除的節點
del = prev.next;
//讓被刪除節點的next指向被刪除節點的下一個節點。
prev.next = del.next;
//讓被刪除節點的下一個節點的prev指向prev節點。
if (del.next != null)
{
del.next.prev = prev;
}
//將被刪除節點的prev、next引用賦為null.
del.prev = null;
del.next = null;
}
size--;
return del.data;
}
//刪除鏈式線性表中最后一個元素
public T remove()
{
return delete(size - 1);
}
//判斷鏈式線性表是否為空鏈表
public boolean empty()
{
return size == 0;
}
//清空線性表
public void clear()
{
//將底層數組所有元素賦為null
header = null;
tail = null;
size = 0;
}
public String toString()
{
//鏈表為空鏈表時
if (empty())
{
return "[]";
}
else
{
StringBuilder sb = new StringBuilder("[");
for (Node current = header ; current != null
; current = current.next )
{
sb.append(current.data.toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2 , len).append("]").toString();
}
}
public String reverseToString()
{
//鏈表為空鏈表時
if (empty())
{
return "[]";
}
else
{
StringBuilder sb = new StringBuilder("[");
for (Node current = tail ; current != null
; current = current.prev )
{
sb.append(current.data.toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2 , len).append("]").toString();
}
}
}線性表的兩種實現比較
空間性能：
順序表：順序表的存儲空間是靜態分布的，需要一個長度固定的數組，因此總有部分數組元素被浪費。
鏈表：鏈表的存儲空間是動態分布的，因此不會空間浪費。但是由于鏈表需要而外的空間來為每個節點保存指針，因此要犧牲一部分空間。
時間性能：
順序表：順序表中元素的邏輯順序與物理存儲順序是保持一致的，而且支持隨機存取。因此順序表在查找、讀取時性能很好。
鏈表：鏈表采用鏈式結構來保存表內元素，因此在插入、刪除元素時性能要好
看完上述內容，你們對java中線性表的存儲結構是什么有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
