線性表結構的Java實現

一、線性表的抽象數據類型表述

線性表的結構簡單，長度允許動態增長或搜索；可以對線性表中的任何數據元素進行訪問和查找；允許進行數據的插入和刪除操作；求線性表中的指定數據的前驅和后繼；合並線性表以及拆分線性表中。

Java JDK中有ArrayList和LinkedList兩個類很好的實現了順序存儲和鏈式存儲。因此學習數據結構的最好方式是去研究JDK源碼。

這里的代碼個人作為練習，為了便於理解，很多地方處理的並非十分嚴謹，僅供參考。轉載注明出處，技術討論 email： <[e-mail]>

 

package org.yohhan.data_structure.api;

/**
 * @author yohhan <[e-mail]>
 * @date create：2016年1月10日 下午4:05:35
 *
 *       線性表的抽象數據類型
 * 
 */
public interface MyList {
    public void clear();

    public boolean isEmpty();

    public int length();

    public Object get(int i) throws Exception;

    public void insert(int i, Object obj) throws Exception;

    public void remove(int i) throws Exception;

    public int indexOf(Object obj);

    public void display();
}

 

 

 

 

 

二、線性表的順序存儲實現

1.順序表的定義：

順序存儲采用一組地址連續的存儲單元依次存儲線性表占用的各個數據元素的存儲結構。

2.順序表的特點：

1）邏輯上相鄰的數據元素，在物理存儲位置上也是相鄰的。

2）存儲密度高，事先需要分配足夠應用的存儲空間。

3）隨機存取，查詢速度快，直接訪問地址單元中的數據。時間復雜度 O(1)

4）插入刪除操作會引起大量的數據移動，時間復雜度O(n)

3.順序表的結構類描述：

package org.yohhan.data_structure.linear;

import org.yohhan.data_structure.api.MyList;

/**
 * @author yohhan <[e-mail]>
 * @date create：2016年1月10日 下午4:09:15
 * 
 *       線性表的順序存儲實現
 */
public class SqList implements MyList {

    private Object[] listElem; // 數組作為線性表的存儲空間
    private int curLen; // 線性表的當前長度

    public SqList(int maxSize) {
        curLen = 0;
        listElem = new Object[maxSize];
    }

    @Override
    public void clear() {
        curLen = 0;
    }

    @Override
    public boolean isEmpty() {
        return curLen == 0;
    }

    @Override
    public int length() {
        return curLen;
    }

    @Override
    public Object get(int i) throws Exception {
        if (i < 0 || i > curLen - 1)
            throw new Exception("元素不存在");
        return listElem[i];
    }

    @Override
    public void insert(int i, Object obj) throws Exception {
        if (curLen == listElem.length)
            throw new Exception("存儲空間已滿");
        if (i < 0 || i > curLen)
            throw new Exception("插入位置不合法");
        for (int j = curLen; j > i; j--)
            listElem[j] = listElem[j - 1];
        listElem[i] = obj;
        ++curLen;
    }

    @Override
    public void remove(int i) throws Exception {
        if (i < 0 || i > curLen - 1)
            throw new Exception("刪除位置不合法");
        for (int j = i; j < curLen; j++)
            listElem[j] = listElem[j + 1];
        --curLen;
    }

    @Override
    public int indexOf(Object obj) {
        int j = 0;
        while (j < curLen && !listElem[j].equals(obj))
            j++;
        if (j < curLen)
            return j;
        return -1;
    }

    @Override
    public void display() {
        for (int j = 0; j < curLen; j++)
            System.out.print(listElem[j] + ", ");
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (Object obj : listElem) {
            if (null != obj)
                sb.append(obj.toString() + ", ");
        }
        sb.delete(sb.length() - 2, sb.length());
        sb.append("]");
        return sb.toString();
    }

}

 

三、線性表的鏈式存儲實現

1.單鏈表的定義：

采用鏈式存儲方式存儲的線性表，鏈表中每一個結點中包含存放數據元素值的數據域和存放邏輯上相鄰結點的指針域。(示例中的結點只包含一個指針域，稱為單鏈表(Single Linked List))

（圖片摘自網上）

單鏈表通過指向后繼結點的指針將結點串聯成一條鏈。

以線性表中的第一個數據元素的存儲地址作為線性表的起始地址，稱為線性表的頭指針。通過頭指針(head)來唯一標識一個鏈表。

單鏈表中的最后一個節點沒有后繼，指針域為空指針(null),稱為尾結點。

示例中采用一個“虛頭結點”數據域不存放具體值，指針域中的指針指向單鏈表的第一個結點(首結點)。即當頭結點中的指針域為空時，鏈表為空

 

 

 

 

2.鏈式存儲的特點：

1)不需要預先分配存儲空間，動態分配存儲空間，存儲密度較低、

2) 無法隨機查詢，需要從頭遍歷來查找元素。時間復雜度O(n)

3)便於進行數據的插入和刪除。時間復雜度O(1)

 

3.線性表的單鏈表實現：

結點類結構：

package org.yohhan.data_structure.node;

/**
 * @author yohhan <[e-mail]>
 * @date create：2016年1月10日 下午4:39:15
 * 
 *       鏈表的結點類描述
 * 
 */
public class Node {

    private Object data;
    private Node next;

    public Node() {
        this(null, null);
    }

    public Node(Object data) {
        this(data, null);
    }

    public Node(Object data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

}

 

單鏈表類的描述：

package org.yohhan.data_structure.linear;

import org.yohhan.data_structure.api.MyList;
import org.yohhan.data_structure.node.Node;

/**
 * @author yohhan <[e-mail]>
 * @date create：2016年1月10日 下午4:51:58
 * 
 *       帶頭結點的單鏈表實現
 * 
 */
public class LinkList implements MyList {

    private Node head;

    public LinkList() {
        head = new Node();
    }

    public LinkList(int n, boolean order) throws Exception {
        this();
        if (order)
            createFromTail(n);
        else
            createFromHead(n);
    }

    private void createFromTail(int n) throws Exception {
        // 可在此添加輸入流，傳入數據

        for (int j = 0; j < n; j++)
            insert(length(), j + 1);
    }

    private void createFromHead(int n) throws Exception {
        // 可在此添加輸入流，傳入數據

        for (int j = 0; j < n; j++)
            insert(0, j + 1);
    }

    @Override
    public void clear() {
        head.setData(null);
        head.setNext(null);
    }

    @Override
    public boolean isEmpty() {
        return head.getNext() == null;
    }

    @Override
    public int length() {
        Node node = head.getNext();
        int length = 0;
        while (node != null) {
            node = node.getNext();
            ++length;
        }
        return length;
    }

    /**
     * 按位序號查找算法
     */
    @Override
    public Object get(int i) throws Exception {
        Node node = head.getNext();
        int j = 0;
        while (node != null && j < i) {
            node = node.getNext();
            ++j;
        }
        if (j > i || node == null)
            throw new Exception("元素不存在");
        return node.getData();
    }

    /**
     * 在index前插入新結點
     */
    @Override
    public void insert(int i, Object obj) throws Exception {
        Node node = head;
        int j = -1;
        while (node != null && j < i - 1) {
            node = node.getNext();
            ++j;
        }
        if (j > i - 1 || node == null)
            throw new Exception("插入位置不合法");
        Node newNode = new Node(obj);
        newNode.setNext(node.getNext());
        node.setNext(newNode);
    }

    @Override
    public void remove(int i) throws Exception {
        Node node = head;
        int j = -1;
        while (node.getNext() != null && j < i - 1) { // 鏈表不能為空
            node = node.getNext();
            ++j;
        }
        if (j > i - 1 || node == null)
            throw new Exception("刪除位置不合法");
        node.setNext(node.getNext().getNext());
    }

    /**
     * 按值查找算法
     */
    @Override
    public int indexOf(Object obj) {
        Node node = head.getNext();
        int j = 0;
        while (node != null && !node.getData().equals(obj)) {
            node = node.getNext();
            ++j;
        }
        if (node != null)
            return j;
        return -1;
    }

    @Override
    public void display() {
        Node node = head.getNext();
        while (node != null) {
            System.out.print(node.getData() + "");
            node = node.getNext();
        }
        System.out.println();
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        Node node = head.getNext();
        while (node != null) {
            sb.append(node.getData().toString() + ", ");
            node = node.getNext();
        }
        sb.delete(sb.length() - 2, sb.length());
        sb.append("]");
        return sb.toString();
    }

}

 

 

附：線性表的單元測試類：

package org.yohhan.data_structure.test;

import static org.junit.Assert.*;
import org.junit.Test;
import org.yohhan.data_structure.linear.LinkList;
import org.yohhan.data_structure.linear.SqList;

/**
 * @author yohhan <[e-mail]>
 * @date create：2016年1月10日 下午4:25:12
 * 
 *       線性表單元測試類
 *
 */
public class LinearTest {

    @Test
    public void sqListTest() throws Exception {
        SqList sqList = new SqList(10);
        for (int i = 0; i < 5; i++)
            sqList.insert(i, i + 1);
        System.out.println(sqList);
        assertTrue(sqList.toString().equals("[1, 2, 3, 4, 5]"));
        assertTrue(sqList.length() == 5);
        assertTrue(sqList.indexOf(2) == 1);
        assertTrue(sqList.get(0).equals(1));
        sqList.remove(1);
        assertTrue(sqList.length() == 4);
        assertTrue(sqList.indexOf(1) == 0);
    }

    @Test
    public void linkListTest() throws Exception {
        LinkList linkList = new LinkList(5, true);
        System.out.println(linkList);
        assertTrue(new LinkList(5, false).toString().equals("[5, 4, 3, 2, 1]"));
        assertTrue(linkList.toString().equals("[1, 2, 3, 4, 5]"));
        assertTrue(linkList.length() == 5);
        assertTrue(linkList.indexOf(2) == 1);
        assertTrue(linkList.get(0).equals(1));
        linkList.remove(1);
        assertTrue(linkList.length() == 4);
        assertTrue(linkList.indexOf(1) == 0);

    }

}