数据结构习题

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

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

void invert(SeqList *L, int *num)  //L 为数组，num 为数组元素个数
{
    int j, tmp;
    for(j = 0; j <= *(num-1)/2; j++)
    {
        tmp = L[j];
        L[j] = L[*num-j-1];
        L[*num-j-i] = tmp;
    }
}

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

void invert(LinkList L)  //LinkList 为结构体指针类型名
{
    Node *p, *q, *r;
    if(L->next == NULL) return;    //链表为空
    p = L -> next;
    q = p -> next;
    p -> next = NULL;      //摘下第一个结点，生成初始逆置表
    while(q != NULL)      //从第二个结点起依次插入当前逆置表
    {
        r = q -> next;
        q -> next = L -> next;
        L -> next = q;
        q = r;
    }
}

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

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

int TreeDepth(BiTree t)  //二叉树采用二叉链表存储
{
    int hl, hr, rel;
    if(!t) return 0;
    else
    {
        hl = TreeDepth(t -> lchild);
        hr = TreeDepth(t -> rchild);
        rel = (hl > hr) ? hl + 1 : hr + 1;
        return (rel);
    }
}

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

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

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

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

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

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

#include <iostream>
#include <iomanip>
#include <algorithm>
using namespace std;
int a[1000000], n;
void Deleteup(int a[], int n)
{
    int i, j, k, count;
    i = 0;
    while(i < n)
    {
        count = 0;
        j = i + 1;
        while(j < n && a[i] == a[j])
            j++,count++;
        if(count != 0)
            for(k = j; k < n; k++)
                a[k - count] = a[k];
        n -= count;
        i++;
    }
    for(int l = 0; l < n; l++)
        cout<<a[l]<<" ";
}

int main()
{
    cin>>n;
    for(int i = 0; i < n; i++)
        cin>>a[i];
    Deleteup(a,n);
    return 0;
}

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

#include <iostream>
#include <iomanip>
#include <algorithm>
using namespace std;
int a[1000000], n;
void Deleteup(int a[], int n)
{
    int i, j, k;
    i = 0;
    while(i < n)
    {
        for(j = i + 1; j < n;)
        {
            if(a[i] == a[j])
            {
                for(k = j; k < n - 1; k++)
                    a[k] = a[k+1];
                n--;
            }
            else j++;
        }
        i++;
    }
    for(int l = 0; l < n; l++)
        cout<<a[l]<<" ";
}

int main()
{
    cin>>n;
    for(int i = 0; i < n; i++)
        cin>>a[i];
    Deleteup(a,n);
    return 0;
}

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

算法：

typedef struct
{
    int adjvex;
    struct ArcNode *nextarc;
}ArcNode;
typedef struct
{
    int data;
    int in;
    int out;
    ArcNode *firstarc;
}VNode;
typedef struct
{
    VNode vertices[NUM];
    int vexnum;
    int arcnum;
}AlGraph;
void GetInAndOut(AlGraph &g)
{
    int i;
    ArcNode *p;
    for(i = 0; i < g.vexnum; i++)
    {
        p = g.vertices[i].firstarc;
        while(p != NULL)
        {
            g.vertices[i].out++;
            g.vertices[p->adjvex].in++;
            p = p->nextarc;
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+11;
int in[maxn];    //代表入度
int out[maxn];   //代表出度
struct node      //定义一个结构体
{
    int to;   // 入度
    int w;    // 权值
};
vector <node>g[maxn];    //容器
ll n,m;     //n个节点, m 次输入
int main()
{
    std::ios::sync_with_stdio(0);    //加速器
    memset(in,0,sizeof(in));    //初始化
    cin>>n>>m;
    int a,b,c;       // a  to  b .权值为 c
    for(int i=1;i<=m;i++)
    {
        cin>>a>>b>>c;
        g[a].push_back(node{b,c});  //终点 和 权值
    }
    for(int i=1;i<=n;i++)    // n 个结点
    {
        for(int j=0;j<g[i].size();j++)
        {
            int q=g[i][j].to;
            in[q]++;       //桶排原理， 统计入度
        }
        out[i]=g[i].size();   //统计出度
    }
    for(int i=1;i<=n;i++)
        cout<<"节点"<<i<<"的入度是"<<in[i]<<" 出度是"<<out[i]<<endl;
    return 0;
}