根据给定的信息，我们可以深入探讨东北大学数据结构算法汇总中提到的关键知识点，主要围绕线性结构、基础要点以及具体的算法实现展开。
### 线性结构类型定义
#### 顺序表
顺序表是一种线性表的数据结构，其中的元素按照一定的顺序存储在连续的内存空间中。给定文件中的顺序表定义如下：
```c
#define MAXSIZE 100
typedef struct node {
ElemType data[MAXSIZE];
int length;
} SqList;
```
这里定义了一个名为`SqList`的结构体，用于表示顺序表。`ElemType`是具体的数据类型，可以是整型、字符型等；`data`数组用来存储数据，最大长度为`MAXSIZE`；`length`记录了当前顺序表中元素的实际数量。
#### 单链表
单链表是一种常见的线性表实现方式，每个节点包含一个指向下一个节点的指针。定义如下：
```c
typedef struct node {
ElemType data;
struct node* next;
} SLink;
```
这里定义了一个名为`SLink`的结构体，`data`存储数据，`next`是指向下一个节点的指针。
#### 双链表
双链表是一种更复杂的链表形式，每个节点除了包含指向下一个节点的指针外，还包含一个指向前一个节点的指针。
```c
typedef struct node {
ElemType data;
struct node* prior;
struct node* next;
} dlink;
```
这里定义了一个名为`dlink`的结构体，`data`存储数据，`prior`指向当前节点的前一个节点，`next`指向当前节点的下一个节点。
### 基础要点
#### 单链表
单链表的结构示意图未给出，但可以想象每个节点只包含一个指向下一个节点的指针。这种结构使得单链表具有良好的插入和删除性能，因为只需要修改指针即可，但查找效率较低，需要从头节点开始逐个遍历。
#### 双链表
双链表的结构示意图同样未给出，但可以理解为每个节点同时包含一个指向前一个节点的指针和一个指向下一个节点的指针。这种结构使得双链表既可以在两个方向上进行操作，又具有良好的插入和删除性能，但相比单链表占用更多的内存空间。
### 算法实现
#### 删除顺序表中重复元素
该算法的目标是从顺序表中删除所有重复出现的元素。具体实现如下：
```c
void delsame(int A[], int count) {
int i, j, k;
if (N > 1) {
j = 1;
for (i = 1; i < N; i++) {
k = 0;
while (k < j && A[k] != A[i]) k++;
if (k >= j) A[j++] = A[i];
}
A[j] = '\0';
}
}
```
这段代码通过两层循环来比较并删除重复元素，最终保留唯一值。
#### 给无序表建立有序索引表
算法的目标是对一个无序表建立有序的索引表，以便提高后续的操作效率。具体实现如下：
```c
typedef struct indexelem {
KeyType key; // 关键字
int sn; // 序号
} IndexType; // 索引项
IndexType idx[1m]; // 索引表
DataType data[1m]; // 原顺序表
for (i = 1; i <= m; i++) {
j = i - 1;
while (j > 0 && idx[j].key > data[i].key) { // 把大于data[i].key的所有idx[j].key后移
idx[j + 1] = idx[j];
j--;
}
idx[j + 1].key = data[i].key; // 插入data[i].key至idx中，并记下其序号i
idx[j + 1].sn = i;
}
```
该算法首先定义了索引项结构体，然后通过插入排序的方式构建索引表，使索引表按关键字有序。
#### 逆置单链表
算法的目标是将单链表中的元素顺序反转。具体实现如下：
```c
void reverse(LinkList H) {
SNode* p, * temp;
P = H->next;
H->next = NULL;
while (p) {
temp = p;
p = p->next;
temp->next = H->next;
H->next = temp;
}
}
```
通过遍历链表并调整指针关系，实现链表元素的逆置。
#### 拆分单链表
算法的目标是根据数据的不同类型将单链表拆分成三个不同的链表。具体实现如下：
```c
void decompese(SNode* L, SNode* ha, SNode* hb, SNode* hc) {
SNode* temp, * p;
p = L;
ha = (SNode*)malloc(sizeof(SNode));
hb = (SNode*)malloc(sizeof(SNode));
hc = (SNode*)malloc(sizeof(SNode));
ha->next = ha;
hb->next = hb;
hc->next = hc;
while (p) {
if ((p->data >= 'A' && p->data <= 'Z') || (p->data >= 'a' && p->data <= 'z')) {
temp = p;
p = p->next;
temp->next = ha->next;
ha->next = temp;
} else if (p->data >= '0' && p->data <= '9') {
temp = p;
p = p->next;
temp->next = hb->next;
hb->next = temp;
} else {
temp = p;
p = p->next;
temp->next = hc->next;
hc->next = temp;
}
}
}
```
该算法通过遍历原始链表，根据数据类型将其分为大写字母、小写字母、数字和其他类型四类，并分别插入到不同的链表中。
#### 删除单链表重复元素
算法的目标是从单链表中删除所有重复出现的元素。具体实现如下：
```c
void delete(LinkList H) {
SNode* p, * q, * r;
P = H->next;
while (p != NULL) {
q = p;
while (q->next) {
if (q->next->data == p->data) {
r = q->next;
q->next = r->next;
free(r);
} else
q = q->next;
}
p = p->next;
}
}
```
通过遍历链表，比较相邻元素，如果发现重复，则删除重复元素。
#### 合并单链表
算法的目标是将两个单链表合并成一个有序的链表。具体实现如下：
```c
LinkList merge(LinkList A, LinkList B) {
LinkList C;
SNode* p, * q;
P = A->next;
q = B->next;
C = A;
C->next = NULL;
free(B);
while (p && q) {
if (p->data < q->data) {
s = p;
p = p->next;
} else {
s = q;
q = q->next;
}
s->next = C->next; /* 插入到C表的头部 */
C->next = s;
}
if (p == NULL) r = q;
if (q == NULL) r = p;
while (r) /* 将剩余的结点一个个摘下，插入到C表的头部 */ {
s = r;
r = r->next;
}
}
```
通过比较两个链表中元素的大小，依次选择较小的元素插入到新链表中，直到其中一个链表为空，再将另一个链表剩余的部分直接连接到新链表的末尾。
以上就是关于东北大学数据结构算法汇总中的线性结构、基础要点以及算法实现的具体分析。这些知识点对于理解和掌握数据结构的基本原理非常有帮助，也是学习编程语言和技术的基础。
