2. 程式人生 > >詳解陣列，連結串列和ADT

詳解陣列，連結串列和ADT

阿新 • • 發佈：2019-02-19

陣列

先由一個例子複習一下陣列的操作：

class  HighArray
{
    private long[] a;
    private  int nElems;
    //-----------------------------------
    public HighArray(int max)   //建構函式
    {
        a=new long[max];
        nElems = 0;
    }
    //-----------------------------------
    public boolean find(long searchKey)   //查詢元素
    {
        int
 
 j；
        for(j=0;j<nElems;j++)
            if(a[j]==searcheKey)
                break;   //退出for迴圈，記錄了j的值
        if(j==nElems)   
                return false;   //沒找到
            else
                return true;   //找到了
    }
    //--------------------------------------
    public void insert(long value
 
)   //插入元素
    {
        a[nElems]=value;
        nElems++;
    } 
    //--------------------------------------
    public boolean delete(long value)   //刪除元素
    {
        int j;
        for(j=0;j<nElems;j++)
            if(value=a[j])
                break;
        if(j=nElems)
             return false
 
;   //不存在那個元素
        else
        {
            for(int k=j;k<nElesm;k++)
                a[k]=a[k+1];   //遍歷，從查詢的那個位置起，把陣列中的元素向前挪動一位
            nElems--;   //總長度減一
            return true;
        }
    }   //end  delete()
    //----------------------------------------
    public void display()
    {
        for(int j=0;j<nElems;j++)
            System.out.println(a[j]+" ");
        System.out.rpintln("");
    }
}

接著在客戶端始測試 陣列的 增 刪 查 操作

class  HighArrayApp
{
    public static void main(String[] args)
    {
        int maxSize=100;
        HighArray arr;
        arr= new HightArray(maxSize);

        arr.insert(57);
        arr.insert(27);
        arr.insert(17);
        arr.insert(67);
        arr.insert(87);
        arr.insert(33);
        arr.insert(22);
        arr.insert(11);
        arr.insert(66);
        arr.insert(66);

        int searchKey=35;
        if(arr.find(searchKey))
            System.out.println("Found"+searchKey);
        else
            System.out.println("Can't found"+searchKey);

        arr.delete(55); 
        arr.delete(66);

        arr.display();

    }
}

上例演示了一個數組增刪查的過程，它的特點是高度的抽象，操作“增刪改”都被封裝到 HightArray類中，並且暴露出介面（insert()，delete()，display()）供使用者使用，這裡的使用者就是HightArrayApp，它只需呼叫方法完成操。

接著複習一下陣列的二分查詢

二分查詢適用於有序陣列，關於排序我在上一節博文有寫，那麼今天在這裡預設陣列有序的情況學習一下二分查詢把

class  OrdArray
{
    private long[] a;
    private  int nElems;
    //-----------------------------------
    public HighArray(int max)
    {
        a=new long[max];
        nElems = 0;
    }
    //-----------------------------------
    public int size()
    {
        return nElems
    }
    //-----------------------------------
    public int find(long searchKey)   //查詢元素
    {
        int lowerBound=0;
        int upperBound=nElems-1;
        int curIn;

        while(true)
        {
            curIn=(lowerBound+upperBound)/2;
            if(a[curIn]==searchKey)
                return curIn;
            else if(lowerBound>upperBound)
                return nElems;
            else
            {
                if(a[curIn]<searchKey)
                    lowerBound=curIn+1;
                else
                    upperBound=curIn-1;
            }
        }
    }
    //--------------------------------------
    public void insert(long value)   //插入元素
    {
        int j;
        for(j=0;j<nElmes;j++)
            if(a[j]>value);
                break;
        for(int k=nElems;k>j;k--)
            a[k]=a[k-1];
        a[j]=value;
    nElems++;
    } 
    //--------------------------------------
    public boolean delete(long value)   //刪除元素
    {
        int j;
        for(j=0;j<nElems;j++)
            if(value=a[j])
                break;
        if(j=nElems)
             return false;   //不存在那個元素
        else
        {
            for(int k=j;k<nElesm;k++)
                a[k]=a[k+1];   //遍歷，從查詢的那個位置起，把陣列中的元素向前挪動一位
            nElems--;   //總長度減一
            return true;
        }
    }   //end  delete()
    //----------------------------------------
    public void display()
    {
        for(int j=0;j<nElems;j++)
            System.out.println(a[j]+" ");
        System.out.rpintln("");
    }
}

接著在客戶端測試 陣列的 增 刪 查 操作

class  HighArrayApp
{
    public static void main(String[] args)
    {
        int maxSize=100;
        HighArray arr;
        arr= new HightArray(maxSize);

        arr.insert(57);
        arr.insert(27);
        arr.insert(17);
        arr.insert(67);
        arr.insert(87);
        arr.insert(33);
        arr.insert(22);
        arr.insert(11);
        arr.insert(66);
        arr.insert(66);

        int searchKey=35;
        if(arr.find(searchKey)!=arr.size())
            System.out.println("Found"+searchKey);
        else
            System.out.println("Can't found"+searchKey);
        arr.display();

        arr.delete(55); 
        arr.delete(66);

        arr.display();

    }
}

陣列的問題

  1. 在一個無序陣列中插入只需要O(1)的時間，查詢卻需要O(N)
  2. 在一個有序陣列中查詢只需要O(logN),但插入卻需要O(N)
  3. 不論是有序還是無序，刪除操作，都需要花費O(N)
  4. 一旦陣列被建立，大小就被固定住，陣列初始化的大小不容易控制

連結串列

既然陣列作為資料儲存結構有一定的缺陷，那麼接下來將介紹一種新的資料儲存結構：連結串列。

鏈結點

在連結串列中，每個資料項都obeisance包含在鏈結點Link中。一個鏈結點是某個類的物件，這個類就叫做Link，因為一個連結串列中有許多類似的鏈結點，所以需要使用不同於連結串列的類來表達鏈結點。

每個Link物件都包含對下一個鏈結點引用的欄位，通常叫做next。

但是連結串列物件包含有對第一個鏈結點的引用。

這裡寫圖片描述

關係而非位置

陣列是根據下標號直接訪問，在連結串列中，尋找一個特定元素的唯一方法就是沿著這個元素鏈從頭開始一直向下尋找。從第一項開始，刀第二個，然後到第三個。

單鏈表

這個連結串列僅有的操作是：

  1. 在連結串列頭插入一個數據線
  2. 在連結串列頭刪除一個數據線
  3. 遍歷連結串列顯示它的內容

下面我們來看一下程式碼描述：

Link類 是鏈結點的抽象描述

class Link   
{

    public int iData;//假設Link中的資料是int和double，實際有可能是Object物件
    public double dData;
    public Link next;   //這裡看上去很突兀，但實際是一個鏈結點的引用，不是"Link中包含了一個Link"
    //------------------------------
    public Link(int id,double dd)
    {
        iData=id;
        dData=dd;
    }
    //-------------------------------
    public void display()
    {
        System.out.print("{"+iData+","+dData+"}");
    }
}   //end class Link

LinkList是連結串列的抽象

class LinkList
{
    private Link first;   //頭結點的引用
    //-------------------------------
    public LinkList()
    {
        first=null;
    }
    //-------------------------------
    public void insertFirst(int id,double dd)
    {
        //插入新結點的過程：
        //first已經指向了連結串列的第一個結點，插入新的結點：
        //1.建立的newLink結點的next等於first；
        //2.然後改變first的值，使得first指向新建立的鏈結點
        Link newLink =new Link(id,dd);
        newLink.next=first;
        first=newLink;
    }
    //-------------------------------
    public Link deletefirst()
    {
        //通過把first重新指向第二個鏈結點，刪除和第一個鏈結點的連結，記住first是連結串列的屬性，next是鏈結點的屬性
        Link temp=first;
        first=first.next;   //如何刪除：first-->old next
        return temp;   //返回刪除的鏈結點Link
    }
    //---------------------------------
    public Lind find（int key）  //查詢某個元素
    {
        Link current =first;
        while(current.iData!=key)
        {
            if(current.next==null)
                return null;
            else
                current =current.next;
        }
        return current;
    }
    //--------------------------------
    public Link delete(int key)   //刪除某個元素
    {
        Link current =frist;
        Link previous=first;
        while(current.iData!=key)
        {
            if(current.next==null)
              return null;
             else
             {
                previous=current;
                current=current.next;
             }
        }
        if(current==first)
             first=first.next;
         else
             previous.next=current.next;
         return current;
    }
    //---------------------------------
    public void displayList()   //輸出
    {
        System.out.print("List(first-->last): ");
        Link current=first;
        while(current!=null)
        {
            current.displayLink();
            current=current.next;
        }
        System.out.println(" ");
    }
}   //end class LinkList

LinkListApp是測試連結串列和鏈結點的客戶端

class LinkListApp
{
    public static void  main(String[] args)
    {
        LinkList theList=new LinkList();//建立新的連結串列
        theList.insertFirst(22,2.33);
        theList.insertFirst(44,4.33);
        theList.insertFirst(55,3.33);
        theList.insertFirst(88,34.33);

        theList.displayList();

        Link f=theList.find(44);
        if(f!=null)
            System.out.println（"Found Link with key "+f.iData）;
        else
            Systemm.out.println("Can't find link");


        Link d=theList.delete(88);

        theList.displayList();

        while(!theList.isEmpety())
        {
            Link aLink=theList.deleteFirst();
            System.out.print("Deleted");
            aLink.displayLink();
            System.out.println(" ");
        } 

        theList.displayList();
    }   //end main()
}

雙端連結串列

雙端連結串列與單鏈表的唯一區別是，增加了對最後一個鏈結點的引用。

這樣就允許在表尾插入一個鏈結點。
當然我們也可以遍歷整個連結串列直到表尾再插入。顯然雙端連結串列這樣在末尾插入鏈結點效率更高。

有序連結串列


有序連結串列優於有序陣列的地方就是插入的速度，因為連結串列的插入是不需要移動元素的，連結串列也可以擴充套件記憶體，陣列的記憶體是固定的。

有序連結串列的缺點就是實現起來稍微複雜。

雙向連結串列


雙向連結串列的優點 就是反向遍歷非常簡單。

為什麼？

因為雙向連結串列的每個鏈結點都有兩個屬性，分別指向前一個結點和指向後一個結點。

關於有序連結串列和雙向連結串列的程式碼敘述有興趣的可以自行查閱

連結串列的效率

在表頭插入和刪除速度很快，花費O(1);
查詢，刪除和在指定鏈結點後面插入都需要搜尋表中一半以上的鏈結點，需要O(N)次比較，雖然陣列執行這些操作演示O(N)次比較，但是連結串列仍然要快一些，因為插入刪除鏈結點時，連結串列不需要移動，增加的效率是顯著的，特別是複製實際遠遠大於比較實際的時候。

連結串列比陣列的優越性還體現在：連結串列需要多少記憶體就可以用多少記憶體，並且可以擴充套件。

陣列太大導致效率低下，陣列太小，使用的時候有可能空指標；向量是可擴充套件的陣列，它改變長度的方式是增量擴充套件，擴大一倍。記憶體效率上比連結串列低的多，

ADT 抽象資料型別

接下來討論一個比連結串列更廣泛的話題：抽象資料型別

簡單來說，是一種考慮資料結構的方式：著重於它做了什麼，而忽略它 是怎麼做的。

棧和佇列都是ADT的例子，陣列和連結串列都可以實現它們。

用連結串列實現棧
棧的push()和pop()操作實際是通過陣列操作完成的
arr[++top]=data;
data=arr[top- -];

而連結串列是類似於這樣完成：
theList.insertFist(data);
data=theList.deleteFirst();


棧的使用者呼叫push()和pop()方法來插入和刪除棧中的元素，它們不需要知道棧是用連結串列還是陣列實現的

class Link 
{
    public long dData;
    public Link next;
    //--------------------------
    public Link(long dd)
    {
        dData=dd;
    }
    //--------------------------
    public void displayLink(){
        System.out.print(dData+" ");
    }
}   //end class Link
class LinkList{
    private Link first;   //頭結點的引用
    //--------------------------------------
    public LinkList（）
    {
        first=null;
    }
    //--------------------------------------
    public boolean isEmpty()
    {
        return fisrt==null;
    }
    //-------------------------------------
    public void insertFirst(long dd)
    {
        Link newLink=new Link(dd);
        newLink.next=first;
        first=newLink;
    }
    //--------------------------------------
    pubic long deleteFirst()
    {
        Link temp=first;
        first=first.next;
        return temp.dData;
    }
    //-------------------------------------
    public voi displayList()
    {
        Link current =first;
        while(current!=null)
        {
            current.displayLink();
            current=current.next;
        }
        System.out.println("");
    }
}   //end class
class Stack
{
    private LinkList theList;
    //------------------------------
    public Stack()
    {
        theList=new LinkList();
    }
    //------------------------------
    public void push(long i)
    {
        theList.insertFirst(j);
    }
    //------------------------------
    public void pop()
    {
        return theList.deleteFirst();
    }
    //------------------------------
    public boolean isEmpty()
    {
        return theList.isEmpty();
    }
    //-------------------------------
    public void displayStack()
    {
        System.out.print("Stack(top-->bottom):");
        theList.displayList();
    }
}   //end class
class LinkStackApp
{

    public static void main(String[] args)
    {
        LinkStack theStack=new LinkStack();
        theStack.push(20);
        theStack.push(40);

        theStack.displayStack();

        theStack.push(60);
        theStack.push(80);

        theStack.displayStack();

        theStack.pop();
        theStack.pop();

        theStack.displayStack();
    }   //end  main()
}   //end class

觀察：整個程式，LinkStackApp中的main方法只和LinkStack類有關，LinkStack類只和LinkList類有關。main（）和LinkList類是不能通訊的。

資料型別和抽象

抽象資料型別分為兩步，首先看看“資料型別”再考慮“抽象”


資料型別可以表示內建的型別，比如int，double，也可以用類來建立自己的資料型別。


抽象這個詞的意思是“不考慮細節的描述和實現”，抽象是事物的本質和重要特徵。

當“抽象資料型別”用於描述棧和佇列這樣的資料額結構時，它的意義被進一步擴充套件了。它意味著類的使用者不知道方法是怎樣運作的，也不知道資料是如何儲存的。

對於棧來說，使用者只知道push()和pop()方法的存在是被使用者使用的，但不需要知道內部的實現，以及內部資料是如何儲存。

介面，在ADT中有一個經常被稱為“介面”的規範，同城是類的公有方法，在棧中，push() 和pop()就形成了介面。

相關推薦

詳解陣列，連結串列和ADT

陣列 先由一個例子複習一下陣列的操作： class HighArray { private long[] a; private int nElems; //-------

陣列、連結串列和樹的演進

我們最常用的資料結構就是樹，最基礎的資料結構是陣列，那麼樹在陣列的基礎上解決了什麼問題？為什麼用樹而不用陣列？下面我們來詳細的剖析一下： 上面的圖是陣列、連結串列和樹的示意圖，可以看到，陣列中的元素沒有指標，單向連結串列有一個指標，雙向連結串列有兩個指標，它們都是表示的順序關係，也就是

劍指offer系列——表示數值的字串，字元流中第一個不重複的陣列，連結串列中環的入口結點

表示數值的字串 題目描述 請實現一個函式用來判斷字串是否表示數值（包括整數和小數）。例如，字串"+100","5e2","-123","3.1416"和"-1E-16"都表示數值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。 解題思路：

常見的資料結構（棧、佇列、陣列、連結串列和紅黑樹）

（一）棧 棧：stack,又稱堆疊，它是運算受限的線性表，其限制是僅允許在標的一端進行插入和刪除操作，不允許在其 他任何位置進行新增、查詢、刪除等操作。 簡單的說：採用該結構的集合，對元素的存取有如下的特點先進後出（即，存進去的元素，要在後它後面的元素依次取出後，才能取出該元素）。例如，子彈

陣列、連結串列和二叉樹的應用場景

很明顯，題主沒有學的比較好。 或者沒參加過acm的相關訓練。只是一個平時跟著學做些課後題然後混畢業的。 二叉樹，本質上，是對連結串列和陣列的一個折中。。 比如，我有一個任務，需要輸入 10萬個資料（32位整數），然後有兩個操作： 1.新增(刪除)一個整數。 2.詢問第x大的資料。 比如，我給你 1, 8,

python中字典dic詳解-建立，遍歷和排序

在python的程式設計中，字典dic是最典型的資料結構，看看如下對字典的操作： 建立字典 直接使用 {} 建立空字典： book_price = {} 直接初始化的方式建立字典： book_price = {'a':23,'b':30}

C++中陣列、連結串列和vector等容器之間的區別

1. 各個容器之間區別 ① vector 　　（連續的空間儲存,可以使用[]操作符）快速的訪問隨機的元素，快速的在末尾插入元素，但是在序列中間歲間的插入，刪除元素要慢，而且如果一開始分配的空

陣列、連結串列和雜湊表

陣列和連結串列的區別： 1、陣列是將元素在記憶體中連續存放。 連結串列中的元素在記憶體中不是順序儲存的，而是通過存在元素中的指標聯絡到一起。 2、陣列必須事先定義固定的長度，不能適應資料動態地增減的情況。 連結串列動態地進行儲存分配

詳解SkipList跳躍連結串列【含程式碼】

本文始發於個人公眾號：TechFlow，原創不易，求個關注 今天繼續介紹分散式系統當中常用的資料結構，今天要介紹的資料結構非常了不起，和之前介紹的布隆過濾器一樣，是一個功能強大原理簡單的資料結構。並且它的缺點和短板更少，應用更加廣泛，比如廣泛使用的Redis就有用到它。 SkipList簡介 SkipL

陣列的特點，陣列的使用，連結串列的特點，set和list的區別，arrayList，linkedList，的常用方法，set，hashset，

陣列的特點： 陣列的長度一旦定義則不能改變 陣列中的元素都有整數索引 陣列只能儲存同一型別的元素 陣列即可以儲存基本資料型別，又可以儲存引用資料型別 陣列的使用： 獲取元素。通過索引獲取，arr[2]; 新增元素（在元素3後面新增一個新元素8）：要先建立新的陣列，長度為原

劍指offer(二十三，二十四，二十五)最小的k個數，連續子陣列的最大和，連結串列中環的入口節點

23：最小的k個數 題目描述 輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。 簡單題。。。。 function GetLeastNumbers_Solution(input, k) { if(k>input.l

陣列、連結串列等常用資料結構和集合淺解（java）

簡單理解：多人在操作同一個容器時，每個人修改裡面的元素時其實是複製出來一個新的容器 ，然後在新的容器上進行修改，修改完將新的容器賦給原來容器的引用，而這個過程中很多人在同步做讀取的動作，但是他們讀取的是舊的容器元素，新的內容他們未能取得，這樣就讀寫分離了，不會產生衝突，但是新舊元素不能保持一致。

android平臺下OpenGL ES 3.0例項詳解頂點緩衝區物件(VBO)和頂點陣列物件(VAO)

OpenGL ES 3.0學習實踐 android平臺下OpenGL ES 3.0從零開始 android平臺下OpenGL ES 3.0繪製純色背景 android平臺下OpenGL ES 3.0繪製圓點、直線和三角形 android平臺下OpenGL E

java揹包的陣列實現，連結串列實現

陣列實現 package base.structure; import java.lang.reflect.Array; import java.util.Iterator; /** * @program: Algorithm4J * @description: 揹包陣列的實現

面試題18——連結串列和陣列有什麼區別

陣列和連結串列有以下不同： （1）儲存形式：陣列是一塊連續的空間，宣告時就要確定長度。連結串列是一塊可不連續的動態空間，長度可變，每個節點要儲存相鄰結點指標； （2）資料查詢：陣列的線性查詢速度快，查詢操作直接使用偏移地址。連結串列需要按順序檢索結點，效率低； （3）資料插入或刪除：連結串列

陣列和連結串列和集合的區別和應用場景以及堆和棧的區別

陣列和集合的區別： 1.陣列的長度固定的，超過長度時，只能建立一個新的陣列，並把舊的陣列的值傳進去方可； 而集合的長度是動態不固定的。 2.陣列的儲存型別是單一的，同一陣列只能儲存同一資料型別的資料。 而集合可以儲存多鍾資料型別的資料。 3.陣列只能通過下標來訪

連結串列和順序表（參考stl原始碼，使用c語言實現）

順序表 優點：可以隨機訪問，cpu快取記憶體利用率高，不涉及（較少）進行插入和刪除操作，應該使用順序表。 順序表，不論是動態開闢，還是固定大小，一般放置在棧上，不用程式設計師手動開闢空間 連結串列：主要運用2種，A單向不帶頭結點的非迴圈連結串列      B雙向帶頭

新手做無貨源店鋪淘客不會做，詳解店淘操作模式和新手常陷入的誤區

隨著現代社會的發展，網際網路電商已成為越來越多關注的話題。淘寶一點一點的走進大家的視線，讓大家對她產生了一種依賴，越來越多的人開始進行網購。在網上買東西很方便，不僅可以節約時間，還可以節省體力。也是這個原因，現在好多的兼職創業朋友選擇了加入淘寶大家庭。 很多人看

每天一點點之資料結構與演算法 - 應用 - 分別用連結串列和陣列實現LRU緩衝淘汰策略

一、基本概念： 1、什麼是快取？ 快取是一種提高資料讀取效能的技術，在硬體設計、軟體開發中都有著非廣泛的應用，比如常見的CPU快取、資料庫快取、瀏覽器快取等等。   2、為什麼使用快取？即快取的特點 快取的大小是有限的，當快取被用滿時，哪些資料應該被清

棧的實現——連結串列和陣列

C語言（列印函式採用的c++）： 棧的連結串列實現—— 棧的初始化（建立||清空）、入棧、出棧（獲取棧頂元素） 棧的陣列實現——初始化、入棧、出棧、清空棧 參考資料：《資料結構與演算法分析——C語言描述》 P46 一. 棧的連結串列實現 StackLinkList.