2. 程式人生 > >線性表——順序表——時間複雜度計算

線性表——順序表——時間複雜度計算

阿新 • • 發佈：2018-12-26

  資料結構的核心思想是通過資料結構的思維來優化程式碼的演算法，以此來提升程式的執行效能，縮短程式執行的時間。下面我來舉兩個例子，以此來說明資料結構的時間複雜度計算問題。

  由於我這裡操作的是線性表——順序表，所以說先把線性表——順序表的原始碼貼出來

AbstractLineMethod.java

package com.mycompany;

import util.ObjectHolder;

/**
 * Created by HP on 2017/9/6.
 */
public interface AbstractLineMethod {
    /**
     * 初始化線性表
     * @param
 
 size
     */
    void initList(int size);

    /**
     * 銷燬線性表
     */
    void destroyList();

    /**
     * 清空線性表
     */
    void clearList();

    /**
     * 線性表判空
     * @return
     */
    boolean listEmpty();

    /**
     * 獲取線性表的長度
     * @return
     */
    int listLength();

    /**
     * 獲取指定位置處的元素
     * @param
 
 i
     * @param ele
     * @return
     */
    public boolean getElem(int i, ObjectHolder ele);

    /**
     * 獲取該元素線上性表中第一次出現的位置
     * @param ele
     * @return
     */
    public int locateElem(ObjectHolder ele);

    /**
     * 獲取指定元素的前驅
     * @param currentElem
     * @param preElem
     * @return
 

     */
    public boolean priorElem(ObjectHolder currentElem,ObjectHolder preElem);

    /**
     * 獲取指定元素的後繼
     * @param currentElem
     * @param nextElem
     * @return
     */
    public boolean nextElem(ObjectHolder currentElem,ObjectHolder nextElem);

    /**
     * 線上性表的指定位置處插入元素
     * @param i
     * @param ele
     * @return
     */
    public boolean listInsert(int i,Object ele);

    /**
     * 刪除線性表指定位置處的元素
     * @param i
     * @param ele
     * @return
     */
    public boolean listDelete(int i,ObjectHolder ele);

    /**
     * 迴圈遍歷線性表
     */
    public void listTraverse();

}

LineMethod.java

package com.mycompany;

import util.ObjectHolder;

/**
 * Created by HP on 2017/9/6.
 */
public class LineMethod implements AbstractLineMethod{

    private int m_size = 0;
    private Object[] m_pList = null;
    private int m_iLength = 0;

    /**
     * 初始化線性表
     * @param size
     */
    public void initList(int size){
        this.m_size = size;
        this.m_pList = new Object[size];
        this.m_iLength = 0;
    }

    /**
     * 銷燬線性表
     */
    public void destroyList(){
        this.m_pList = null;
        this.m_size = 0;
        this.m_iLength = 0;
    }

    /**
     * 將線性表指標歸零
     */
    public void clearList(){
        this.m_iLength = 0;
    }

    /**
     * 判空操作
     * 如果線性表為空，則返回true否則返回false
     * @return
     */
    public boolean listEmpty(){
        if(this.m_iLength == 0){
            return true;
        }
        return false;
    }

    /**
     * 返回線性表的長度
     * @return
     */
    public int listLength(){
        return m_iLength;
    }

    /**
     * 獲取指定位置處的元素
     * @param i
     * @param ele
     * @return
     */
    public boolean getElem(int i, ObjectHolder ele){
        if(i < 0 || i >= m_size){
            return false;
        }
        ele.object = this.m_pList[i];
        return true;
    }

    /**
     * 尋找第一個滿足ele的資料元素的位序
     * @param ele
     * @return
     */
    public int locateElem(ObjectHolder ele){
        for(int i = 0;i < this.m_iLength; i++){
            if(this.m_pList[i] == ele.object){
                return i;
            }
        }
        return -1;
    }

    /**
     * 獲取指定元素的前驅，如果存在，則返回true，不存在則返回false
     * @param currentElem
     * @param preElem
     * @return
     */
    public boolean priorElem(ObjectHolder currentElem,ObjectHolder preElem){
        //如果查詢元素不位於線性表，則返回false
        int temp = locateElem(currentElem);
        if(temp == -1){
            return false;
        }
        //第一個元素沒有前驅，所以說應該加以排除
        if(temp == 0){
            return false;
        }
        preElem.object = this.m_pList[temp - 1];
        return true;
    }

    /**
     * 獲取指定元素的後繼，如果存在則返回true，如果不存在則返回false
     * @param currentElem
     * @param nextElem
     * @return
     */
    public boolean nextElem(ObjectHolder currentElem,ObjectHolder nextElem){
        //如果所查詢元素不是位於線性表中，則返回false
        int temp = locateElem(currentElem);
        if(temp == -1){
            return false;
        }
        //最後一個元素沒有後繼，應該加以排除
        if(temp == this.m_iLength -1){
            return false;
        }
        nextElem.object = this.m_pList[temp + 1];
        return true;
    }

    /**
     * 在指定位置處插入指定元素，如果插入成功則返回true，失敗則返回false
     * @param i
     * @param ele
     * @return
     */
    public boolean listInsert(int i,Object ele){
        if(i < 0 || i > this.m_iLength){
            return false;
        }
        for (int k = this.m_iLength - 1;k >= i;k --){
            this.m_pList[k + 1] = this.m_pList[k];
        }
        this.m_pList[i] = ele;
        this.m_iLength ++;
        return true;
    }

    /**
     * 線上性表中刪除指定的元素，如果刪除成功，則返回true，如果刪除失敗則返回false
     * @param i
     * @param ele
     * @return
     */
    public boolean listDelete(int i,ObjectHolder ele){
        if(i < 0 || i >= this.m_iLength){
            return false;
        }
        ele.object = this.m_pList[i];
        for(int k = i +1;k < this.m_iLength;k ++){
            this.m_pList[k - 1] = this.m_pList[k];
        }
        this.m_iLength --;
        return true;
    }

    /**
     * 迴圈遍歷線性表中的元素
     */
    public void listTraverse(){
        for(int i = 0;i < this.m_iLength;i ++){
            System.out.println(this.m_pList[i]);
        }
    }


}

ObjectHolder.java

package util;

/**
 * Created by HP on 2017/9/6.
 */
public class ObjectHolder {

    public Object object;

}

  下面是對於該線性表的時間複雜度的計算示例

  示例1：

  現有現有線性表LA,LB，LA中的陣列為：3,5,7,2,9,8，LB中的陣列為：4,,6,0,1現將LB中的數組合併到LA中，方法為：

TestUnion.java

package com.mycompany;

import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import util.ObjectHolder;

/**
 * 現有線性表LA,LB
 * LA中的陣列為：3,5,7,2,9,8
 * LB中的陣列為：4,,6,0,1
 * 現將LB中的數組合併到LA中
 * Created by HP on 2017/9/12.
 */
public class TestUnion {

    private static final Logger log = Logger.getLogger(TestUnion.class);

    /**
     * 建立線性表LA
     * @return
     */
    public AbstractLineMethod createListLA(){
        Object e1 = 3;
        Object e2 = 5;
        Object e3 = 7;
        Object e4 = 2;
        Object e5 = 9;
        Object e6 = 8;
        AbstractLineMethod abstractLineMethod = new LineMethod();
        abstractLineMethod.initList(10);
        abstractLineMethod.listInsert(0,e1);
        abstractLineMethod.listInsert(1,e2);
        abstractLineMethod.listInsert(2,e3);
        abstractLineMethod.listInsert(3,e4);
        abstractLineMethod.listInsert(4,e5);
        abstractLineMethod.listInsert(5,e6);
        return abstractLineMethod;
    }

    /**
     * 建立線性表LB
     * @return
     */
    public AbstractLineMethod createListLB(){
        Object e1 = 4;
        Object e2 = 6;
        Object e3 = 0;
        Object e4 = 1;
        AbstractLineMethod abstractLineMethod = new LineMethod();
        abstractLineMethod.initList(10);
        abstractLineMethod.listInsert(0,e1);
        abstractLineMethod.listInsert(1,e2);
        abstractLineMethod.listInsert(2,e3);
        abstractLineMethod.listInsert(3,e4);
        return abstractLineMethod;
    }

    /**
     * 合併線性表LA與LB
     */
    @Test
    public void testUnion(){
        //集合A
        AbstractLineMethod la = createListLA();
        //線性表LA的順序：3,5,7,2,9,8
        //集合B
        AbstractLineMethod lb = createListLB();
        //線性表LB的順序：4,6,0,1
        //集合A的長度
        int laLenth = la.listLength();
        //集合B的長度
        int lbLenth = lb.listLength();
        ObjectHolder ele = new ObjectHolder();
        for(int i = 0;i < lbLenth;i ++){
            lb.getElem(i,ele);
            if(la.locateElem(ele) == -1){
                la.listInsert(laLenth ++,ele.object);
            }
        }
        //迴圈遍歷新陣列
        la.listTraverse();
        //輸出結果：3,5,7,2,9,8,4,6,0,1
        Assert.assertEquals(10,la.listLength());
        log.info("合併後的線性表陣列長度為：" + la.listLength());
    }

}

  示例2：

  現有非降序線性表LA,LB，其中線性表LA中的陣列為：3,5,8,11，線性表LB中的陣列元素為：2,6,8,9,11,15,20，現將LA與LB中的元素按照非降序順序插入到空線性表LC中，方法為：

TestMergeList.java

package com.mycompany;

import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import util.ObjectHolder;

/**
 * 現有非降序線性表LA,LB
 * 其中線性表LA中的陣列為：3,5,8,11
 * 線性表LB中的陣列元素為：2,6,8,9,11,15,20
 * 現將LA與LB中的元素按照非降序順序插入到空線性表LC中，方法如下：
 * Created by HP on 2017/9/13.
 */
public class TestMergeList {

    private static final Logger log = Logger.getLogger(TestMergeList.class);

    /**
     * 建立線性表LA
     * @return
     */
    public AbstractLineMethod createListLA(){
        Object e1 = 3;
        Object e2 = 5;
        Object e3 = 8;
        Object e4 = 11;
        AbstractLineMethod abstractLineMethod = new LineMethod();
        abstractLineMethod.initList(10);
        abstractLineMethod.listInsert(0,e1);
        abstractLineMethod.listInsert(1,e2);
        abstractLineMethod.listInsert(2,e3);
        abstractLineMethod.listInsert(3,e4);
        return abstractLineMethod;
    }

    /**
     * 建立線性表LB
     * @return
     */
    public AbstractLineMethod createListLB(){
        Object e1 = 2;
        Object e2 = 6;
        Object e3 = 8;
        Object e4 = 9;
        Object e5 = 11;
        Object e6 = 15;
        Object e7 = 20;
        AbstractLineMethod abstractLineMethod = new LineMethod();
        abstractLineMethod.initList(10);
        abstractLineMethod.listInsert(0,e1);
        abstractLineMethod.listInsert(1,e2);
        abstractLineMethod.listInsert(2,e3);
        abstractLineMethod.listInsert(3,e4);
        abstractLineMethod.listInsert(4,e5);
        abstractLineMethod.listInsert(5,e6);
        abstractLineMethod.listInsert(6,e7);
        return abstractLineMethod;
    }

    /**
     * 建立空的線性表LC
     * @return
     */
    public AbstractLineMethod createListLC(){
        AbstractLineMethod abstractLineMethod = new LineMethod();
        abstractLineMethod.initList(20);
        return abstractLineMethod;
    }

    /**
     * 合併到LC
     */
    @Test
    public void mergeToLC(){
        //建立線性表LA
        AbstractLineMethod la = createListLA();
        //建立線性表LB
        AbstractLineMethod lb = createListLB();
        //建立空的線性表LC
        AbstractLineMethod lc = createListLC();
        //初始化下標i,j
        int i = 0,j = 0;
        //當兩個下標長度均在有效範圍內時
        while((i < la.listLength()) && (j < lb.listLength())){
            ObjectHolder laEle = new ObjectHolder();
            ObjectHolder lbEle = new ObjectHolder();
            //如果元素laEle與元素lbEle都獲取成功時
            if(la.getElem(i,laEle) && lb.getElem(j,lbEle)){
                //如果laEle元素的雜湊值小於等於lbEle元素的雜湊值，則將laEle元素插入到lc線性表中
                if(laEle.object.hashCode() <= lbEle.object.hashCode()){
                    lc.listInsert(i + j,laEle.object);
                    //插入後，線性表la中的指標後移一位
                    i ++;
                } else { //否則的話，此時laEle中的元素大於lbEle中的元素，則將lbEle元素插入到lc線性表中
                    lc.listInsert(i + j,lbEle.object);
                    //插入後，線性表lb中的指標後移一位
                    j ++;
                }
            }
        }
        //當其中的一個線性表迴圈遍歷結束，另一個還沒結束時，此時應該做的就是將沒有迴圈結束的線性表中剩餘的元素依次全部插入到lc中
        //當線性表la剩餘時
        while(i < la.listLength()){
            ObjectHolder ele = new ObjectHolder();
            //如果la中的元素獲取正確時，執行if語句中的程式碼
            if(la.getElem(i,ele)){
                //將該獲取的元素插入到lc中
                lc.listInsert(i + j,ele.object);
                //將la中的元素指標（下標）自增1
                i ++;
            }
        }

        //當線性表lb剩餘時
        while(j < lb.listLength()){
            ObjectHolder ele = new ObjectHolder();
            //如果lb中的元素獲取正確時，執行if語句中的程式碼
            if(lb.getElem(j,ele)){
                //將該獲取的元素插入到lc中
                lc.listInsert(i + j,ele.object);
                //將lb中的元素指標（下標）自增1
                j ++;
            }
        }

        //迴圈結束之後，迴圈遍歷lc中的元素
        lc.listTraverse();
        log.info("合併後的陣列長度為：" + lc.listLength());
        Assert.assertEquals(11,lc.listLength());

    }

}

  通過上述2個示例我們不難看出：
  在示例1中，每次在LA中插入一個LB中的元素，該元素都要迴圈遍歷LA中的每一個元素，然後將其插入其中，其插入的耗時為：O(listLength(LA)*listLength(LB))

  在示例2中，雖然整體的程式碼量比示例1中的程式碼量要長，但是LA中的元素已經找到，只要符合條件即可插入到LC中，而LB中的元素也是一樣的，這樣一來，插入到LC中的元素，LA只需要迴圈一次，LB也只需要迴圈一次，所以說整體的時間消耗為：
O(listLength(LA)+listLength(LB))

  通過上述分析，我們可以發現，雖然示例2中的情況更復雜，程式碼量也更多，但是實際上在程式碼執行耗時操作時，示例2中的方法效能要明顯優於示例1中的方法。

  下面是該專案的完整下載地址：

相關推薦

線性表——順序表——時間複雜度計算

  資料結構的核心思想是通過資料結構的思維來優化程式碼的演算法，以此來提升程式的執行效能，縮短程式執行的時間。下面我來舉兩個例子，以此來說明資料結構的時間複雜度計算問題。   由於我這裡操作的是線性表——順序表，所以說先把線性表——順序表的原始碼貼出來 Ab

線性表——順序表——時間複雜度計算2

   接上一篇文章繼續分析    在之前的文章中的示例1和示例2中，我們通過觀察可以發現，當在順序儲存結構的線性表中某個位置上插入或刪除一個數據元素時，其時間主要耗費在移動元素上（換句話說，移動元素的操作為預估演算法時間複雜度的基本操作），而移動元素的格式

資料結構-演算法-時間複雜度計算

演算法的時間複雜度定義為： 在進行演算法分析時，語句總的執行次數T(n)是關於問題規模n的函式，進而分析T(n)隨n的變化情況並確定T(n)的數量級。演算法的時間複雜度，也就是演算法的時間量度，記作：T(n}=0(f(n))。它表示隨問題規模n的增大，演算法執行時間的埔長率

資料結構與演算法-時間複雜度計算

一、方法 根本沒有必要計算時間頻度,即使計算處理還要忽略常量、低次軍和最高次剩的係數,所以可以採用如下簡單方法: 找出演算法中的基本語句：演算法中執行次數最多的那條語句就是基本語句,通常是最內層迴圈的迴圈體。 計算基本語句的執行次數的數量級：只需計算基本語句執行次數的數量級,這就

演算法之漢諾塔時間複雜度計算

 設a, b, c是3個塔座：開始時，塔座a上有n個自上而下、由小到大地疊在一起圓盤，各圓盤從小到大編號為1, 2, …, n，現要求將塔座a上的這一疊圓盤移到塔座b上，並仍按同樣順序疊置，移動圓盤時遵守以下移動規則： 規則1：每次只能移動1個圓盤； 規則2：不允許將較大的圓

演算法的時間複雜度計算

時間複雜度與演算法步驟的多少是同樣的含義，計算演算法的總步驟就是時間複雜度。同時大O表示的是時間複雜度的上限。所以計算總步驟時可以按同數量級中最大情況來計算。 1.O(f(n)):輸入規模為n（n個數據）的演算法的時間複雜度為f（n）。 2.O(1)：演算法的時間複雜度與輸

演算法時間複雜度計算方法

一、概念: 時間複雜度是總運算次數表示式中受n的變化影響最大的那一項(不含係數) 比如：一般總運算次數表示式類似於這樣： a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f a ！ =0時，時間複雜度就是O(2^n); a=0,b<

資料結構-時間複雜度計算詳解--向李紅老師的資料結構低頭 ：）

今天早上突然想總結一下資料結構的時間複雜度的知識。 之前學了很多遍，但是一直沒有總結，所以之前參考了Algorithm還有清華大學出版的那個資料結構書，今天早上花了幾個小時好好的總結一下，也送給三班的同學們。 演算法的時間複雜度定義為： 在

二分法的時間複雜度+演算法的時間複雜度計算

黃色標亮-劃重點背誦+自己的理解，綠色標亮-引用資源的連結，藍色標亮-要注意的地方 二分法查詢 的 時間複雜度計算 設 查詢資料的長度為n，每次查詢後資料長度減半，則有 查詢次數 資料長度 第1次查詢           n/2                      

遞迴演算法的時間複雜度計算

在演算法分析中，當一個演算法中包含遞迴呼叫時，其時間複雜度的分析會轉化為一個遞迴方程求解。實際上，這個問題是數學上求解漸近階的問題，而遞迴方程的形式多種多樣，其求解方法也是不一而足，比較常用的有以下四種方法：     (1)代入法(Substitution Metho

快速排序平均情況下時間複雜度計算過程：

就平均情況而言，快速排序是目前被認為最好的一種內部排序方法，其時間複雜度在平均情況下是nlogn，在最壞的情況下（有序時）時間複雜度是o(n^2)。下面來分析時間複雜度的計算過程： 平均情況下：T(n)=2*T(n/2)+n;      第一次劃分            

時間複雜度計算

定義：如果一個問題的規模是n，解這一問題的某一演算法所需要的時間為T(n)，它是n的某一函式 T(n)稱為這一演算法的“時間複雜性”。 當輸入量n逐漸加大時，時間複雜性的極限情形稱為演算法的“漸近時間複雜性”。 我們常用大O表示法表示時間複雜性，注意它是某一個演算法的時間複雜性。大O表示只是說有上界，由定義如

已知長度為n的線性表A採用順序儲存結構，請寫一個時間複雜度為O（n）、空間複雜度為O（1）的演算法，該演算法可刪除線性表中所有值為item的資料元素。

語言：C++ #include <iostream> using namespace std; typedef int ElemType; //定義 #define MAXSIZE 100 typedef struct {ElemType *elem; int length;}Sq

長度為n的順序表L，編寫一個時間複雜度為O(n),空間複雜度為O(1)的演算法，該演算法刪除線性表中所有值為X的元素

解法：用K記錄順序表L中不等於X的元素個數，邊掃描L邊統計K，並將不等於X的元素向前放置K位置上，最後修改L長度 void  del_x_1(SqList &L,Elemtype x){ int k=0; for(i=0;i<L.length;i++) {

編寫程式，在一非遞減的順序表L中，刪除所有值相等的多餘元素。要求時間複雜度O（n），空間複雜度為O（1）

翠花上程式碼： Status delExcrescentValue(SeqList &S){ int flag = 0,val = S.elem[0];//記錄值不等的下標 //printf("%d\n",S.elem[0]); for(int i = 1;i

【資料結構】實現順序表以及簡單的時間複雜度分析

最近在學資料結構，接下來一段時間我將用java來實現所學的各種資料結構，以加深自己的印象。 線性表包括順序表和連結串列，其實順序表就是動態陣列，下面我將二次封裝實現屬於自己的動態陣列。 -------------------------------------------

刪除線性表中所有值為x的元素，要求時間複雜度為O(n)，空間複雜度為O(1)

思路：統計不等於x的個數，用k記錄不等於x的元素的個數。邊統計邊把當前元素放在第k個位置上，最後修改表的長度 public static void del(List<Integer> l

棧表中獲取最小值，時間複雜度為O(1)

       近期複習資料結構，看到網上有一道演算法題，該題目曾經是google的一道面試題，國內的網際網路公司也紛紛效仿。我也順便複習之。        題目內容為：對現在的stack（棧）資料結構進行改進，加一個

題目9  單鏈表中儲存M個整數，設計一個時間複雜度儘可能高效的演算法

單鏈表中儲存M個整數，設計一個時間複雜度儘可能高效的演算法，對於連結串列中絕對值相等的元素（|data|<n），只保留第一次出現的節點，刪除其餘的節點。如：15->(-3)->(-15)->3  得：15->(-3) 

素數表的獲取，素數線性篩法介紹，複雜度超低

//素數線性篩法，複雜度：O(nloglogn) //求100以內素數 #include<iostream> #include<cstring> #include<string> using namespace std; bool vis[101];//