2. 程式人生 > >順序表中基本操作的實現

順序表中基本操作的實現

阿新 • • 發佈：2018-12-10 
//庫函式標頭檔案包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函式狀態碼定義
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;

//順序表的儲存結構定義
#define LIST_INIT_SIZE  100
#define LISTINCREMENT   10
 

typedef int ElemType;  //假設線性表中的元素均為整型
typedef struct//注意這裡的寫法
{
    ElemType* elem;   //儲存空間基地址
    int length;       //表中元素的個數
    int listsize;     //表容量大小
} SqList;   //順序表型別定義

一、順序表的初始化

Status InitList_Sq(SqList &L)
{
    L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//注意是給L.elem分配空間//在初始化的時候，有長度限制，因為是順序結構
    if
 
(!L.elem) exit(OVERFLOW); 
    L.length=0;
    L.listsize=LIST_INIT_SIZE;
}

注意： （1）是給L.elem分配空間，而不是L，不要和連結串列混淆 （2）在給L.elem分配空間的時候，LIST_INIT_SIZE*sizeof(ElemType)，會有具體的長度，因為是順序結構，有明確的長度，不要和連結串列混淆，連結串列才沒有具體的長度 （3）在初始化的時候，順序表長度為0，容量大小為分配空間的大小

演算法時間複雜度：O(1)

二、順序表的建立

Status ListCreate_Sq(SqList &L)
 

{
    ElemType n,m;
    scanf("%d",&n);
    L.elem=(ElemType*)malloc(n*sizeof(ElemType));//雖然之前已經確定了分配的空間，但是，之後因為有確定的數字了，所以重新分配空間；
    if(!L.elem) exit(OVERFLOW);
    L.length=n;
    L.listsize=n;
    for(int i=0; i<n; i++)
    {
        scanf("%d",&m);
        L.elem[i]=m;
        //scanf("%d",&L.elem[i]);//這種方法也是對的
    }
    return OK;
}

ListCreate_Sq 和 InitList_Sq是不同的，InitList_Sq是結構初始化，初始化的時候，L.length=0;L.listsize=LIST_INIT_SIZE。ListCreate_Sq 是建立一個順序表，L.length和L.listsize由輸入的值確定。但是兩者還是有共同點的，兩者都先L.elem=(ElemType*)malloc(....*sizeof(ElemType)); 一般是先InitList_Sq(La);然後再CreateList_Sq(La);

三、順序表的插入

1、指定插入位置

方法1：

Status ListInsert_Sq(SqList &L, int pos, ElemType e)//插入必須要看空間問題，不夠的話就重新分配，倒著賦值//注意pos是位置，從1開始的
{
    ElemType* newbase;
    if(pos>=1&&pos<=L.length+1)//pos是位置,別忘記對length+1（length為元素的個數），因為可以插入的位置有n+1個；
    {
        if(L.length>=L.listsize)//這裡別忘記等於號，因為等於的話，再插入也會超過記憶體大小；
        {
            newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//與LISTINCREMENT相加的是listsize而不是length,因為是增大記憶體//給newbase動態分配一個長度為LISTINCREMENT的新空間
            if(!newbase) exit(OVERFLOW);//在分配空間方面，都要進行這樣的判斷；
            L.elem=newbase;//新分配空間的基地址
            L.listsize+=LISTINCREMENT;//重新分配空間了，所以別忘記改變容量的大小。
        }
        for(int i=L.length;i>=pos;i--)
            L.elem[i]=L.elem[i-1];
        L.elem[pos-1]=e;
        L.length++;//多了一個數據元素，所以length也要加一；
        return OK;
    }
    else  return ERROR;//別忘記else
}

方法2：

Status ListInsert_Sq(SqList &L,int pos,ElemType e)//在pos位置插入e元素
{
    ElemType* newbase;//newbase是ElemType*類型的，別定義錯了
    if(pos>=1&&pos<=L.length+1)//可以插入的有n+1個位置，所以，別忘了+1//pos是位置,別忘記對length+1（length為元素的個數），因為可以插入的位置有n+1個；
    {
        if(L.length>=L.listsize)//這裡別忘記等於號，因為等於的話，再插入也會超過記憶體大小；
        {
            newbase=(ElemType*)realloc(L.elem,(LISTINCREMENT+L.listsize)*sizeof(ElemType));//注意是在L.listsize基礎上進行的擴充，因為是增大記憶體，
            if(!newbase) exit(OVERFLOW);//在分配空間方面，都要進行這樣的判斷；
            L.elem=newbase;
            L.listsize+=LISTINCREMENT;//重新分配空間了，所以別忘記改變容量的大小。
        }
        ElemType *p,*q;
        p=&(L.elem[pos-1]);
        for(q=&(L.elem[L.length-1]);q>=p;q--)
            *(q+1)=*q;
        *p=e;
        L.length++;
        return OK;
    }
    else  return ERROR;//別忘記else
}

注意： （1）對於在順序表中插入一個數來說，一定要先判斷插入的位置是否是在1—length+1的範圍內，在的話，看資料多少是否超過了儲存空間的大小，超過了的話，要進行空間重新分配，空間重新分配的時候還不要忘記判斷是否分配成功。成功的話，改變記憶體大小，然後將要插入的位置記錄下來，倒著賦值，賦值的時候注意臨界點的判斷，最後不要忘記長度加一。 （2）newbase到底是什麼型別的，自己要分清了 （3）重新分配的時候，是LISTINCREMENT+L.listsize與sizeof相乘 （4）別忘記對於地址的儲存

演算法的時間複雜度為：O( ListLength(L) )

2、給出一定的條件，插入資料 例如：有序插入函式，L是一個遞增的有序順序表，函式Status ListInsert_SortedSq(SqList &L, ElemType e)用於向順序表中按遞增的順序插入一個數據。 比如：原資料有：2 5，要插入一個元素3，那麼插入後順序表為2 3 5。 要考慮擴容的問題。 

Status ListInsert_SortedSq(SqList &L, ElemType e)
{
    int i=0;
    for(int j=0;j<L.length;j++)
    {
        if(L.elem[j]>e)  break;//注意臨界判斷條件
        else i++;
    }
    for(int j=L.length; j>=i+1; j--)  L.elem[j]=L.elem[j-1];
    L.elem[i]=e;
    L.length++;//這裡不要忘記；
    return OK;
}

注意：

Status ListInsert_SortedSq(SqList &L, ElemType e)
{
    ElemType i=0;
    while(L.elem[i]<e)
    {
        i++;
    }
    for(int j=L.length-1;j>=i;j--)
        L.elem[j+1]=L.elem[j];
    L.elem[i]=e;
    L.length++;//這裡不要忘記；
    return OK;
}

這個是錯誤的，因為，萬一想要插入的數比所有的數都打的話，那麼i就會無限制地增加

改成

Status ListInsert_SortedSq(SqList &L, ElemType e)
{
    int i=0;
    while(L.elem[i]<e&&i<L.length)//千萬不要忘記i<L.length這個條件
    {
        i++;
    }
    for(int j=L.length-1;j>=i;j--)
        L.elem[j+1]=L.elem[j];
    L.elem[i]=e;
    L.length++;//這裡不要忘記；
    return OK;
}

注意：增加元素的同時，不要忘記將長度加1；

四、順序表的刪除 刪除pos位置處的元素，並給e賦值為pos位置處的元素 方法1：

Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
{
    if(pos>=1&&pos<=L.length)
    {
        e=L.elem[pos-1];
        for(int i=pos-1;i<=L.length-2;i++)
            L.elem[i]=L.elem[i+1];
        L.length--;
    }
    else  return ERROR;
}

方法2：

Status ListDelete_Sq(SqList &L, int pos, ElemType &e)//刪除不用考慮空間問題，一個個前移就好，最後別忘記L.length--
{
    if(pos>=1&&pos<=L.length)
    {
        ElemType *p;
        e=L.elem[pos-1];//先將e賦值，也就是返回刪掉了哪個數
        for(p=&(L.elem[pos-1]);p<=&(L.elem[L.length-2]);p++)
            *p=*(p+1);
        L.length--;
    }
    else  return ERROR;
}

注意： （1）刪除元素的同時，不要忘記將長度減1； （2）刪除是正向賦值，插入是倒敘賦值

演算法的時間複雜度為：O( ListLength(L) )

五、查詢某元素的位置

查詢元素e在順序表的位次並返回

int ListLocate_Sq(SqList L, ElemType e)
{
    int a=-1;
    int i;
    for(i=0; i<L.length; i++)
    {
        if(L.elem[i]==e)
        {
            a=1;
            break;
        }
        else  continue;
    }
    if(a==-1)
    {
        return 0;
    }
    else return i+1;
}

六、對於符合某條件的元素的定位

Status Equal(ElemType a,ElemType b)
{
    if(a==b)  return true;
    else  return false;
}
int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))//在表中查詢第一個值與e滿足compare（）的元素的位序
{
    ElemType *p;
    int i=1;//i的初值為第1個元素的位序
    p = L.elem; //p的初值為第1個元素的儲存位置
    while(i <= L.length && !(* compare)(*p++,e)) i++;
    if(i <= L.length) return i;
    else return 0;
}

/////////////////////////////////用法
if(!LocateElem_Sq(La,elem,Equal))
            ListInsert_Sq(Lc,Lc.length+1,elem);

演算法的時間複雜度為：O( ListLength(L) )

相關推薦

順序表中基本操作的實現

//庫函式標頭檔案包含 #include<stdio.h> #include<malloc.h> #include<stdlib.h> //函式狀態碼定義 #def

動態順序表的基本操作的實現

順序表是用一段實體地址連續的儲存單元依次儲存資料元素的線性結構，一般情況下采用陣列儲存。在陣列上完成資料的增刪查改。 順序表一般可以分為： 靜態順序表：使用定長陣列儲存。 動態順序表：使用動態開闢的陣列儲存。 SeqList.h #ifndef __SeqLi

資料結構C/C++程式碼實現 順序表棧基本操作

順序表棧基本操作的實現  原始碼： #include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std; #define MAXSIZE 100 //#d

順序表的基本操作及C語言完整實現

對順序表進行操作，大致可分為以下幾類： 表的建立； 表中新增（新增）資料元素； 表中刪除資料元素； 表中查詢指定資料元素； 表中更改某資料元素； 以上操作各自的原理及實現如下所示。 順序表的建立 順序表的建立，也就是順序表進行初始化，在預先申請記憶體空間的同時，給變數 size 和 len

順序表的基本操作及C語言實現（詳解版）

我們學習了順序表及初始化的過程，本節學習有關順序表的一些基本操作，以及如何使用 C 語言實現它們。 順序表插入元素 向已有順序表中插入資料元素，根據插入位置的不同，可分為以下 3 種情況： 插入到順序表的表頭； 在表的中間位置插入元素； 尾隨順序表中已有元素，作為順序表中的最後一個元素； 雖然資

C語言實現順序表的基本操作

1.定義 線性表的順序儲存是指在記憶體中用一組地址連續的儲存單元依次儲存線性表的各元素，用這種儲存形式儲存的線性表稱為順序表。也就是說，順序表以資料元素在計算機內的物理位置相鄰來表示資料元素線上性表中的邏輯相鄰關係。 2.線性表的順序儲存示意圖

連結串列，順序表的基本操作及其實現的棧與佇列

1，順序表 在c裡面，這一部分也就是靜態表和動態表的實現，插入，刪除有丁點意思。 靜態表靠陣列和長度實現（注意長度這一點，因為它反映了當前表內容長度，十分重要） 動態表依靠申請連續空間實現（結構體內部包括首地址，當前規模以及長度） 插入： int *p; p=&

單鏈表的基本操作實現

turn lag 個數 信息 listt 帶頭結點 img 鏈表的基本操作 原因 1、寫這篇博文的原因 C語言有三個重要部分：流程控制、函數、指針。 對於指針，單單了解它的簡單運用是遠遠不夠的，最重要的是學習鏈表。所以這篇文章通過用C語言實現鏈表的一些基本操作和總結，希望對

順序表的基本操作

print type text 復雜 har pla 元素 斷線 number 順序表基本運算 初始化線性表 InitList(L) 銷毀線性表 DestoryList(L) 判斷線性表是否為空 ListEmpty(L) 求線性表的長度 ListLength(L) 輸出線

資料結構（一）:順序表的基本操作 C語言

順序表   標頭檔案： Sqlist.h #include<stdio.h> #include<stdlib.h> #define SIZE 15 #pragma once typedef struct Sqlist { int elem[SIZ

資料結構：順序表的基本操作和還原

實現順序表的基本操作 三、實驗內容 定義順序表(可用結構體實現)、所需要的符號常量以及在該順序表上所進行的操作（用函式實現）初始化、插入新元素、刪除指定元素、查詢（返回指定元素位置）、檢索指定位置的元素。   要求：1、在主函式中呼叫各個函式實現相應操作，首

順序表的基本操作（C++）

// Sequence.cpp : 定義控制檯應用程式的入口點。 //#include "stdafx.h" #include "iostream" using namespace std; //錯誤1，使用cout要加上此句 typedef int type; //忘記知

C++ 順序表的基本操作（使用模版類）

一、遇到問題：        原因：類的函式定義不能放在SeqList.cpp中，必須放在Seqlist.h(類的函式宣告和定義放在同一個檔案下)中，否則        會

資料結構實驗一線性表的基本操作實現及其應用

一.實驗名稱 線性表的基本操作實現及其應用 二.實驗目的 熟練掌握線性表的結構特點，掌握順序表的基本操作。 學會使用順序表解決實際問題。 三.實驗內容 建立 n 個元素的順序表（n 的大小和表裡資料自己確定），實現相關的操作：輸出，插入，刪

自己寫的順序表的基本操作，插入、刪除、修改，給出完整程式碼，其中運用到goto語句

#include<iostream> using namespace std; #define MAXSIZE 100 typedef int DataType; typedef struct {DataType data[MAXSIZE]; //通常用一位陣列

順序棧的基本操作實現c++

注：若有問題或需要補充的內容請告之，新手上路，謝謝。 #include<stdlib.h> #include<stdio.h> #include<math.h> #include<cstring> #include<st

c語言順序表的基本操作

下面是順序表的基本操作，c語言版的資料結構書上寫的操作都實現了因為總體程式碼太長如果寫在一個class中要近500行，閱讀和修改都不方便，所以採用分開寫，希望大家以後寫較長的程式時也採用這種方法，自己執行的所有功能都能實現，而且個人感覺介面還是比較人性化的，大家還有什麼意見或

資料結構順序表相關基本操作練筆

#include<stdio.h> #include<stdlib.h> #define MAX 30 #define LIST_INCREMENT 40 typedef struct{ int lenth; int listsize; int *base; }s

廣義表的基本操作實現

    廣義表的四個特徵：（1）廣義線性表；（2）元素複合性；（3）元素遞迴性；（4）元素共享性     廣義表的上述四個特徵對於他的使用價值和應用效果起到了很大的作用。廣義表的結構相當靈活，它可以相容線性表、陣列、樹和有向圖等各種常用的資料結構。當二維陣列的每行或每列作為

Redis系列（十二）：資料結構SortedSet跳躍表中基本操作命令和原始碼解析

1.SkipList Redis的sortedSet資料結構是有序不重複的（索引為唯一的，資料(score)卻可以重複）， 跳錶是redis的一個核心元件，也同時被廣泛地運用到了各種快取地實現當中，它的主要優點， 就是可以跟紅黑樹、AVL等平衡樹一樣，做到比較穩定地插入、查詢與刪除。理論插入查詢刪除的演算法時