Java數據結構學習-線性結構

線性結構

           線性表是一種線性結構,它是具有相同類型的n(n≥0)個數據元素組成的有限序列;

           線性表的基本組成為:數組,單項鏈表,雙向鏈表;

數組 

    數組有上界和下界,數組的元素在上下界內是連續的;

    比如存儲一個整數的數組定義為:

    int[] arr = {10,20,30,40,50};

    數組的特點是:數據是連續的;隨機訪問速度快;

    數組中稍微復雜一點的是多維數組和動態數組.對於C語言而言,多維數組本質上也是通過一位數組實現的;

    至於動態數組,是指數組的容量能動態增長的數組;

    對於C語言而言,若要提供動態數組,需要手動實現;

    而對於C++而言,STL提供了Vector;

    對於Java而言,Collection集合中提供了ArrayList和Vector;

單向鏈表

    單向鏈表(單鏈表)是鏈表的一種,它由節點組成,每個節點都包含下一個節點的指針;

            單鏈表的示意圖如下:         

 

 

表頭為空,表頭的后繼節點是"節點10"(數據為10的節點),"節點10"的后繼節點是"節點20"(數據為20的節點),...

單鏈表刪除節點

 

刪除"節點30"

刪除之前:"節點20"的后繼節點為"節點30",而"節點30"的后繼節點為"節點40";

刪除之后:"節點20"的后繼節點為"節點40";

單鏈表添加節點

在"節點10"與"節點20"之間添加"節點15";

添加之前:"節點10"的后繼節點為"節點20";

添加之后:"節點10"的后繼節點為"節點15"，而"節點15"的后繼節點為"及誒單20";

雙向鏈表       

雙向鏈表(雙鏈表)時候鏈表的一種;和單鏈表一樣,雙鏈表也是由節點組成的,它的每個數據節點中都有倆個指針,分別指向直接后繼和直接前驅;所以,從雙向鏈表中的任意一個節點開始,都可以很方便的訪問它的前驅節點和后繼節點;一般我們都夠着雙向循環鏈表;

 

雙鏈表的示意圖如下:

表頭為空,表頭的后繼節點為"節點10"(數據為10的節點);

"節點10"的后繼節點是"節點20"(數據為10的節點),"節點20"的前驅節點是"節點10";

"節點20"的后繼節點是"節點30","節點30"的前驅節點是"節點20";...;

末尾節點的后繼節點是表頭;

雙鏈表刪除節點

刪除"節點30"

刪除之前:"節點20"的后繼節點為"節點30","節點30"的前驅節點為"節點20";

"節點30"的后繼節點為"節點40","節點40"的前驅節點為"節點30";

刪除之后:"節點20"的后繼節點為"節點40","節點40"的前驅節點為"節點20";

雙鏈表添加節點

在"節點10"與"及誒單20"之間添加"節點15";

添加之前:"節點10"的后繼節點為"節點20","節點20"的前驅節點為"節點10";

添加之后:"節點10"的后繼節點為"節點15","節點15"的前驅節點為"節點10";

"節點15"的后繼節點為"節點20","節點20"的前驅節點為"節點15";

 

下面演示一下雙鏈表的實現,只介紹Java語言的三種實現

雙鏈表類(DoubleLink.java)

/**
 * Java 實現的雙向鏈表。 
 * 注：java自帶的集合包中有實現雙向鏈表，路徑是:java.util.LinkedList
 *
 */
public class DoubleLink<T> {

    // 表頭
    private DNode<T> mHead;
    // 節點個數
    private int mCount;

    // 雙向鏈表“節點”對應的結構體
    private class DNode<T> {
        public DNode prev;
        public DNode next;
        public T value;

        public DNode(T value, DNode prev, DNode next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
    }

    // 構造函數
    public DoubleLink() {
        // 創建“表頭”。注意：表頭沒有存儲數據！
        mHead = new DNode<T>(null, null, null);
        mHead.prev = mHead.next = mHead;
        // 初始化“節點個數”為0
        mCount = 0;
    }

    // 返回節點數目
    public int size() {
        return mCount;
    }

    // 返回鏈表是否為空
    public boolean isEmpty() {
        return mCount==0;
    }

    // 獲取第index位置的節點
    private DNode<T> getNode(int index) {
        if (index<0 || index>=mCount)
            throw new IndexOutOfBoundsException();

        // 正向查找
        if (index <= mCount/2) {
            DNode<T> node = mHead.next;
            for (int i=0; i<index; i++)
                node = node.next;

            return node;
        }

        // 反向查找
        DNode<T> rnode = mHead.prev;
        int rindex = mCount - index -1;
        for (int j=0; j<rindex; j++)
            rnode = rnode.prev;

        return rnode;
    }

    // 獲取第index位置的節點的值
    public T get(int index) {
        return getNode(index).value;
    }

    // 獲取第1個節點的值
    public T getFirst() {
        return getNode(0).value;
    }

    // 獲取最后一個節點的值
    public T getLast() {
        return getNode(mCount-1).value;
    }

    // 將節點插入到第index位置之前
    public void insert(int index, T t) {
        if (index==0) {
            DNode<T> node = new DNode<T>(t, mHead, mHead.next);
            mHead.next.prev = node;
            mHead.next = node;
            mCount++;
            return ;
        }

        DNode<T> inode = getNode(index);
        DNode<T> tnode = new DNode<T>(t, inode.prev, inode);
        inode.prev.next = tnode;
        inode.next = tnode;
        mCount++;
        return ;
    }

    // 將節點插入第一個節點處。
    public void insertFirst(T t) {
        insert(0, t);
    }

    // 將節點追加到鏈表的末尾
    public void appendLast(T t) {
        DNode<T> node = new DNode<T>(t, mHead.prev, mHead);
        mHead.prev.next = node;
        mHead.prev = node;
        mCount++;
    }

    // 刪除index位置的節點
    public void del(int index) {
        DNode<T> inode = getNode(index);
        inode.prev.next = inode.next;
        inode.next.prev = inode.prev;
        inode = null;
        mCount--;
    }

    // 刪除第一個節點
    public void deleteFirst() {
        del(0);
    }

    // 刪除最后一個節點
    public void deleteLast() {
        del(mCount-1);
    }
}

 

測試程序(DlinkTest.java)

/**
 * Java 實現的雙向鏈表。 
 * 注：java自帶的集合包中有實現雙向鏈表，路徑是:java.util.LinkedList
 *
 */

public class DlinkTest {

    // 雙向鏈表操作int數據
    private static void int_test() {
        int[] iarr = {10, 20, 30, 40};

        System.out.println("\n----int_test----");
        // 創建雙向鏈表
        DoubleLink<Integer> dlink = new DoubleLink<Integer>();

        dlink.insert(0, 20);    // 將 20 插入到第一個位置
        dlink.appendLast(10);    // 將 10 追加到鏈表末尾
        dlink.insertFirst(30);    // 將 30 插入到第一個位置

        // 雙向鏈表是否為空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 雙向鏈表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的節點
        for (int i=0; i<dlink.size(); i++)
            System.out.println("dlink("+i+")="+ dlink.get(i));
    }


    private static void string_test() {
        String[] sarr = {"ten", "twenty", "thirty", "forty"};

        System.out.println("\n----string_test----");
        // 創建雙向鏈表
        DoubleLink<String> dlink = new DoubleLink<String>();

        dlink.insert(0, sarr[1]);    // 將 sarr中第2個元素 插入到第一個位置
        dlink.appendLast(sarr[0]);    // 將 sarr中第1個元素 追加到鏈表末尾
        dlink.insertFirst(sarr[2]);    // 將 sarr中第3個元素 插入到第一個位置

        // 雙向鏈表是否為空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 雙向鏈表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的節點
        for (int i=0; i<dlink.size(); i++)
            System.out.println("dlink("+i+")="+ dlink.get(i));
    }


    // 內部類
    private static class Student {
        private int id;
        private String name;

        public Student(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "["+id+", "+name+"]";
        }
    }

    private static Student[] students = new Student[]{
        new Student(10, "sky"),
        new Student(20, "jody"),
        new Student(30, "vic"),
        new Student(40, "dan"),
    };

    private static void object_test() {
        System.out.println("\n----object_test----");
        // 創建雙向鏈表
        DoubleLink<Student> dlink = new DoubleLink<Student>();

        dlink.insert(0, students[1]);    // 將 students中第2個元素 插入到第一個位置
        dlink.appendLast(students[0]);    // 將 students中第1個元素 追加到鏈表末尾
        dlink.insertFirst(students[2]);    // 將 students中第3個元素 插入到第一個位置

        // 雙向鏈表是否為空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 雙向鏈表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的節點
        for (int i=0; i<dlink.size(); i++) {
            System.out.println("dlink("+i+")="+ dlink.get(i));
        }
    }

 
    public static void main(String[] args) {
        int_test();        // 演示向雙向鏈表操作“int數據”。
        string_test();    // 演示向雙向鏈表操作“字符串數據”。
        object_test();    // 演示向雙向鏈表操作“對象”。
    }
}

 

運行結果

----int_test----
isEmpty()=false
size()=3
dlink(0)=30
dlink(1)=20
dlink(2)=10

----string_test----
isEmpty()=false
size()=3
dlink(0)=thirty
dlink(1)=twenty
dlink(2)=ten

----object_test----
isEmpty()=false
size()=3
dlink(0)=[30, vic]
dlink(1)=[20, jody]
dlink(2)=[10, sky]

 轉載自:http://www.cnblogs.com/skywang12345/p/3561803.html