https://www.jianshu.com/p/d7d5545012e2
习题答案：https://www.cnblogs.com/kangjianwei101/p/5229548.html

1 && 2

//注意行列存储

10

广义表最基本的操作：取表头head(LS)与取表尾tail(LS)
https://blog.csdn.net/qq_38842021/article/details/82290201

head() 返回列表的第一个元素；
tail() 返回列表的删去第一个元素之后的剩余列表；

11

12

13

19

//这个没有办法找到所有的，只能找到一行中前面的
#include <stdio.h>
#include <stdlib.h>
#define m 5
#define n 4
typedef struct Node
{
	int row;//行
	int col;//列
	int data;
};

void SaddlePoint(int a[m][n])
{
	Node s[20];
	int max, min, i, j, k=0;
	int q = 0;
	for (i = 0; i < m; i++)
	{
		min = a[i][0];
		for (j = 0; j < n; j++)//找行最小值
		{
			if (min > a[i][j])
			{
				min = a[i][j];
				k = j;//k是最小值的列数
			}
		}
		max = a[i][k];
		for (j = 0; j < n; j++)//找k列的最大值
		{
			if (max < a[j][k])
			{
				max = a[j][k];
			}
		}
		if (max == min)//找到的最值比较，相同表明是马鞍点
		{
			s[q].col = i;
			s[q].row = k;
			s[q].data = a[i][k];
			printf("鞍点行数为 %d 列数为%d 值为 %d \n", s[q].row + 1, s[q].col + 1, s[q].data);
		}
	}
}

int main()
{
	int a[m][n] = {
		{3,6,4,9},
		{1,2,3,4},
		{9,9,9,9},
		{1,1,1,1},
		{2,3,1,1},
	};
	SaddlePoint(a);
	return 0;
}

21

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10

//三元组稀疏矩阵类型定义
typedef int ElemType;
typedef struct
{
	int i, j;//该非零元的行列下标
	ElemType e;
}Triple;
typedef struct
{
	Triple data[MAXSIZE + 1];//data[0]是不用的
	int mu, nu, tu;//矩阵的行列，非零元个数
}TSMatrix;

int AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q)
{
	int m, n, q;
	if (M.mu != N.mu || M.nu != N.nu)//判断两矩阵的行列是否相同
	{
		printf("两个矩阵不能相加\n");
		return 0;
	}
	Q->mu = M.mu;//给Q赋值
	Q->nu = M.nu;
	Q->tu = 0;
	m = n = q = 1;
	while (m <= M.tu && n <= N.tu)//遍历对比，行列相同的相加
	{
		if (M.data[m].i < N.data[n].i)
		{
			Q->data[q] = M.data[m];
			m++;
		}
		else if (M.data[m].i > N.data[n].i)
		{
			Q->data[q] = N.data[n];
			n++;
		}
		else //M的行与N的行相同
		{
			if (M.data[m].j < N.data[n].j)
			{
				Q->data[q] = M.data[m];
				m++;
			}
			else if (M.data[m].j > N.data[n].j)
			{
				Q->data[q] = N.data[n];
				n++;
			}
			else//M的列=N的列
			{
				if (M.data[m].e + N.data[n].e)
				{
					Q->data[q].i = M.data[m].i;
					Q->data[q].j = M.data[m].j;
					Q->data[q].e = M.data[m].e + N.data[n].e;
					m++;
					n++;
				}
				else
				{
					m++;
					n++;
				}
			}
		}
		q++;
		Q->tu++;
	}
	while (m <= M.tu)
	{
		Q->data[q] = M.data[m];
		m++;
		q++;
		Q->tu++;
	}
	while (n <= N.tu)
	{
		Q->data[q] = N.data[n];
		n++;
		q++;
		Q->tu++;
	}
	return 0;
}

30

#include <stdio.h>
#include <stdlib.h>
//广义表的头尾链表存储表示 p109
typedef enum {ATOM,LIST}ElemTag;//ATOM==0:原子，LIST==1:子表
typedef struct GLNode
{
	ElemTag tag; //区分原子节点和表节点
	union
	{
		int atom; //值域
		struct 
		{
			struct GLNode* hp, * tp; //ptr是表节点的指针域，ptr.hp和ptr.tp分别指向表头表尾
		}ptr;
	};
}*GList;

int GListDepth(GList& L)
{
	int depth = 0;
	int hpdepth, tpdepth;//表头表尾深度
	if (!L) return 1;//空表深度为1
	if (L->tag = ATOM) return 0;//原子深度为0
	hpdepth = GListDepth(L->ptr.hp) + 1;
	tpdepth = GListDepth(L->ptr.tp);
	return hpdepth > tpdepth ? hpdepth : tpdepth;
}

分割线

typedef enum {ATOM,LIST} ElemTag;
typedef struct GLNode{
     ElemTag tag;
     union {
       char atom;
       struct { 
         GLNode *hp, *tp;
       } ptr;
     }un;
} *GList;
int GListDepth(GList ls)
{
    GList pp;
    int max, h, t;
    if(!ls)
       return 1;
    if(ls->tag == ATOM)
       return 0;
    for(pp=ls; pp; pp=pp->un.ptr.tp){
       h = GListDepth(pp->un.ptr.hp)+1;
       t = GListDepth(pp->un.ptr.tp);
       if(h > t)
           return h;
       else
           return t;
    }          
}

32

#include <stdio.h>
#include <stdlib.h>
//广义表的头尾链表存储表示 p109
typedef enum { ATOM, LIST }ElemTag;//ATOM==0:原子，LIST==1:子表
typedef struct GLNode
{
	ElemTag tag; //区分原子节点和表节点
	union
	{
		int atom; //值域
		struct
		{
			struct GLNode* hp, * tp; //ptr是表节点的指针域，ptr.hp和ptr.tp分别指向表头表尾
		}ptr;
	};
}*GList;

int GListCompare(GList& L1, GList& L2)
{
	if (!L1 && !L2) //表1，2都为空，表示他们相同
		return 1;
	if (L1 && L2)//两个表都不为空
	{
		if (L1->tag == L2->tag)
		{
			if (L1->tag == ATOM)//如果是原子节点
			{
				if (L1->atom == L2->atom)
					return 1;
			}
			else
			{
				if (GListCompare(L1->ptr.hp, L2->ptr.hp))
					if (GListCompare(L1->ptr.tp, L2->ptr.tp))
						return 1;
			}
		}
	}
	return 0;
}

33

#include <stdio.h>
#include <stdlib.h>
//广义表的头尾链表存储表示 p109
typedef enum { ATOM, LIST }ElemTag;//ATOM==0:原子，LIST==1:子表
typedef struct GLNode
{
	ElemTag tag; //区分原子节点和表节点
	union
	{
		int atom; //值域
		struct
		{
			struct GLNode* hp, * tp; //ptr是表节点的指针域，ptr.hp和ptr.tp分别指向表头表尾
		}ptr;
	};
}*GList;

void Get(GList L, int a)//a的初赋值为0
{
	int i = a;
	if (L)
	{
		if (L->tag == ATOM)
			printf("%c -> 第%d层\n", L->atom, i);
	}
	if (L->tag == LIST)
	{
		Get(L->ptr.hp, i + 1);
		Get(L->ptr.tp, i );
	}
}

38

#include <stdio.h>
#include <stdlib.h>
//广义表的头尾链表存储表示 p109
typedef enum { ATOM, LIST }ElemTag;//ATOM==0:原子，LIST==1:子表
typedef struct GLNode
{
	ElemTag tag; //区分原子节点和表节点
	union
	{
		int atom; //值域
		struct
		{
			struct GLNode* hp, * tp; //ptr是表节点的指针域，ptr.hp和ptr.tp分别指向表头表尾
		}ptr;
	};
}*GList;

void Get_L_ATOM(GList L, int l, int a)//a的初值赋值是0
{
	int i = a;
	if (L && l >= i)
	{
		if (L->atom == ATOM)
		{
			if (l == i)
				printf("%c", L->atom);
		}
		else
		{
			Get_L_ATOM(L->ptr.hp, l, i + 1);
			Get_L_ATOM(L->ptr.hp, l, i);
		}
	}
}