真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

成都創(chuàng)新互聯(lián)網(wǎng)站制作重慶分公司

數(shù)據(jù)結(jié)構(gòu)基礎(chǔ)（一）-創(chuàng)新互聯(lián)

線性表

線性順序表

1、線性表的數(shù)據(jù)操作

創(chuàng)新互聯(lián)服務(wù)項目包括西崗網(wǎng)站建設(shè)、西崗網(wǎng)站制作、西崗網(wǎng)頁制作以及西崗網(wǎng)絡(luò)營銷策劃等。多年來，我們專注于互聯(lián)網(wǎng)行業(yè)，利用自身積累的技術(shù)優(yōu)勢、行業(yè)經(jīng)驗、深度合作伙伴關(guān)系等，向廣大中小型企業(yè)、政府機構(gòu)等提供互聯(lián)網(wǎng)行業(yè)的解決方案，西崗網(wǎng)站推廣取得了明顯的社會效益與經(jīng)濟(jì)效益。目前，我們服務(wù)的客戶以成都為中心已經(jīng)輻射到西崗省份的部分城市，未來相信會繼續(xù)擴大服務(wù)區(qū)域并繼續(xù)獲得客戶的支持與信任！

數(shù)據(jù)結(jié)構(gòu)基礎(chǔ)（一）

2、使用定義的函數(shù)實現(xiàn)兩個集合LA和LB的合并：

void unionList(List LA,List LB,List &LC)
{
    int lena,i;
    ElemType e;
    InitList(LC);
    //將LA的所有元素插入到LC中
    for (i=1;i<=ListLength(LA);i++)
    {
        GetElem(LA,i,e);
        ListInsert(LC,i,e);
     } 
     lena=ListLength(LA);

     //將LB的所有元素插入到LC
     for(i=1;i

3、順序表存儲類型的定義

# define MaxSize 50
typedef struct
{

    ElemType date[MaxSize];
        int length;
}SqList;

4、創(chuàng)建線性表

void CreateList(Sqlist *&L,ElemType a[],int n)
{
    int i;
    L=(SqList *)malloc(sizeof(SqList)); 
    // malloc 相當(dāng)于new,分配SqList大小的內(nèi)存空間，指向SqLost的指針，并將地址賦值給L 

    for (i=0;idata[i]=a[i];
    L->length=n;    
}

5、初始化線性表

void InitList(SqList *&L) // 應(yīng)用指針
{
    L=(SqList *)malloc(sizeof(SqList));
    L->length=0;   // 初始化線性表的長度 
}

6、銷毀線性表

void DestroyList(SqlList *&L)
{

 free(L); 
}

7、判斷線性表是否為空

bool ListEmpty(SqList *L)
{
    return(L->length==0);
}

8、求線性表的長度

int ListLength(SqList *L)
{
    return(L->length);  
}

9、輸出線性表

void DispList(SqList *L)
{
    int i;
    if (ListEmpty(L))
        return;
    for (i=0;ilength;i++)
        printf("%d ",L->data[i]);
    printf("\n");
}

10、求某個數(shù)據(jù)元素的值，返回L中的第i個元素的值，并存入e中，1<=i<=ListLength(L)

bool GetElem(SqList *L,int i,ElemType &e)
{
    if (i<1||i>L->length)
        return false;
    e=L->data[i-1];
    return true;
}

11、按元素值查找

int LocateElem(L,e)
{
    int i = 0;
   while (ilength && L->data[i]!=e)
        i++;
    if (i>=L->length)
        return 0;
    else
        return i+1;

}

12、插入元素

bool ListInsert(SqList *&L,int i,ElemType e)
{
    int j;
    if (i<1||i>L->length+1)
        return false;
    i--;
    for (j=L->length;j>i;j--)
        L->data[j]=L->data[j-1];
    L->data[i]=e;
    L->length++;
    return true;    
}

13、刪除元素

bool ListDelete(SqList *&L,int i,ElemType &e)
{
    int j;
    if (i<1||i>L->length)
        return false;
    i--;
    e=L->data[i];
    for(j=i;jlength-1;j++)
        L->data[j]=L->data[j+1];
    L->length--;
    return true; 

}
線性鏈表

1、單鏈表的存儲結(jié)構(gòu)的定義

typedef struct LNode // 定義單鏈表節(jié)點類型
{
    ElemType data; //數(shù)據(jù)域
    struct LNode *next; //指針域，指向后繼節(jié)點  遞歸結(jié)構(gòu) 
}LinkList;

2、單鏈表的頭插法：

void CreateListF(LinkList *&L,ElemType a[],int n)
{
    LinkList *S;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
    for(i=0;idata=a[i];
        S->next=L->next;
        L->next=S;
    }   
 }

3、單鏈表尾插法

void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0;idata=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

4、單鏈表的基本操作

數(shù)據(jù)結(jié)構(gòu)基礎(chǔ)（一）

5、初始化線性表

void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

6、銷毀線性表

void DestroyList(LinkList *&L)
{
    LinkList *pre=L,*p=L->next;
   while (p=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
 }

7、判斷表為空

bool ListEmpty(LinkList *L)
{
    return(L->next==NULL);
}

8、求線性表的ListLength(L)

 int ListLength(LinkList *L)
 {
    int n=0;
    LinkList *p=L;
   while (p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return(n);
 }

9、輸出線性表：

void DisList(LinkList *L)
{
    LinkList *p=L->next;
   while(p!=NULL)
    {
        printf("%d",p->data);
        p=p->next;
    }
    printf("\n")
 }

10、查找某個元素

bool GetElem(LinkList *L,int i,ElemType &e)
 {
    int j=0;
    LinkList *p=L;
   while (jnext;
            }   
    if (p==NULL)
        return false;
    else
    {
        e=p->data;
        return true;
    }
 }

11、 按元素查找，返回元素的位置

 int LocateElem(LinkList *L,ElemType e)
 {
    int i=1;
    LinkList *p=L->next;
   while (p!=NULL&& p->data!=e)
    {
        p=p->next;
        i++;
     } 
     if (p==NULL)
         return 0;
     else
         return i;
  }

12、插入數(shù)據(jù)元素：

 bool ListInsert(LinkList *&L,int i,ElemType e){
    int j=0;
    LinkList *p=L,*S;
   while (jnext; 
     }
     if (p==NULL)
         return false;
     else{
        S=LinkList *)malloc(sizeof(LinkList));
        S->data=e;
        S->next=p->next;
        p->next=S;
        return true;    
     }
   }

13、刪除數(shù)據(jù)元素

 bool ListDelete(LinkList *&L,int i,ElemType &e)
 {
    int j=0;
    LinkList *p=L,*q;
   while(jnext;
     }
    if (p==NULL)
        return false;
    else{
        q=p->next;
        if(q=NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
 }
雙鏈表

1、雙向鏈表的定義和存儲結(jié)構(gòu)

 typedef struct DNode
 {
    ElemType data;
    struct DNode *prior;
    struct DNode *next;

 }DLinkList;

2、頭插法建立雙鏈表

{
    DLinkList *S;
    int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    L->prior=L->next=NULL;
    for(i=0;idata=a[i];
        S->next=L->next;
        if(L->next!=NULL)
            L->next->prior=S;
        L->next=S;
        S->prior=L;
     }
 }

3、尾插法建立雙鏈表

 void CreateListR(DLinkList *&L,ElemType a[],int n)
 {
    DLinkList *s,*r;
    int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    r=L;
    for (i=0;idata=a[i];
        r->next=s;
        s->prior=r;
        r=s;
     }
     r->next=NULL;
 }

4、插入節(jié)點：

 bool ListInsert(DLinkList *&L,int i,ElemType e)
 {
    int j=0;
    DLinkList *p=L,*s;
   while(jnext;
     }
    if (p=NULL)
        return false;
    else 
    {
        s=(DLink *)malloc(sizeof(DLinkList));
        s->data=e;
        s->next=p->next;
        if (p->next!=NULL)
            P->next->prior=s;
        s->prior=p;
        p->next=s;
        return true;
    }
 }

5、雙鏈表刪除節(jié)點

 bool ListDelete(DLinkList *&L,int i,ElemType &e)
 {
    int j=0;
    DLinkList *p=L, *q;
   while (jnext; 
     } 
    if (p==NULL)
        return false;
    else
    {
        q=p->next;
        if (q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        if (p->next!=NULL)
            p->next->prior=p;
        free(q);
        return true;

    }
 }
有序表的操作

1、有序順序表的插入操作：

 void ListInsert(SqList *&L,ElemType e)
 {
    int i =0,j;
   while (ilength && L->data[i]i;j--)
        L->data[j]=L->data[j-1];
    L->data[i]=e;
    L->length++; 
 }

2、有序鏈表的插入操作：

 void ListInsert(LinkList *&L,ElemType e)
 {
    LinkList *pre=L, *p;
   while (pre->next!=NULL && pre->next->data < e)
        pre=pre->next;
    p=(LinkList *)malloc(sizeof(LinkList));
    p->data=e;
    p->next=pre->next;
    pre->next=p;
 }

3、采用順序表存放有序表時的歸并算法（將順序表LA和LB中的元素插入到LC中形成一個新的順序表）：

void UnionList(SqList *LA,SqList *LB,SqList *&LC)
{
    int i=0,j=0,k=0;
    LC=(SqList *)malloc(sizeof(SqList));

    // LA和LB均未達(dá)到末尾時，擇其小加入LC
   while(ilength && jlength)
    {
        if(LA->data[i]data[j])
           {
             LC->data[k]=LA->data[i];
             i++;
            }
        else
        {
            LC->data[k]=LB->data[j];
            j++; 
        }
        k++;
    }  

    // LA 尚未掃描完，將其余元素插入LC中
   while(ilength)
    {
        LC->data[k]=LA->data[i];
        i++;
        k++;
     } 

   while(jlength)
    {
        LC->data[k]=LB->data[j];
        j++;
        k++;
    }
}

4、采用單鏈表存放有序表時的歸并算法（將有序鏈表LA和LB中的元素插入到LC中形成一個新的有序鏈表）：

void UnionList1(LinkList *LA,LinkList *LB,LinkList *&LC)
{
    LinkList *pa=LA->next, *pb=LB->next, *r,*s;
    LC=(LinkList *)malloc(sizeof(LinkList));
    r=LC;

    // LA 和 LB 均未達(dá)到末尾時，擇其小優(yōu)先尾插

   while(pa!=NULL && pb!=NULL)
    {
        S=(LinkList *)malloc(sizeof(LinkList));
        if(pa->datadata)
        {
            s->data=pa->data;
            pa=pa->next;
        }
        else
        {
            s->data=pb->data;
            pb=pb->next;
        }
        r->next=s;
        r=s;
     } 

     // LA 未達(dá)到末尾，復(fù)制LA中所有結(jié)點
    while(pa!=NULL)
     {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=pa->data;
        r->next=s;
        r=s;
        pa=pa->next;
      } 

      // LB 未達(dá)到末尾，復(fù)制LA中所有結(jié)點

    while(pb!=NULL)
     {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=pb->data;
        r->next=s;
        r=s;
        pb=pb->next;
      } 
}

棧和隊列

1、棧的判定：

  • ?？眨?top = -1
  • 棧滿： top = MaxSize-1
  • 進(jìn)棧e操作：top ++ ; 將e放在top處
  • 退棧操作：從top處取出元素e; top --;

2、初始化一個空棧s,實際上是將棧頂指針指向-1即可。

// 定義一個順序棧
typedef struct
{
    ElemType data[MaxSize];
        int top;
}SqStack;

void InitStack(SqStack *&s)
{
  s=(SqStack *)malloc(sizeof(SqStack)); // 申請內(nèi)存空間
    s->top=-1;
}

3、釋放棧s占用的空間，銷毀棧：

void DestoryStack(SqStack *&s)
{
    free(s);
}

4、進(jìn)棧操作push(&s,e)

  • 條件：在棧不滿時，可以進(jìn)棧
  • 操作：
    • 將棧指針+1
    • 在該位置上插入元素e
bool Push(SqStack *&s,ElemType e)
{
    if （s->top==MaxSize-1）
        return false;   // 棧滿
        s->top++
        s->data[s->top]=e;
        return true;

}

5、Pop(&s,&e)出棧

  • 條件： 棧不為空
  • 操作：
    • 棧頂元素賦值給e
    • 指針減1
bool Pop(SqStack *&s,ElemType &e)
{

    if (s->top==-1)
            return false;

    e=s->data[s->top];
        s->top--;
        return true;
}

6、用棧判斷對稱串算法

bool summetry(ElemType str[])
{
    int i;
        ElemType e;
        SqStack *st;
        InitStack(st);

        // 將所有元素進(jìn)棧

        for (i=0;str[i]!='\0';i++)
            Push(str,str[i]);

        // 出棧的字符與從左向右讀取的字符串比較

        for(i=0;str[i]!='\0';i++)
        {
        Pop(st,e);
        if(str[i]!=e)
        {
            DestroyStack(st);
                return false;

        }
        }
DestroyStack(st);
return true;

}
棧的鏈?zhǔn)酱鎯Y(jié)構(gòu)

1、棧的鏈?zhǔn)酱鎯?/p>

 *  采用單鏈表： 頭結(jié)點后保存棧頂
 *  優(yōu)點：不存在棧滿上溢的情況
 *  ?？諚l件： s->next=NULL

定義：

typedef struct linknode
{
    ElemType data;
    struct linknode *next;
 }LiStack;

2、建立一個空棧

void InitStack(LiStack *&s)
{
    s=(LiStack *)malloc(sizeof(LiStack));
    s->next=NULL;
 }

3、釋放棧的全部占用空間

 void DetroyStack(LiStack *&s)
 {
    LiStack *p=s, *q=s->next;
   while (q!=NULL)
    {
        free(p);
        p=q;
        q=p->next;
     }
     free(p);
 }

4、判斷棧是否為空

 bool StackEmpty(LiStack *S)
 {
    return(s->next==NULL);
 }

5、進(jìn)棧

 void Push(LiStack *&s,ElemType e)
 {
    LiStack *p;
    p=(LiStack *)malloc(sizeof(LiStack));
    p->data=e;
    p->next=s->next;
    s->next=p;
 }

6、 出棧

 bool Pop(LiStack *&s, ElemType &e)
 {
    LiStack *p;
    if (s->next==NULL)
        return false;
    p=s->next;
    e=p->data;
    s->next=p->next;
    free(p);
    return true;
 }

7、取棧頂元素

 bool GetTop(LiStack *s,ElemType &e)
 {
    if (s->next==NULL)
        return false;
    e=s->next->data;
    return true;
 }
隊列

隊列的數(shù)據(jù)操作：

  • InitQueue(&q): 初始化隊列，構(gòu)造一個新隊列
  • DestroyQueue(&q): 銷毀隊列。
  • QueueEmpty(q):判斷隊列是否為空
  • enQueue(&q,e): 進(jìn)隊列。將元素e進(jìn)隊，作為隊尾元素。
  • deQueue(&q,&e): 出隊列。

隊列的存儲結(jié)構(gòu)：

  • 數(shù)據(jù)元素data : 元素具有同一類型ElemType.最多Maxsize
  • 當(dāng)前隊首： front
  • 當(dāng)前隊尾：rear

定義結(jié)構(gòu)：

typedef struct
{
    ElemType data[MaxSize];
    int front,rear; //隊首和隊尾指針 
 } SqQueue;

1、順序隊的特性

  • 隊空條件： front = rear
  • 隊滿條件： rear = MaxSize - 1
  • 元素e進(jìn)隊： rear ++; data[rear]=e;
  • 元素e出隊： front ++; e=data[front];
  • rear指向隊尾元素
  • front指向隊頭元素的前一個位置

2、初始化隊列

 void InitQueue(SqQueue *&q)
 {
    q=(SqQueue *)malloc(sizeof(SqQueue));
    q->front=q->rear=-1;
  }

3、釋放隊列q所占的存儲空間

  void DestroyQueue(SqQueue *&q)
  {
    free(q);
  }

4、判斷隊列是否為空QueueEmpty

bool QueueEmpty(SqQueue *q)
{
    return(q->front==q->rear);
}

5、進(jìn)隊列

bool enQueue(SqQueue *&q,ElemType e)
{
    if (q->rear==MaxSize-1)
    return false;
    q->rear++
    q->data[q->rear]=e;
    return true;
}

6、出隊列

bool deQueue(SqQueue *&q,ElemType &e)
{
    if (q->front==q->rear)
        return false;
    q->front++;
    e=q->data[q->front];
    return true;
}

提示：順序隊列在滿隊數(shù)據(jù)取完后，在隊空的情況下會出現(xiàn)front==rear&& rear = MaxSize - 1的情況，而出現(xiàn)這種情況后，無法再插入數(shù)據(jù)，這就需要使用環(huán)形隊列。

環(huán)形隊列
  • 隊空條件： front=rear
  • 隊滿條件：（rear+1）%MaxSize=front
  • 進(jìn)隊e操作： rear=(rear+1)%MaxSize; 將e放在rear處
  • 處隊操作：front=(front+1)%MaxSize; 取出front處元素e;

另外有需要云服務(wù)器可以了解下創(chuàng)新互聯(lián)scvps.cn，海內(nèi)外云服務(wù)器15元起步，三天無理由+7*72小時售后在線，公司持有idc許可證，提供“云服務(wù)器、裸金屬服務(wù)器、高防服務(wù)器、香港服務(wù)器、美國服務(wù)器、虛擬主機、免備案服務(wù)器”等云主機租用服務(wù)以及企業(yè)上云的綜合解決方案，具有“安全穩(wěn)定、簡單易用、服務(wù)可用性高、性價比高”等特點與優(yōu)勢，專為企業(yè)上云打造定制，能夠滿足用戶豐富、多元化的應(yīng)用場景需求。


網(wǎng)站題目：數(shù)據(jù)結(jié)構(gòu)基礎(chǔ)（一）-創(chuàng)新互聯(lián)
分享網(wǎng)址：http://weahome.cn/article/dcisoj.html

其他資訊

在線咨詢

微信咨詢

電話咨詢

028-86922220（工作日）

18980820575（7×24）

提交需求

返回頂部