數據結構基礎（一）
線性表
線性順序表
一、線性表的數據操做node
二、使用定義的函數實現兩個集合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<ListLength(LB);i++)
{
GetElem(LB,i,e);
if (!LocateElem(LA,e))
ListInsert(LC,++lena,e);
}
}
三、順序表存儲類型的定義數據結構
# define MaxSize 50
typedef struct
{
ElemType date[MaxSize];
int length;
}SqList;
四、建立線性表ide
void CreateList(Sqlist *&L,ElemType a[],int n)
{
int i;
L=(SqList *)malloc(sizeof(SqList));
// malloc 至關於new,分配SqList大小的內存空間，指向SqLost的指針，並將地址賦值給L
for (i=0;i<n;i++)
L->data[i]=a[i];
L->length=n;
}
五、初始化線性表函數
void InitList(SqList *&L) // 應用指針
{
L=(SqList *)malloc(sizeof(SqList));
L->length=0; // 初始化線性表的長度
}
六、銷燬線性表指針
void DestroyList(SqlList *&L)
{
free(L);
}
七、判斷線性表是否爲空code
bool ListEmpty(SqList *L)
{
return(L->length==0);
}
八、求線性表的長度blog
int ListLength(SqList *L)
{
return(L->length);
}
九、輸出線性表遞歸
void DispList(SqList *L)
{
int i;
if (ListEmpty(L))
return;
for (i=0;i<L->length;i++)
printf("%d ",L->data[i]);
printf("\n");
}
十、求某個數據元素的值，返回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;
}
十一、按元素值查找
int LocateElem(L,e)
{
int i = 0;
while (i<L->length && L->data[i]!=e)
i++;
if (i>=L->length)
return 0;
else
return i+1;
}
十二、插入元素
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;
}
1三、刪除元素
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;j<L->length-1;j++)
L->data[j]=L->data[j+1];
L->length--;
return true;
}
線性鏈表
一、單鏈表的存儲結構的定義
typedef struct LNode // 定義單鏈表節點類型
{
ElemType data; //數據域
struct LNode *next; //指針域，指向後繼節點 遞歸結構
}LinkList;
二、單鏈表的頭插法：
void CreateListF(LinkList *&L,ElemType a[],int n)
{
LinkList *S;
int i;
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
S=(LinkList *)malloc(sizeof(LinkList));
S->data=a[i];
S->next=L->next;
L->next=S;
}
}
三、單鏈表尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
LinkList *s,*r;
int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
四、單鏈表的基本操做
五、初始化線性表
void InitList(LinkList *&L)
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}
六、銷燬線性表
void DestroyList(LinkList *&L)
{
LinkList *pre=L,*p=L->next;
while (p=NULL)
{
free(pre);
pre=p;
p=pre->next;
}
free(pre);
}
七、判斷表爲空
bool ListEmpty(LinkList *L)
{
return(L->next==NULL);
}
八、求線性表的ListLength(L)
int ListLength(LinkList *L)
{
int n=0;
LinkList *p=L;
while (p->next!=NULL)
{
n++;
p=p->next;
}
return(n);
}
九、輸出線性表：
void DisList(LinkList *L)
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%d",p->data);
p=p->next;
}
printf("\n")
}
十、查找某個元素
bool GetElem(LinkList *L,int i,ElemType &e)
{
int j=0;
LinkList *p=L;
while (j<i&&p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)
return false;
else
{
e=p->data;
return true;
}
}
十一、 按元素查找，返回元素的位置
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;
}
十二、插入數據元素：
bool ListInsert(LinkList *&L,int i,ElemType e){
int j=0;
LinkList *p=L,*S;
while (j<i-1 && p!=NULL){
j++;
p=p->next;
}
if (p==NULL)
return false;
else{
S=LinkList *)malloc(sizeof(LinkList));
S->data=e;
S->next=p->next;
p->next=S;
return true;
}
}
1三、刪除數據元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
int j=0;
LinkList *p=L,*q;
while(j<i-1 && p!=NULL){
j++;
p=p->next;
}
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;
}
}
雙鏈表
一、雙向鏈表的定義和存儲結構
typedef struct DNode
{
ElemType data;
struct DNode *prior;
struct DNode *next;
}DLinkList;
二、頭插法創建雙鏈表
{
DLinkList *S;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList));
L->prior=L->next=NULL;
for(i=0;i<n;i++)
{
S=(DLinkList *)malloc(sizeof(DLinkList));
S->data=a[i];
S->next=L->next;
if(L->next!=NULL)
L->next->prior=S;
L->next=S;
S->prior=L;
}
}
三、尾插法創建雙鏈表
void CreateListR(DLinkList *&L,ElemType a[],int n)
{
DLinkList *s,*r;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList));
r=L;
for (i=0;i<n;i++)
{
s=(DLinkList *)malloc(sizeof(DLinkList));
s->data=a[i];
r->next=s;
s->prior=r;
r=s;
}
r->next=NULL;
}
四、插入節點：
bool ListInsert(DLinkList *&L,int i,ElemType e)
{
int j=0;
DLinkList *p=L,*s;
while(j<i-1 && p!=NULL)
{
j++;
p=p->next;
}
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;
}
}
五、雙鏈表刪除節點
bool ListDelete(DLinkList *&L,int i,ElemType &e)
{
int j=0;
DLinkList *p=L, *q;
while (j<i-1 && p!=NULL)
{
j++;
p=p->next;
}
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;
}
}
有序表的操做
一、有序順序表的插入操做：
void ListInsert(SqList *&L,ElemType e)
{
int i =0,j;
while (i<L->length && L->data[i]<e)
i++;
for (j=ListLength(L);j>i;j--)
L->data[j]=L->data[j-1];
L->data[i]=e;
L->length++;
}
二、有序鏈表的插入操做：
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;
}
三、採用順序表存放有序表時的歸併算法（將順序表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均未達到末尾時，擇其小加入LC
while(i<LA->length && j<LB->length)
{
if(LA->data[i]<LB->data[j])
{
LC->data[k]=LA->data[i];
i++;
}
else
{
LC->data[k]=LB->data[j];
j++;
}
k++;
}
// LA 還沒有掃描完，將其他元素插入LC中
while(i<LA->length)
{
LC->data[k]=LA->data[i];
i++;
k++;
}
while(j<LB->length)
{
LC->data[k]=LB->data[j];
j++;
k++;
}
}
四、採用單鏈表存放有序表時的歸併算法（將有序鏈表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 均未達到末尾時，擇其小優先尾插
while(pa!=NULL && pb!=NULL)
{
S=(LinkList *)malloc(sizeof(LinkList));
if(pa->data<pb->data)
{
s->data=pa->data;
pa=pa->next;
}
else
{
s->data=pb->data;
pb=pb->next;
}
r->next=s;
r=s;
}
// LA 未達到末尾，複製LA中全部結點
while(pa!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=pa->data;
r->next=s;
r=s;
pa=pa->next;
}
// LB 未達到末尾，複製LA中全部結點
while(pb!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=pb->data;
r->next=s;
r=s;
pb=pb->next;
}
}
棧和隊列
一、棧的斷定：
- 棧空： top = -1
- 棧滿： top = MaxSize-1
- 進棧e操做：top ++ ; 將e放在top處
- 退棧操做：從top處取出元素e; top --;
二、初始化一個空棧s,其實是將棧頂指針指向-1便可。
// 定義一個順序棧
typedef struct
{
ElemType data[MaxSize];
int top;
}SqStack;
void InitStack(SqStack *&s)
{
s=(SqStack *)malloc(sizeof(SqStack)); // 申請內存空間
s->top=-1;
}
三、釋放棧s佔用的空間，銷燬棧：
void DestoryStack(SqStack *&s)
{
free(s);
}
四、進棧操做push(&s,e)
- 條件：在棧不滿時，能夠進棧
- 操做：
- 將棧指針+1
- 在該位置上插入元素e
bool Push(SqStack *&s,ElemType e)
{
if （s->top==MaxSize-1）
return false; // 棧滿
s->top++
s->data[s->top]=e;
return true;
}
五、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;
}
六、用棧判斷對稱串算法
bool summetry(ElemType str[])
{
int i;
ElemType e;
SqStack *st;
InitStack(st);
// 將全部元素進棧
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;
}
棧的鏈式存儲結構
一、棧的鏈式存儲
* 採用單鏈表： 頭結點後保存棧頂 * 優勢：不存在棧滿上溢的狀況 * 棧空條件： s->next=NULL
定義：
typedef struct linknode
{
ElemType data;
struct linknode *next;
}LiStack;
二、創建一個空棧
void InitStack(LiStack *&s)
{
s=(LiStack *)malloc(sizeof(LiStack));
s->next=NULL;
}
三、釋放棧的所有佔用空間
void DetroyStack(LiStack *&s)
{
LiStack *p=s, *q=s->next;
while (q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
四、判斷棧是否爲空
bool StackEmpty(LiStack *S)
{
return(s->next==NULL);
}
五、進棧
void Push(LiStack *&s,ElemType e)
{
LiStack *p;
p=(LiStack *)malloc(sizeof(LiStack));
p->data=e;
p->next=s->next;
s->next=p;
}
六、 出棧
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;
}
七、取棧頂元素
bool GetTop(LiStack *s,ElemType &e)
{
if (s->next==NULL)
return false;
e=s->next->data;
return true;
}
隊列
隊列的數據操做：
- InitQueue(&q): 初始化隊列，構造一個新隊列
- DestroyQueue(&q): 銷燬隊列。
- QueueEmpty(q):判斷隊列是否爲空
- enQueue(&q,e): 進隊列。將元素e進隊，做爲隊尾元素。
- deQueue(&q,&e): 出隊列。
隊列的存儲結構：
- 數據元素data : 元素具備同一類型ElemType.最多Maxsize
- 當前隊首： front
- 當前隊尾：rear
定義結構：
typedef struct
{
ElemType data[MaxSize];
int front,rear; //隊首和隊尾指針
} SqQueue;
一、順序隊的特性
- 隊空條件： front = rear
- 隊滿條件： rear = MaxSize - 1
- 元素e進隊： rear ++; data[rear]=e;
- 元素e出隊： front ++; e=data[front];
- rear指向隊尾元素
- front指向隊頭元素的前一個位置
二、初始化隊列
void InitQueue(SqQueue *&q)
{
q=(SqQueue *)malloc(sizeof(SqQueue));
q->front=q->rear=-1;
}
三、釋放隊列q所佔的存儲空間
void DestroyQueue(SqQueue *&q)
{
free(q);
}
四、判斷隊列是否爲空QueueEmpty
bool QueueEmpty(SqQueue *q)
{
return(q->front==q->rear);
}
五、進隊列
bool enQueue(SqQueue *&q,ElemType e)
{
if (q->rear==MaxSize-1)
return false;
q->rear++
q->data[q->rear]=e;
return true;
}
六、出隊列
bool deQueue(SqQueue *&q,ElemType &e)
{
if (q->front==q->rear)
return false;
q->front++;
e=q->data[q->front];
return true;
}
提示：順序隊列在滿隊數據取完後，在隊空的狀況下會出現front==rear&& rear = MaxSize - 1的狀況，而出現這種狀況後，沒法再插入數據，這就須要使用環形隊列。
環形隊列
- 隊空條件： front=rear
- 隊滿條件：（rear+1）%MaxSize=front
- 進隊e操做： rear=(rear+1)%MaxSize; 將e放在rear處
- 處隊操做：front=(front+1)%MaxSize; 取出front處元素e;
相關文章
- 1. 數據結構基礎（一）
- 2. 數據結構系列之基礎篇（一）數據與結構
- 3. java_數據結構（一）數據結構與算法基礎
- 4. 數據結構與算法（一）——數據結構基礎知識
- 5. 數據結構（一）算法基礎
- 6. Redis(一)——基礎數據結構
- 7. 數據結構基礎知識（一）
- 8. python 語言基礎&數據結構（一)
- 9. 數據結構筆記（一）——基礎
- 10. 數據結構基礎入門(一)
- 更多相關文章...
- • Spring目錄結構和基礎JAR包介紹 - Spring教程
- • Hibernate目錄結構和基礎JAR包介 - Hibernate教程
- • Flink 數據傳輸及反壓詳解
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. python的安裝和Hello，World編寫
- 2. 重磅解讀：K8s Cluster Autoscaler模塊及對應華爲雲插件Deep Dive
- 3. 鴻蒙學習筆記2（永不斷更）
- 4. static關鍵字 和構造代碼塊
- 5. JVM筆記
- 6. 無法啓動 C/C++ 語言服務器。IntelliSense 功能將被禁用。錯誤: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回碼狀態含義
- 8. Java樹形結構遞歸（以時間換空間）和非遞歸（以空間換時間）
- 9. 數據預處理---缺失值
- 10. 都要2021年了，現代C++有什麼值得我們學習的？
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 數據結構基礎（一）
- 2. 數據結構系列之基礎篇（一）數據與結構
- 3. java_數據結構（一）數據結構與算法基礎
- 4. 數據結構與算法（一）——數據結構基礎知識
- 5. 數據結構（一）算法基礎
- 6. Redis(一)——基礎數據結構
- 7. 數據結構基礎知識（一）
- 8. python 語言基礎&數據結構（一)
- 9. 數據結構筆記（一）——基礎
- 10. 數據結構基礎入門(一)