數據結構知識點總結（更新ing）

⭐ 我的網站: www.mengyingjie.com ⭐

1線性表

1.1線性表的基本操作

方法名	含義
InitList(&L)	初始化表。構造一個空的線性表。
Length(L)	求表長。返回線性表L的長度，即L中數據元素的個數。
LocateElem(L,e)	按值查找操作。在表L中查找具有給定關鍵字值的元素。
GetElem(L,i)	按位查找操作。獲取表L中第i個位置的元素的值。
ListInsert(&L,i,e)	插入操作。在表L中的第i個位置上插入指定元素e.
ListDelete (&L,i, &e)	刪除操作。刑除表L中第i個位置的元素，並用e返回刪除元素的值。
PrintList(L)	輸出操作。按前後順序輸出線性表L的所有元素值。
Empty(L)	判空操作。若L爲空表，則返回true,否則返回false.
DestroyList (&L)	銷燬操作。銷燬線性表，並釋放線性表L所佔用的內存空間。

1.2線性表的順序表示

1.2.1順序表的定義

靜態

#define MaxSize 50
typedef struct {
  ElemType data[MaxSize];
  int length;
}SeqList

動態

#define InitSize 100    //表長度的初始定義
typedef struct{
ElemType *data;         //指示動態分配數組的指針
  int MaxSi ze, length;   //數組的最大容量和當前個數
} SeqList;              //動態分配數組順序表的類型定義
//初始化分配語句
L. data= (ElemType* ) malloc (sizeof (ElemType) *InitSize) ;
//C++的初始動態分配語句爲
L.data=new ElemType [InitSize] ;

1.2.2順序表上基本基本操作的實現

插入操作

bool ListInsert (SqList &L, int i, ElemType e) {
//本算法實現將元素e插入到順序表L中第i個位置
  if(i<1I li>L. length+1)  //判斷 i的範圍是否有效
    return false;
  if (L. length>=MaxSize)  //當前存儲空間已滿，不能插入
    return false;
  for (int j=L. length;j>=i;j--) //將第 i個元素及之後的元素後移
    L.data[j]=L.data[j-1] ;
  L.data[i-1]=e;  //在位置i處放入e
  L. length++;  //線性表長度加1
    return true;
}

時間複雜度：
好 O(1) 壞 O(n) 平均 O(n)

刪除操作

bool ListDelete (SqList &L,int i,Elemtype &e) {
//本算法實現刪除順序表L中第i個位置的元素
  if(i<1lli>L.length)  //判斷i的範圍是否有效
    return false;
  e=L.data[i-1];  //將被刪除的元素賦值給e
  for(int j=i;j<L. length;j++)  //將第i個位置後的元素前移
    L.data[j-1]=L.data[j];
  L. length--;  //線性表長度減 1
  return t rue ;
}

時間複雜度：
好O(1) 壞(n) 平均O(n)

按值查詢

int LocateElem (SqList L, ElemType e) {  
//本算法實現查找順序表中值爲e的元素，如果查找成功，返回元素位序，否則返回0
  int i;
  for(i=0; i<L. length; i++)
    if(L.data[i]==e)
      return i+1 ;  //下標爲i的元素值等於e,返回其位序i+1
  return 0;  //退出循環，說明查找失敗

時間複雜度：
好O(1) 壞O(n) 平均O(n)

1.3線性表的鏈式表示

1.3.1 單鏈表的基本操作的實現

單鏈表的定義

typedef struct LNode {
//定義單鏈表結點類型
  ElemType data;  //數據域
  struct LNode  *next ;  //指針域
}LNode, *LinkList;

採用頭插法建立單鏈表

LinkList List_HeadInsert (LinkList &L) {
//從表尾到表頭逆向建立單鏈表L,每次均在頭結點之,後插入元素
  LNode *s;int x;
  L= (LinkList) malloc (sizeof (LNode)) ;  //創建頭結點
  L->next=NULL;  //初始爲空鏈表
  scanf ("&d", &X) ;  //輸入結點的值
  while(x!=9999) {  //輸入9999表示結束
    s= (LNode* ) malloc (si zeof (LNode) ) ;  //創建新結點
    s->data=x;
    s->next=L->next;
    L->next=s;  //將新結點插入表中，L爲頭指針
    scanf ("&d",&x) ;
  }
  return L;
}

每個結點時間複雜度爲O(1) n個元素爲O(n)

採用尾插法建立單鏈

LinkList List_TailInsert (LinkList &L) {
//從表頭到表尾正向建立單鏈表L,每次均在表尾插入元素
  int x;  // 設元素類型爲整型
  L= (LinkList) malloc (sizeof (LNode) ) ;
  LNode *s, r=L;//r爲表尾指針
  scanf ("%d",&x) ;  //輸入結點的值
  while (x!=9999) {  //輸入9999表示結束
    s = (LNode *) malloc (sizeof (LNode)) ;
    s->data=x;
    r->next=s;
    r=S;  //r指向新的表尾結點
    scanf ("號d",&x) ;
    r->next =NULL;  //尾結 點指針置空
  }
  return L;
}

時間複雜度與頭插法一樣

按序號查找結點值

LNode *GetElem(LinkList L,int i) {
//本算法取出單鏈表L (帶頭結點)中第i個位置的結點指針
  int j=1;  //計數，初始爲1
  LNode p=L->next;  //頭結點指針賦給p
  if(i==0)
    return L;  //若i等於0，則返回頭結點
  if(i<1)
    return NULL;  //若i無效，則返回NULL
  while (p&&j<i) {  //從第1個結點開始找，查找第i個結點
    p=p->next;
    j++;
  }
return p;  //返回第i個結點的指針，如果i大於表長，直接返回P即可

時間複雜度O(n)

按值查找表結點

LNode *LocateElem (LinkList L, ElemType e) {
//本算法查找單鏈表L (帶頭結點)中數據域值等於e的結點指針，否則返回NULL
  LNode *p=L->next;
  while (p!=NULL&&p->data!=e)   //從第 1個結點開始查找data域爲e的結點
    p=p->next;
  return p;  //找到後返回該結點指針，否則返回NULL
}

時間複雜度O(n)

插入結點操作

p = GetElem(L,i-1);  //查找插入位置的前驅結點
s->next = p->next;  //圖2.7中操作步驟1
p->next = s;  //圖2.7中操作步驟2

刪除結點操作

p = GetElem(L,i-1) ;  // 查找刪除位置的前驅結點
q = p->next;  //令q指向被刪除結點
p->next = q->next  //將*q結點從鏈中“斷開
free (q) ;  //釋放結點的存儲空間

1.3.2雙鏈表的操作的實現

雙鏈表的定義

typedef struct DNode {
//定義雙鏈表結點類型
  ElemType data;  //數據域
  struct DNode *prior, *next;  //前驅和後繼指針
}DNode, *DLinklist;

雙鏈表的插入操作

s->next=p->next;  //將結點*S 插入到結點*p之後
p->next- >prior=s;
s->prior=p;
p->next-s;  

雙鏈表的刪除操作

p->next=q->next;
q->next->prior-p;
free (q) ;  //釋放結點空間

2棧

2.1棧的基本操作

方法名	含義
InitStack(&S):	初始化-一個空棧S。
StackEmpty(S):	判斷一個棧是否爲空，若棧S爲空則返回true,否則返回false.
Push(&S,x):	進棧，若棧S未滿，則將x加入使之成爲新棧頂。
Pop(&S,&x):	出棧，若棧s非空，則彈出棧頂元素，並用x返回。
GetTop(S,&x):	讀棧項元素，若棧S非空，則用x返回棧頂元素。
ClearStack(&S):	銷燬棧，並釋放棧S佔用的存儲空間

(注意，符號“&”是C++特有的，用來表示引用調用，有的書上採用C語言中的指針類型“*”，也可以達到傳址的目的)。

2.2棧的順序存儲結構

2.2.1順序棧的基本方法

定義

#define MaxSize 50  //定義棧中元素的最大個數
typedef struct {
  Elemtype data [MaxSize] ;  //存放棧中元素
  int top;  //棧頂指針
} SqStack;

(1)初始化

void InitStack(SqStack &S) {
  S. top=-1;  //初始化棧頂指針
}

(2)判棧空

bool StackEmpty (SqStack S) {
  if(S. top==-1)  //棧空
    return true;  
  else  //不空
    return false;
}

(3)進棧

bool Push (SqStack &S, ElemType x) {
if (S. top==MaxSize-1)  //棧滿，報錯
  return false;
  S.data[++S. top]=x;  //指針先加1，再入棧
  return true;
}

(4)出棧

bool Pop (SqStack &S,ElemType &X) {
  if (S. top=--1)  //棧空，報錯
  return false;
  x=S.data[s.top--];  //先出棧，指針再減1
  return true;

(5)讀棧頂元素

bool GetTop (SqStack S, ElemType &X) {
  if (S. top---1)  //棧空，報錯
  return false;
  x=S.datals.top ;  //x記錄棧頂元素
  return true;

2.3棧的鏈式存儲結構

2.3.1棧的鏈式存儲結構的實現方法

定義

typedef struct Linknode {
  ElemType data;  //數據域
  struct Linknode *next;  //指針域
} *LiStack;  //棧類型定義  

3隊列

3.1棧的基本操作

方法名	含義
InitQueue (&Q)	初始化隊列，構造一個空隊列Q.
QueueEmpty (Q)	判隊列空，若隊列Q爲空返回true,否則返回false.
EnQueue(&Q,x)	入隊，若隊列Q未滿，將x加入，使之成爲新的隊尾。
DeQueue (&Q, &x)	出隊，若隊列Q非空，刪除隊頭元素，並用x返回。
GetHead (Q, &x)	讀隊頭元素，若隊列Q非空，則將隊頭元素賦值給X。

3.2隊列的順序存儲結構

3.2.1順序隊列基本方法的實現

定義

#define MaxSize 50   //定義隊列中元素的最大個數
typedef struct{
  ElemType data [MaxSize] ;  //存放隊列元素
  int front, rear;  //隊頭指針和隊尾指針
} SqQueue ;

3.2.2循環隊列的基本方法

初始化

void InitQueue (SqQueue &Q) {
  Q.rear=Q.front=0;  //初始化隊首、隊尾指針
}

判隊空

bool isEmpty (SqQueue Q) {
  if (Q.rear==Q.front)
    return true;  //隊空條件
  else return  false;
}

入隊

bool EnQueue (SqQueue &Q, ElemType x) {
  if( (Q.rear+1) SMaxSize==Q.front) return false;  //隊滿
  Q.data [Q.rear] = X;
  Q.rear= (Q.rear+1) MaxSize;  //隊尾指針加1取模
  return true;
}

出隊

bool DeQueue (SqQueue &Q， ElemType &x) {
  if (Q.rear==Q.front) return false;  //隊空，報錯
  x=Q.data[Q. front] ;
  Q.front= (Q.front+1) % MaxSize;  //隊頭指針加1取模
  return true;
}

3.3隊列的鏈式存儲結構

3.3.1鏈式隊列基本方法的實現

定義

typedef struct {   //鏈式隊列結點
  ElemType data;
  struct LinkNode *next ;
}LinkNode ;

typedef struct{  //鏈式隊列
  LinkNode *front, * rear;  //隊列的隊頭和隊尾指針
}LinkQueue;

初始化

void InitQueue (LinkQueue &Q) {
  Q.front->Q.rear= (LinkNode* )malloc (sizeof(LinkNode) );  //建立頭結點
  Q.front->next=NULL;  //初始爲空
}

判隊空

bool IsEmpty (LinkQueue Q) {
  if (Q.front==Q.rear) return true;
  else return false;
}

入隊

void EnQueue (LinkQueue &Q, ElemType x) {
  LinkNode *s= (LinkNode *)malloc (sizeof (LinkNode)) ;
  s->data=x;  s->next=NULL; //創建新結點，插入到鏈尾
  Q.rear->next=s;
  Q.rear=s;
}

出隊

bool DeQueue (LinkQueue &Q, ElemType &x) {
  if (Q.front==Q.rear) return false;//空隊
  LinkNode *p=Q.front ->next;
  x=p->data;
  Q.front- >next=p->next;
  if (Q.rear==p)
  Q.rear=Q.front; //若原隊列中只有一個結點，刪除後變空
  free(p) ;
  return true;
} 

---

ps:
1.給定兩個單鏈表，編寫算法找出兩個鏈表的公共結點。
分析：勿用蠻力，從第一個公共結點以後全是公共結點。

遇到此類問題，但看了文章還是未解決，
評論或加 QQ：781378815