1 //基於鄰接表
 2 struct vertexnode
 3 {
 4     int vertex;
 5    edgenode * firstedge;
 6 };
 7 struct edgenode
 8 {
 9     int adjvex;
10     edgenode *next;
11 };
12 struct vertexnode adjlist[100];
13 int visited[100];
14 void  GS(int a[], int n, int e)
15 {
16     int i, k,j;
17     for (i=0;i<n;++i)
18     {
 
19         adjlist[i].vertex = a[i];
20         adjlist[i].firstedge = NULL;
21     }
22     for (k = 0; k < e; k++)
23     {
24         cin >> i >> j;
25         edgenode* s = new edgenode;
26         s->adjvex = j;
27         s->next = adjlist[i].firstedge;
28         adjlist[j].firstedge = s;
 
29     }
30 }
31 void DFS(int v)
32 {
33     cout << adjlist[v].vertex; visited[v] = 1;
34     edgenode *p = adjlist[v].firstedge;
35     while (p!=NULL)
36     {
37         int j = p->adjvex;
38         if (visited[j]==0)
39         {
40             DFS(j);
41         }
42         p = p->next;
 
43     }
44 }
45 void BFS(int v)
46 {
47     int front = -1, rear = -1;
48     int Q[100];
49     cout << adjlist[v].vertex; visited[v] = 1; Q[++rear] = v;
50     while (front!=-1)
51     {
52         v = Q[++front];
53         edgenode *p = adjlist[v].firstedge;
54         while (p!=NULL)
55         {
56             int j;
57             j=p->adjvex;
58             if (visited[v]==0)
59             {
60                 cout << adjlist[j].vertex; visited[j] = 1; Q[++rear] = j;
61             }
62             p=p->next;
63         }
64     }
65 }

 1 //基於鄰接矩陣
 2 int vertex[100];
 3 int edge[100][100];
 4 int visited[100];
 5 int n = 10, e = 10;
 6 void GZ(int a[], int n, int e)
 7 {
 8     int i, j, k;
 9     for (i=0;i<n;++i)
10     {
11         vertex[i] = a[i];
12     }
13     for (i = 0; i < n; ++i)
14     {
15         for (j=0;j<n;++j)
16         {
17             edge[i][j] = 0;
18         }
19     }
20     for (k=0;k<e;++k)
21     {
22         cin >> i >> j;
23         edge[i][j] = 1;
24         edge[j][i] = 1;
25     }
26 }
27 void DFS(int v)
28 {
29     int i;
30     cout << vertex[v]; visited[v] = 1;
31     for (i=0;i<n;++i)
32     {
33         if (edge[v][i]==1&&visited[i]==0)
34         {
35             DFS(i);
36         }
37     }
38 }
39 void BFS(int v)
40 {
41     int front = -1, rear = -1, i, j, Q[100];
42     cout << vertex[v]; visited[v] = 1; Q[++rear] = v;
43     while (front!=rear)
44     {
45         v = Q[++front];
46         for (j = 0; j < n; ++j)
47         {
48             if (edge[v][j]==1&&visited[j]==0)
49             {
50                 cout << vertex[j]; visited[j] = 1; Q[++rear] = j;
51             }
52         }
53     }
54 }

 1 //堆排序
 2 void sift(int a[], int pos, int size)
 3 {
 4     int child;
 5     int  tmp = a[pos];
 6     for (;pos*2+1<size;pos=child)
 7     {
 8         child = pos * 2 + 1;
 9         if (child != size - 1 && a[child + 1] > a[child])
10         {
11             child++;
12         }
13         if (a[child] > tmp)
14         {
15             a[pos] = a[child];
16         }
17         else break;
18     }
19     a[pos] = tmp;
20 }
21 void heap(int a[], int size)
22 {
23     int i;
24     for (i=size/2-1;i>=0;--i)
25     {
26         sift(a, i, size);
27     }
28     for (i=size-1;i>0;--i)
29     {
30         swap(a[0], a[i]);
31         sift(a, 0, i);
32     }
33 }

 1 //堆排序
 2 void sift(int a[], int pos, int size)
 3 {
 4     int child;
 5     int  tmp = a[pos];
 6     for (;pos*2+1<size;pos=child)
 7     {
 8         child = pos * 2 + 1;
 9         if (child != size - 1 && a[child + 1] > a[child])
10         {
11             child++;
12         }
13         if (a[child] > tmp)
14         {
15             a[pos] = a[child];
16         }
17         else break;
18     }
19     a[pos] = tmp;
20 }
21 void heap(int a[], int size)
22 {
23     int i;
24     for (i=size/2-1;i>=0;--i)
25     {
26         sift(a, i, size);
27     }
28     for (i=size-1;i>0;--i)
29     {
30         swap(a[0], a[i]);
31         sift(a, 0, i);
32     }
33 }

 1 //選擇排序
 2 void straight(int a[], int size)
 3 {
 4     int pos, j, min;
 5     for (pos=0;pos<size-1;++pos)
 6     {
 7         min = pos;
 8         for (j=pos+1;j<size;++j)
 9         {
10             if (a[j]<a[min])
11             {
12                 min = j;
13             }
14         }
15         if (pos!=min)
16         {
17             swap(a[pos], a[min]);
18         }
19     }
20 }

 1 //希爾排序
 2 void shell(int a[], int size)
 3 {
 4     int gap, pos, j, tmp;
 5     for (gap=size/2;gap>0;gap/=2)
 6     {
 7         for (pos=gap;pos<size;pos++)
 8         {
 9             tmp = a[pos];
10             for (j=pos-gap;j>=0&&a[j]>tmp;j-=gap)
11             {
12                 a[j + gap] = a[j];
13             }
14             a[j + gap] = tmp;
15         }
16     }
17 }

 1 //折半查詢
 2 int binary(int a[], int size, int k)
 3 {
 4     int low = 1, high = size - 1, mid;
 5     while (low<=high)
 6     {
 7         mid = (low + high) / 2;
 8         if (a[mid]==k)
 9         {
10             return mid;
11         }
12         if (k<a[mid])
13         {
14             high = mid - 1;
15         }
16         else
17         {
18             low = mid + 1;
19         }
20     }
21     return 0;
22 }

 1 //單鏈表刪除
 2 struct Node
 3 {
 4     int data;
 5     Node * next;
 6 };
 7 Node *first;
 8 int Delete(int i)
 9 {
10     Node *p = first;int count = 0;
11     while (p!=NULL&&count<i-1)
12     {
13         p = p->next;
14         count++;
15     }
16     if (p==NULL&&p->next==NULL)
17     {
18         throw"位置";
19     }
20     else
21     {
22         Node *q = p->next;
23         int x = q->data;
24         p->next = q->next;
25         delete q;
26         return x;
27     }
28 }

 1 //單鏈表的插入
 2 struct Node
 3 {
 4     int data;
 5     Node *next;
 6 };
 7 Node *first;
 8 void insert(int i, int x)
 9 {
10     Node *p = first;
11     int count = 0;
12     while (p!=NULL&&count<i-1)
13     {
14         p = p->next;
15         count++;
16     }
17     if (p=NULL)
18     {
19         throw"位置";
20     }
21     else
22     {
23         Node *s = new Node;
24         s->data = x;
25         s->next = p->next;
26         p->next = s;
27     }
28 }

 1 //單鏈表的逆置
 2 struct Node
 3 {
 4     int data;
 5     Node *next;
 6 };
 7 Node *first;
 8 void Reverse()
 9 {
10     Node *p = first->next,*u;
11     first->next = NULL;
12     while (p)
13     {
14         u = p->next;
15         p->next = first->next;
16         first->next = p;
17         p = u;
18     }
19 }

 1 //二叉樹的遍歷
 2 struct BiNode
 3 {
 4     int data;
 5     BiNode *left, *right;
 6 };
 7 BiNode *bt;
 8 void Preorder(BiNode *bt)
 9 
10 {
11     if (bt)
12     {
13         cout << bt->data;
14         Preorder(bt->left);
15         Preorder(bt->right);
16     }
17 }
18 void Inorder(BiNode *bt)
19 {
20     if (bt)
21     {
22         Inorder(bt->left);
23         cout << bt->data;
24         Inorder(bt->right);
25     }
26 }
27 void Postorder(BiNode *bt)
28 {
29     if (bt)
30     {
31         Postorder(bt->left);
32         Postorder(bt->right);
33         cout << bt->data;
34         
35     }
36 }
37 void Leverorder(BiNode *bt)
38 {
39     int rear = -1, front = -1;
40     BiNode *Q[100];
41     if (bt==NULL)
42     {
43         return;
44     }
45     Q[++rear] = bt;
46     while (front!=rear)
47     {
48         BiNode *q;
49         q = Q[++front];
50         if (q->left!=NULL)
51         {
52             Q[++rear] = q->left;
53         }
54         if (q->right!=NULL)
55         {
56             Q[++rear] = q->right;
57         }
58     }
59 }

 1 struct BiNode
 2 {
 3     int data;
 4     BiNode *left,*right;
 5 };
 6 struct BiNode *bt;
 7 //求結點數
 8 int size(BiNode *bt)
 9 {
10      if (bt==NULL)
11      {
12          return 0;
13      }
14      else
15      {
16          return 1 + size(bt->left) + size(bt->right);
17      }
18 }
19 //求高度
20 int height(BiNode *bt)
21 {
22     if (bt==NULL)
23     {
24         return 0;
25     }
26     int lh = height(bt->left);
27     int rh = height(bt->right);
28     return 1 + (lh > rh ? lh : rh);
29 }
30 //求葉子數
31 int leafNum(BiNode *bt)
32 {
33     if (bt==NULL)
34     {
35         return 0;
36     }
37     if ((bt->left==NULL)&&(bt->right)==NULL)
38     {
39         return 1;
40     }
41     else
42     {
43         return leafNum(bt->left) + leafNum(bt->right);
44     }
45 }

 1 //統計只有一個孩子的結點個數
 2 struct BiNode
 3 {
 4     int data;
 5     BiNode *left,*right;
 6 };
 7 struct BiNode *bt;
 8 void count(BiNode *bt, int *n)
 9 {
10     if (bt)
11     {
12         if ((bt->left==NULL)&&(bt->right!=NULL)|| (bt->right == NULL) && (bt->left != NULL))
13         {
14             (*n)++;
15             return;
16         }
17         count(bt->left, n);
18         count(bt->right, n);
19     }
20 }

 1 //判斷單鏈表是否遞增
 2 struct Node
 3 {
 4     int data;
 5     Node *next;
 6 };
 7 Node *first;
 8 bool increase()
 9 {
10     Node *p = first->next,*q;
11     while (p->next)
12     {
13         q = p->next;
14         if (p->data<q->data)
15         {
16             p = q;
17         }
18         else
19         {
20             return false;
21         }
22     }
23     return true;
24 }