嚴蔚敏版資料結構課本程式碼——演算法2.1

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

 /* main2-8.c 檢驗bo2-8.c的主程式 */
 //#include"c1.h"
  /* c1.h (程式名) */
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()等 */
 #include<limits.h> /* INT_MAX等 */
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */ 

 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* 函式結果狀態程式碼 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 /* #define OVERFLOW -2 因為在math.h中已定義OVERFLOW的值為3,故去掉此行 */
 typedef int Status; /* Status是函式的型別,其值是函式結果狀態程式碼，如OK等 */ 

 typedef int Boolean; /* Boolean是布林型別,其值是TRUE或FALSE */


 typedef int ElemType; /* 也可以定義ElemType為實型或雙精度型 */
 //#include"c2-1.h"
  /* c2-1.h 線性表的動態分配順序儲存結構 */
 #define LIST_INIT_SIZE 10 /* 線性表儲存空間的初始分配量 */
 #define LISTINCREMENT 2 /* 線性表儲存空間的分配增量 */
 typedef struct
 {
   ElemType *elem; /* 儲存空間基址 */
   int length; /* 當前長度 */ 

   int listsize; /* 當前分配的儲存容量(以sizeof(ElemType)為單位) */
 }SqList;

 //#include"bo2-8.c"
  /* bo2-8.c 順序表示的線性表(儲存結構由c2-1.h定義)的擴充套件操作(10個) */
// #include"bo2-1.c"
 /* bo2-1.c 順序表示的線性表(儲存結構由c2-1.h定義)的基本操作(12個) */
 Status InitList(SqList *L) /* 演算法2.3 */
 { /* 操作結果：構造一個空的順序線性表 */
   (*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
   if(!(*L).elem)
     exit(OVERFLOW); /* 儲存分配失敗 */
   (*L).length=0; /* 空表長度為0 */
   (*L).listsize=LIST_INIT_SIZE; /* 初始儲存容量 */
   return OK;
 }

 Status DestroyList(SqList *L)
 { /* 初始條件：順序線性表L已存在。操作結果：銷燬順序線性表L */
   free((*L).elem);
   (*L).elem=NULL;
   (*L).length=0;
   (*L).listsize=0;
   return OK;
 }

 Status ClearList(SqList *L)
 { /* 初始條件：順序線性表L已存在。操作結果：將L重置為空表 */
   (*L).length=0;
   return OK;
 }

 Status ListEmpty(SqList L)
 { /* 初始條件：順序線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE */
   if(L.length==0)
     return TRUE;
   else
     return FALSE;
 }

 int ListLength(SqList L)
 { /* 初始條件：順序線性表L已存在。操作結果：返回L中資料元素個數 */
   return L.length;
 }

 Status GetElem(SqList L,int i,ElemType *e)
 { /* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
   /* 操作結果：用e返回L中第i個數據元素的值 */
   if(i<1||i>L.length)
     exit(ERROR);
   *e=*(L.elem+i-1);
   return OK;
 }

 int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
 { /* 初始條件：順序線性表L已存在，compare()是資料元素判定函式(滿足為1,否則為0) */
   /* 操作結果：返回L中第1個與e滿足關係compare()的資料元素的位序。 */
   /*           若這樣的資料元素不存在，則返回值為0。演算法2.6 */
   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;
 }

 Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
 { /* 初始條件：順序線性表L已存在 */
   /* 操作結果：若cur_e是L的資料元素，且不是第一個，則用pre_e返回它的前驅， */
   /*           否則操作失敗，pre_e無定義 */
   int i=2;
   ElemType *p=L.elem+1;
   while(i<=L.length&&*p!=cur_e)
   {
     p++;
     i++;
   }
   if(i>L.length)
     return INFEASIBLE;
   else
   {
     *pre_e=*--p;
     return OK;
   }
 }

 Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
 { /* 初始條件：順序線性表L已存在 */
   /* 操作結果：若cur_e是L的資料元素，且不是最後一個，則用next_e返回它的後繼， */
   /*           否則操作失敗，next_e無定義 */
   int i=1;
   ElemType *p=L.elem;
   while(i<L.length&&*p!=cur_e)
   {
     i++;
     p++;
   }
   if(i==L.length)
     return INFEASIBLE;
   else
   {
     *next_e=*++p;
     return OK;
   }
 }

 Status ListInsert(SqList *L,int i,ElemType e) /* 演算法2.4 */
 { /* 初始條件：順序線性表L已存在，1≤i≤ListLength(L)+1 */
   /* 操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加1 */
   ElemType *newbase,*q,*p;
   if(i<1||i>(*L).length+1) /* i值不合法 */
     return ERROR;
   if((*L).length>=(*L).listsize) /* 當前儲存空間已滿,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 儲存分配失敗 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LISTINCREMENT; /* 增加儲存容量 */
   }
   q=(*L).elem+i-1; /* q為插入位置 */
   for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之後的元素右移 */
     *(p+1)=*p;
   *q=e; /* 插入e */
   ++(*L).length; /* 表長增1 */
   return OK;
 }

 Status ListDelete(SqList *L,int i,ElemType *e) /* 演算法2.5 */
 { /* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
   /* 操作結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1 */
   ElemType *p,*q;
   if(i<1||i>(*L).length) /* i值不合法 */
     return ERROR;
   p=(*L).elem+i-1; /* p為被刪除元素的位置 */
   *e=*p; /* 被刪除元素的值賦給e */
   q=(*L).elem+(*L).length-1; /* 表尾元素的位置 */
   for(++p;p<=q;++p) /* 被刪除元素之後的元素左移 */
     *(p-1)=*p;
   (*L).length--; /* 表長減1 */
   return OK;
 }

 Status ListTraverse(SqList L,void(*vi)(ElemType*))
 { /* 初始條件：順序線性表L已存在 */
   /* 操作結果：依次對L的每個資料元素呼叫函式vi()。一旦vi()失敗，則操作失敗 */
   /*           vi()的形參加'&'，表明可通過呼叫vi()改變元素的值 */
   ElemType *p;
   int i;
   p=L.elem;
   for(i=1;i<=L.length;i++)
     vi(p++);
   printf("\n");
   return OK;
 }


 void InsertAscend(SqList *L,ElemType e)
 { /* 初始條件：按非降序排列的順序線性表L已存在 */
   /* 操作結果：在L中按非降序插入新的資料元素e，L的長度加1 */
   ElemType *newbase,*p;
   int k;
   if((*L).length>=(*L).listsize) /* 當前儲存空間已滿,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 儲存分配失敗 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LISTINCREMENT; /* 增加儲存容量 */
   }
   p=(*L).elem;
   for(k=1;k<=(*L).length;k++)
     if(e>*p)
       p++;
     else
       break;
   ListInsert(L,k,e); /* 函式在bo2-1.c中 */
 }

 void InsertDescend(SqList *L,ElemType e)
 { /* 初始條件：按非升序排列的順序線性表L已存在 */
   /* 操作結果：在L中按非升序插入新的資料元素e，L的長度加1 */
   ElemType *newbase,*p;
   int k;
   if((*L).length>=(*L).listsize) /* 當前儲存空間已滿,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 儲存分配失敗 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LISTINCREMENT; /* 增加儲存容量 */
   }
   p=(*L).elem;
   for(k=1;k<=(*L).length;k++)
     if(e<*p)
       p++;
     else
       break;
   ListInsert(L,k,e); /* 函式在bo2-1.c中 */
 }

 Status HeadInsert(SqList *L,ElemType e)
 { /* 初始條件：順序線性表L已存在。操作結果：在L的頭部插入新的資料元素e，L的長度加1 */
   ElemType *p,*q,*newbase;
   if((*L).length>=(*L).listsize)
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW);
     (*L).elem=newbase;
     (*L).listsize+=LISTINCREMENT;
   }
   q=(*L).elem;
   for(p=(*L).elem+(*L).length-1;p>=q;--p)
     *(p+1)=*p;
   *q=e;
   (*L).length++;
   return OK;
 }

 Status EndInsert(SqList *L,ElemType e)
 { /* 初始條件：順序線性表L已存在。操作結果：在L的尾部插入新的資料元素e，L的長度加1 */
   ElemType *q,*newbase;
   if((*L).length>=(*L).listsize) /* 當前儲存空間已滿,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 儲存分配失敗 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LISTINCREMENT; /* 增加儲存容量 */
   }
   q=(*L).elem+(*L).length; /* q為插入位置 */
   *q=e;
   (*L).length++;
   return OK;
 }

 Status DeleteFirst(SqList *L,ElemType *e)
 { /* 初始條件：順序線性表L已存在，且有不少於1個元素 */
   /* 操作結果：刪除L的第一個資料元素，並由e返回其值，L的長度減1 */
   ElemType *p,*q;
   if(ListEmpty(*L)) /* 空表無法刪除 */
     return ERROR;
   p=(*L).elem; /* p指向第一個元素 */
   *e=*p;
   q=(*L).elem+(*L).length-1; /* q指向最後一個元素 */
   for(++p;p<=q;++p)
     *(p-1)=*p; /* 從第2個元素起，所有元素向前移動一個位置 */
   (*L).length--; /* 當前長度減1 */
   return OK;
 }

 Status DeleteTail(SqList *L,ElemType *e)
 { /* 初始條件：順序線性表L已存在，且有不少於1個元素 */
   /* 操作結果：刪除L的最後一個數據元素，並用e返回其值，L的長度減1 */
   ElemType *p;
   if(!(*L).length) /* 空表 */
     return ERROR;
   p=(*L).elem+(*L).length-1; /* 最後一個數據元素的位置 */
   *e=*p; /* 被刪除元素的值賦給e */
   (*L).length--; /* 表長減1 */
   return OK;
 }

 Status DeleteElem(SqList *L,ElemType e)
 { /* 刪除表中值為e的元素，並返回TRUE；如無此元素，則返回FALSE */
   int i=0,j;
   while(i<(*L).length&&e!=*((*L).elem+i))
     i++;
   if(i==(*L).length) /* 沒找到 */
     return FALSE;
   else
   {
     for(j=i;j<(*L).length;j++)
       *((*L).elem+j)=*((*L).elem+j+1); /* 後面的元素依次前移 */
     (*L).length--; /* 當前長度減1 */
     return TRUE;
   }
 }

 Status ReplaceElem(SqList L,int i,ElemType e)
 { /* 用e取代表L中第i個元素的值 */
   if(i<1||i>L.length) /* i值不合法 */
     exit(ERROR);
   *(L.elem+i-1)=e;
   return OK;
 }

 Status CreatAscend(SqList *L,int n)
 { /* 按非降序建立n個元素的線性表 */
   int i,j;
   ElemType e;
   InitList(L);
   printf("請輸入%d個元素:\n",n);
   scanf("%d",&e);
   ListInsert(L,1,e); /* 在空表中插入第1個元素 */
   for(i=1;i<n;i++)
   {
     scanf("%d",&e);
     for(j=0;j<(*L).length;j++)
       if(e<=*((*L).elem+j))
         break;
     ListInsert(L,j+1,e); /* 插於表中 */
   }
   return TRUE;
 }

 Status CreatDescend(SqList *L,int n)
 { /* 按非升序建立n個元素的線性表 */
   int i,j;
   ElemType e;
   InitList(L);
   printf("請輸入%d個元素:\n",n);
   scanf("%d",&e);
   ListInsert(L,1,e); /* 在空表中插入第1個元素 */
   for(i=1;i<n;i++)
   {
     scanf("%d",&e);
     for(j=0;j<(*L).length;j++)
       if(e>=*((*L).elem+j))
         break;
     ListInsert(L,j+1,e); /* 插於表中 */
   }
   return TRUE;
 }


 void visit(ElemType *c) /* ListTraverse()呼叫的函式(型別要一致) */
 {
   printf("%d ",*c);
 }

 int main()
 {
   SqList L;
   ElemType d,e;
   Status i;
   int n;
   printf("按非降序建立n個元素的線性表L,請輸入元素個數n: ");
   scanf("%d",&n);
   CreatAscend(&L,n);
   printf("依次輸出L的元素：");
   ListTraverse(L,visit);
   InsertAscend(&L,10); /* 按非降序插入元素10 */
   printf("按非降序插入元素10後，線性表L為：");
   ListTraverse(L,visit);
   HeadInsert(&L,12); /* 在L的頭部插入12 */
   EndInsert(&L,9); /* 在L的尾部插入9 */
   printf("在L的頭部插入12，尾部插入9後，線性表L為：");
   ListTraverse(L,visit);
   printf("請輸入要刪除的元素的值: ");
   scanf("%d",&e);
   i=DeleteElem(&L,e);
   if(i)
     printf("成功刪除%d\n",e);
   else
     printf("不存在元素%d!\n",e);
   printf("線性表L為：");
   ListTraverse(L,visit);
   printf("請輸入要取代的元素的序號 元素的新值: ");
   scanf("%d%d",&n,&e);
   ReplaceElem(L,n,e);
   printf("線性表L為：");
   ListTraverse(L,visit);
   DestroyList(&L);
   printf("銷燬L後,按非升序重新建立n個元素的線性表L,請輸入元素個數n(>2): ");
   scanf("%d",&n);
   CreatDescend(&L,n);
   printf("依次輸出L的元素：");
   ListTraverse(L,visit);
   InsertDescend(&L,10); /* 按非升序插入元素10 */
   printf("按非升序插入元素10後，線性表L為：");
   ListTraverse(L,visit);
   printf("請輸入要刪除的元素的值: ");
   scanf("%d",&e);
   i=DeleteElem(&L,e);
   if(i)
     printf("成功刪除%d\n",e);
   else
     printf("不存在元素%d!\n",e);
   printf("線性表L為：");
   ListTraverse(L,visit);
   DeleteFirst(&L,&e);
   DeleteTail(&L,&d);
   printf("刪除表頭元素%d和表尾元素%d後,線性表L為：\n",e,d);
   ListTraverse(L,visit);
 }

嚴蔚敏版資料結構課本程式碼——演算法2.1

/* main2-8.c 檢驗bo2-8.c的主程式 */ //#include"c1.h" /* c1.h (程式名) */ #include<string.h> #include<ctype.h> #include<

嚴蔚敏版資料結構課本程式碼——演算法2.2

/* algo2-2.c 實現演算法2.2的程式 */ //#include"c1.h" /* c1.h (程式名) */ #include<string.h> #include<ctype.h> #include<m

嚴蔚敏版資料結構課本程式碼——非降序線性表（BUCT-JK1602-LLP）

/* main2-9.c 檢驗bo2-9.c的主程式(除輸出語句外，和main2-8.c很像) */ //#include"c1.h" /* c1.h (程式名) */ #include<string.h> #include<cty

嚴蔚敏版資料結構——佇列（連結串列實現）

佇列有兩種表示方式，我們再看連結串列實現：個人感覺佇列也就是連結串列的一種特殊表，如果前面的連結串列知識通關了這裡隨便看看記住佇列的遊戲規則就行了。還是和前面一樣，先要有頭結點，總體來說就是單鏈表的插刪。這裡與順序佇列不同的是不需要判斷佇列是不是滿了，連結串列最大的特點是動態分配節點空間

嚴蔚敏版資料結構——鏈隊（佇列的鏈式實現）

其實這節的內容也是單鏈表的特殊操作，這裡要記住的是頭指標被front 指但是它不是隊頭，front->next（首元結點）才是隊頭。咱們看程式碼吧！ #include<stdio.h> #include<malloc.h> #def

嚴蔚敏版資料結構——佇列（順序表表示）

佇列有兩種表示方式，我們先看順序表示：程式碼中的rear（尾指標）與front（頭指標）都是int 型的，它的作用就是做陣列下標，我們習慣稱它為指標，這裡應該注意它不是指標型別。頭指標始終指向佇列頭元素，尾指標始終指向隊尾元素的下一個位置。由於增加元素rear加一，刪除元素fr

嚴蔚敏版資料結構——順序棧

其實也是順序表的一種特殊的操作，實際操作個人覺得要比順序表還簡單。上程式碼看看： #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 typedef struct { int *base

嚴蔚敏版資料結構——單鏈表

嚴蔚敏版資料結構——單鏈表的操作記得前上個禮拜，我寫過的一個版本的單鏈表的建立。今天寫下了這個嚴蔚敏版的單鏈表。梳理了一下思路，其基本演算法還是一樣的，還是那句話，理解，理解，理解最重要。這個版本的單鏈表我要提醒自己的是：1、這是直接在函式中採用引用L

嚴蔚敏版資料結構—順序表

嚴蔚敏版資料結構是本好書！少廢話咯，直接上程式碼研究吧！程式碼不難，重在理解 #include<stdio.h> #include<stdlib.h> #include<string.h> #define OK 1 #define

嚴蔚敏版資料結構學習筆記（4）：佇列

和上次的棧相反，佇列是一種先進獻出的線性表（FIFO）；它只允許在它的一端進行刪除操作，而在另一邊進行插入操作。在佇列裡面，允許插入的一端我們稱之為隊尾，允許刪除的一端稱為隊頭；佇列和棧的基本操作差不多，也有八個，不同的一點是刪除操作是在表的頭部進行而不

嚴蔚敏版資料結構學習筆記（3）：棧

棧是隻能在表尾進行插入和刪除的一種簡單一點的線性表。表尾端是棧頂(top)，表頭端是棧底(bottom)，不含元素的稱為空棧。因為我們只能對棧頂的元素進行插入和刪除操作，所以棧這個資料結構就是一個很有”原則”的結構，棧的修改是按照後進先出的原則進行的，也就是LI

嚴蔚敏版資料結構學習筆記（5）：串

串（string），由字面意思理解就知道是和字串有關的一種資料結構，它是由零個或者多個字元組成的有限序列，一般記為 s = ‘a1a2a3……an’(n>=0); 其中s為串名，用單引號括起來的字元序列是串的值，ai可以是字母，數字，或者是其他字元；

資料結構作業程式碼儲存-2.1 單向迴圈連結串列的建立，插入和刪除，和指標移動

在此感謝我親愛的大神同學們！一個Z妹子講情了思路，一個M妹子提供了更高階的雙向迴圈連結串列的程式碼借鑑（雖然有些還是沒怎麼看懂。。。我的作業就完成啦！儲存程式碼當個紀念！ 1，往操作位置順時針的下一位插入一個元素，並將操作位置移到新元素上。 2，刪掉操作位置順時針方

棧C/C++實現(資料結構嚴蔚敏版)

1、標頭檔案：stack.h#include<iostream> #include<malloc.h> using namespace std; typedef int Status; typedef char ElemType; #define

串知識點詳解（資料結構，嚴蔚敏版）

1.堆分配儲存表示（也是一種順序表） typedef struct{ char *ch; int length; }HString; 2.串操作函式 //初始化一個串 void InitalStr(HString &T); //生成一個其值等於串常量chars

順序儲存線性表的C++實現——嚴蔚敏版《資料結構》

因為最近在拿嚴蔚敏版的《資料結構》複習相關知識，所以就通過動手實現來加深理解，在這裡與大家分享。話不多說，直接上程式碼，註釋比較詳細，就不另外解說了。首先是List_Sq.h，這裡使用了類模板以及函式模板，便於將該順序線性表使用在不同的基本資料型別

C語言-單鏈表的基本操作-嚴蔚敏版的資料結構

以下部分是標頭檔案 #ifndef __LianBiao__ #define __LianBiao__ typedef int ElemType; typedef struct LNode { int data; struct LNode

資料結構演算法實現（嚴蔚敏版）目錄

資料結構演算法實現（嚴蔚敏版配套實現程式）目錄: 第1章緒論1.1 什麼是資料結構1.2 基本概念和術語1.3 抽象資料型別的表現與實現1.4 演算法和演算法分析第2章線性表2.1 線性表的型別定義2.2 線性表的順序表示和實現2.3 線性表的鏈式表示和實現2.4 一元

資料結構 C語言嚴蔚敏版演算法2.1

//已知線性表La和Lb的資料元素按值非遞減有序排列，現要求將La和Lb歸併為一個新的線性表Lc，且Lc中的資料元素仍按值非遞減有序排列。 #include <stdio.h> #include <stdlib.h> #include <ma

[資料結構] 嚴蔚敏版線索二叉樹C語言----驚為天人的按線索遍歷演算法

自己完全寫不來，只能品一品其中的韻味。 #ifndef THREADBINARYTREE_H #define THREADBINARYTREE_H #include <stdio.h> #include <stdlib.h> #include

嚴蔚敏版資料結構課本程式碼——演算法2.1

相關推薦