数据结构习题

Posted 2022-12-22 edviv

一.线性表的逆置算法( a[ 1] .....  a[ n ]) 逆置为( a[ n ] ...... a[ 1 ])

(1)一维数组作存储结构

 1 void invert(SeqList *L, int *num)  //L 为数组，num 为数组元素个数
 2 
 3     int j, tmp;
 4     for(j = 0; j <= *(num-1)/2; j++)
 5     
 6         tmp = L[j];
 7         L[j] = L[*num-j-1];
 8         L[*num-j-i] = tmp;
 9     
10 

(2)单链表作为存储结构

 1 void invert(LinkList L)  //LinkList 为结构体指针类型名
 2 
 3     Node *p, *q, *r;
 4     if(L->next == NULL) return;    //链表为空
 5     p = L -> next;
 6     q = p -> next;
 7     p -> next = NULL;      //摘下第一个结点，生成初始逆置表
 8     while(q != NULL)      //从第二个结点起依次插入当前逆置表
 9     
10         r = q -> next;
11         q -> next = L -> next;
12         L -> next = q;
13         q = r;
14     
15 

二.二叉树：知道前序遍历、中序遍历、后序遍历任意两种即可求出该棵二叉树的形态。

三.求二叉树高度的算法：

 1 int TreeDepth(BiTree t)  //二叉树采用二叉链表存储
 2 
 3     int hl, hr, rel;
 4     if(!t) return 0;
 5     else
 6     
 7         hl = TreeDepth(t -> lchild);
 8         hr = TreeDepth(t -> rchild);
 9         rel = (hl > hr) ? hl + 1 : hr + 1;
10         return (rel);
11     
12 

四.判断循环队列是否满的方法：

(1) 牺牲一个单元不用： 当 Q.front == Q.rear 时队列为空。

                                       当 (Q.rear + 1) % MAXSIZE == Q.front 时队列为满。

(2) 标志域法：设置一个标志域， flag == 0 时队列空，flag == 1 时队列满。

五.在一个顺序表中删除重复元素，不能另外开辟数据存储空间。

(1) 只能删除相邻位置的重复元素，不相邻位置的重复元素保留

 1 #include <iostream>
 2 #include <iomanip>
 3 #include <algorithm>
 4 using namespace std;
 5 int a[1000000], n;
 6 void Deleteup(int a[], int n)
 7 
 8     int i, j, k, count;
 9     i = 0;
10     while(i < n)
11     
12         count = 0;
13         j = i + 1;
14         while(j < n && a[i] == a[j])
15             j++,count++;
16         if(count != 0)
17             for(k = j; k < n; k++)
18                 a[k - count] = a[k];
19         n -= count;
20         i++;
21     
22     for(int l = 0; l < n; l++)
23         cout<<a[l]<<" ";
24 
25 
26 int main()
27 
28     cin>>n;
29     for(int i = 0; i < n; i++)
30         cin>>a[i];
31     Deleteup(a,n);
32     return 0;
33 

(2)所有重复元素都删除。

 1 #include <iostream>
 2 #include <iomanip>
 3 #include <algorithm>
 4 using namespace std;
 5 int a[1000000], n;
 6 void Deleteup(int a[], int n)
 7 
 8     int i, j, k;
 9     i = 0;
10     while(i < n)
11     
12         for(j = i + 1; j < n;)
13         
14             if(a[i] == a[j])
15             
16                 for(k = j; k < n - 1; k++)
17                     a[k] = a[k+1];
18                 n--;
19             
20             else j++;
21         
22         i++;
23     
24     for(int l = 0; l < n; l++)
25         cout<<a[l]<<" ";
26 
27 
28 int main()
29 
30     cin>>n;
31     for(int i = 0; i < n; i++)
32         cin>>a[i];
33     Deleteup(a,n);
34     return 0;
35 

六.采用邻接链表作为有向图的存储结构，编写一个算法计算有向图的出度和入度。

算法：

 1 typedef struct
 2 
 3     int adjvex;
 4     struct ArcNode *nextarc;
 5 ArcNode;
 6 typedef struct
 7 
 8     int data;
 9     int in;
10     int out;
11     ArcNode *firstarc;
12 VNode;
13 typedef struct
14 
15     VNode vertices[NUM];
16     int vexnum;
17     int arcnum;
18 AlGraph;
19 void GetInAndOut(AlGraph &g)
20 
21     int i;
22     ArcNode *p;
23     for(i = 0; i < g.vexnum; i++)
24     
25         p = g.vertices[i].firstarc;
26         while(p != NULL)
27         
28             g.vertices[i].out++;
29             g.vertices[p->adjvex].in++;
30             p = p->nextarc;
31         
32     
33 

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 typedef long long ll;
 4 const int maxn=1e5+11;
 5 int in[maxn];    //代表入度
 6 int out[maxn];   //代表出度
 7 struct node      //定义一个结构体
 8 
 9     int to;   // 入度
10     int w;    // 权值
11 ;
12 vector <node>g[maxn];    //容器
13 ll n,m;     //n个节点, m 次输入
14 int main()
15 
16     std::ios::sync_with_stdio(0);    //加速器
17     memset(in,0,sizeof(in));    //初始化
18     cin>>n>>m;
19     int a,b,c;       // a  to  b .权值为 c
20     for(int i=1;i<=m;i++)
21     
22         cin>>a>>b>>c;
23         g[a].push_back(nodeb,c);  //终点 和 权值
24     
25     for(int i=1;i<=n;i++)    // n 个结点
26     
27         for(int j=0;j<g[i].size();j++)
28         
29             int q=g[i][j].to;
30             in[q]++;       //桶排原理， 统计入度
31         
32         out[i]=g[i].size();   //统计出度
33     
34     for(int i=1;i<=n;i++)
35         cout<<"节点"<<i<<"的入度是"<<in[i]<<" 出度是"<<out[i]<<endl;
36     return 0;
37