线性表
线性表（List）：零个或多个数据元素的有限序列。
首先它是一个序列。也就是说，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且只有一个前驱和后继。
然后，线性表强调是有限的。
顺序表与单链表是线性表的两种最基本的存储结构，而静态链表是两者的完美结合，是系统进行动态存储分配的方法基础。线性表的这三种存储结构不但是其他数据结构（如树形结构、图型结构、集合等）存储方法的重要基础，同时本身也有广泛的应用。
线性表应该有以下基本的操作
- InitList 初始化
- ListEmpty 判空
- ClearList 清空
- GetElem 返回线性表第i个位置的元素
- ListInsert 在线性表第i个位置插入元素
- ListDelete 删除线性表的第i个位置的元素
- ListLength *返回线性表的元素个数
顺序存储结构
可能有人第一次见线性表的顺序存储结构的时候，不禁怀疑：”这不就数组吗？这样定义好麻烦啊。有啥用啊？”
确实，在一些小体量的程序时，这样定义使用很麻烦，不如直接用数组。
但是这样封装起来后，程序就会很规范，虽然代码看上去很臃肿。
另外要实现的功能：
- 对于已排好序的线性表，删除所有重复元素的算法。
- 线性表”逆置”算法。
- 线性表循环左移/右移 k 位的算法。
- 合并两个已排好序的线性表的算法
下面是代码，结合注释理解
点击查看代码
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#define maxlenglth 1000
#define OK 1
#define ERROR 0
using namespace std;
typedef int Elemtype;
typedef int Status;
typedef int Position;
struct SeqList
{
Elemtype data[maxlenglth];
int lenth;
};// 线性表的定义
Status Display(SeqList L);//打 印
SeqList InitList();// 初始化
Position End(SeqList L); // 返回最后的位置
Status Insert(Elemtype t, Position p, SeqList &L); // 在位置p插入元素t
Status Delete(Elemtype t, SeqList &L); //删除所有元素t
Status Sort(SeqList &L); //排序
Status Unique(SeqList &L); //对排完序去重
Status ReverseList(SeqList &L); //翻转（逆置）
Status Merge(SeqList &L1, SeqList L2); //合并两个排好序的
Status Move(SeqList &L, int flag, int step); //移动
int main()
{
// basic test
int n1, n2;
SeqList L1 = InitList();
SeqList L2 = InitList();
cout << "please input L1's lenth:"; cin >> n1;
cout << "please input L1's data:" << "\n";
for(int i = 1; i <= n1; i ++ ) { int x; cin>> x;
Insert(x, L1.lenth + 1, L1);
}
Display(L1);
cout << "----Delete----" << "\n";
Elemtype temp;
cin >> temp;
Delete(temp, L1);
Display(L1);
cout << "----Sorted----" << "\n";
Sort(L1);
Display(L1);
cout << "----Uniqued----" << "\n";
Unique(L1);
Display(L1);
// merge test
cout << "please input L2's lenth:"; cin >> n2;
cout << "please input L2's data:" << "\n";
for(int i = 1; i <= n2; i ++ ) { int x; cin>> x;
Insert(x, L2.lenth + 1, L2);
}
Display(L2);
cout << "----Merged----" << "\n";
Merge(L1, L2);
Display(L1);
// move test
int flag, step;
cout << "left(1) right(0):"; cin >> flag;
cout << "move step:"; cin >> step;
Move(L1, flag, step);
Display(L1);
cin >> n1;
return 0;
}
Status Display(SeqList L)
{
for(int i = 1; i <= 1="=" l.lenth; i ++ ) cout << l.data[i] " \n"[i="=" l.lenth]; } seqlist initlist() { list; list.lenth="0;" return position end(seqlist l) status insert(elemtype t, p, &l) if(l.lenth + maxlenglth) "full list!" "\n"; 1; if(p> L.lenth + 1 || p < 1)
{
cout << "Invalid Position!" << "\n";
return 1;
}
L.lenth += 1;
for(int i = L.lenth; i > p; i -- )
{
L.data[i] = L.data[i - 1];
}
L.data[p] = t;
return 0;
}
Status Delete(Elemtype t, SeqList &L)
{
Position idx = 0;
for(int i = 1; i <= 1 l.lenth; i ++ ) { if(l.data[i] !="t)" idx ++; l.data[idx]="L.data[i];" } l.lenth="idx;" return 0; status sort(seqlist &l) sort(l.data + 1, l.data 1); unique(seqlist position elemtype last="0;" for(int <="L.lenth;" ++) if(i="=" 1) }else if(last reverselist(seqlist j="L.lenth;" j; ++, -- swap(l.data[i], l.data[j]); merge(seqlist &l1, seqlist l2) if(l1.lenth l2.lenth>= maxlenglth)
{
cout << "Overflow!" << "\n";
return 1;
}
for(int i = L2.lenth + 1, j = 1; j <= l1.lenth; j ++ , i ++) { l2.data[i]="L1.data[j];" } position idx="0;" i, j; for(i="1," + 1; <="L2.lenth" && l2.lenth;) if(l2.data[i] ++; l1.data[idx]="L2.data[i];" }else while(i while(j l1.lenth) l1.lenth return 0; status move(seqlist &l, int flag, step) static seqlist temp="InitList();" temp.lenth="L.lenth;" if(temp.lenth="=" 0) for(int ) temp.data[i]="L.data[i];" step="step" % l.lenth; if(flag="=" flag="1;" * step; if(j> temp.lenth)
{
j -= temp.lenth;
}
if(j < 1)
{
j += temp.lenth;
}
L.data[j] = temp.data[i];
}
return 0;
}
</=></=></=></=></=></cstring></iostream></algorithm></cstdio>
链式存储结构
关于链表，有三种经典类型： 单链表， 双向链表， 循环链表
而每种类型又有很多考法
但其核心都是 指针域的用法
另外要实现的功能：
- 对于已排好序的线性表，删除所有重复元素的算法。
- 线性表”逆置”算法。
- 线性表循环左移/右移 k 位的算法。
- 合并两个已排好序的线性表的算法
点击查看代码
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#define OK 0
#define ERROR 1
using namespace std;
typedef int Elemtype;
typedef int Status;
struct Node{
Elemtype data;
Node * next;
};//链表定义
typedef Node * Position;
typedef Node * LIST;
void Creat(LIST head,int size);//创建
void ForwardInsert(LIST head,Elemtype x);//头插
void BackInsert(LIST head,int x);//尾插
void Travel(LIST head);//遍历
Status IsEmpty(LIST head);//判空
void AllDelete(LIST head);//删除
void SomeDataDelete(LIST head,Elemtype x);//删除一个数
void SomeDataInsert(LIST head,Elemtype x,int num);//在某位置插入一个数
void Sort(LIST head, int (*cmp)(Elemtype, Elemtype));//冒泡排序
int Ascend(Elemtype x, Elemtype y);//升序
int Descend(Elemtype x, Elemtype y);//降序
Position Locate(Elemtype x, LIST head);
void Unique(LIST head);//去重
Status Reverse(LIST head);//翻转
Status Move(LIST head, int flag, int step);//循环移动
Status Merge(LIST head1, LIST head2);//合并两个排好序的链表
int Len(LIST head);//求链表长
void MergeTest();//合并的测试
int main()
{
LIST head = (LIST)malloc(sizeof(Node));//头节点
head->next = NULL;
int num, i;
Elemtype temp;
cout << "list num:";
cin >> num;
Creat(head,num);
Travel(head);
cout << "Insert forwarddata:";//头插
cin >> temp;
ForwardInsert(head,temp);
Travel(head);
cout << "Insert backdata:";//尾插
cin >> temp;
BackInsert(head,temp);
Travel(head);
cout << "Somedata delete:";//删除
cin >> temp;
SomeDataDelete(head,temp);
Travel(head);
cout << "SomeDataInsert:(data and which):"; //某一位置插入某个数（BUG不可尾插）
cin >> temp >> i;
SomeDataInsert(head,temp,i);
Travel(head);
// 排序测试
cout << "----Sorted----" << "\n";
Sort(head,Descend);
Travel(head);
//去重测试
cout << "----Uniqued----" << "\n";
Unique(head);
Travel(head);
// 翻转测试
cout << "----Reversed----" << "\n";
Reverse(head);
Travel(head);
// 循环左(右)移测试
cout << "----Move----" << "\n";
int flag ,step;
cout << "(right, left)(0,1)---(step)" << "\n";
cin >> flag >> step;
Move(head, flag, step);
Travel(head);
// 合并测试
MergeTest();
AllDelete(head);
Travel(head);
free(head);//free掉头节点
return 0;
}
void MergeTest()
{
int num;
cout << "----Merge----" << "\n";
LIST h1 = (LIST)malloc(sizeof(Node));
h1->next = NULL;
cout << "list1 num:";cin >> num;
Creat(h1,num);
Sort(h1, Descend);
LIST h2 = (LIST)malloc(sizeof(Node));
h2->next = NULL;
cout << "list2 num:";cin >> num;
Creat(h2,num);
Sort(h2, Descend);
Merge(h1, h2);
cout << "Merged list:" << "\n";
Travel(h1);
AllDelete(h1);
free(h1);
free(h2);
}
Status Merge(LIST head1, LIST head2)
{
LIST p1 = head1->next, p2 = head2->next;
LIST temp = head1;
while(p1 != NULL && p2 != NULL)
{
if(p1->data < p2->data)
{
temp->next = p1;
p1 = p1->next;
}else
{
temp->next = p2;
p2 = p2->next;
}
temp = temp->next;
}
while(p1 != NULL)
{
temp->next = p1;
p1 = p1->next;
temp = temp->next;
}
while(p2 != NULL)
{
temp->next = p2;
p2 = p2->next;
temp = temp->next;
}
temp->next = NULL;
return OK;
}
Status Move(LIST head, int flag, int step)
{
int len = Len(head);
step = step % len;
if(step == 0)
{
return OK;
}
if(flag == 0)
{
step = len - step;
}
LIST p, q, s;
p = q = s = head;
p = p->next;
int idx = 0;
while(s->next != NULL)
{
idx ++;
s = s->next;
if(idx == step)
{
q = s;
}
}
head->next = q->next;
s->next = p;
q->next = NULL;
return OK;
}
int Len(LIST head)
{
LIST p = head;
int cnt = 0;
while(p->next != NULL)
{
cnt ++;
p = p->next;
}
return cnt;
}
void Unique(LIST head)
{
Elemtype last;
LIST p, q;
p = head->next;
if(p == NULL || p->next == NULL)
{
return;
}
last = p->data;
q = p->next;
while(q != NULL)
{
if(q->data == last)
{
p->next = q->next;
free(q);
if(p->next == NULL)
{
q = NULL;
}else
{
q = p->next;
}
}else
{
last = q->data;
q = q->next;
p = p->next;
}
}
}
Status Reverse(LIST head)
{
LIST p, q, s;
p = q = s = head->next;
q = p->next;
while(q != NULL)
{
p->next = q->next;
q->next = s;
s = q;
q = p->next;
}
head->next = s;
return OK;
}
Position Locate(Elemtype x, LIST head)
{
Position p = head;
while(p->next != NULL)
{
if(p->data == x)
{
return p;
}else
{
p = p->next;
}
}
return p;/* 如果没有找到 */
}
int Descend(Elemtype x, Elemtype y)
{
return x > y;
}
int Ascend(Elemtype x, Elemtype y)
{
return x < y;
}
void Sort(LIST head, int(*cmp)(Elemtype, Elemtype))
{
if(head->next == NULL)
{
cout << "Empty Node!\n";
return;
}
if(head->next->next==NULL)
{
cout << "Only one element!\n";
return;
}
LIST p1;
LIST p2;
for (p1 = head->next; p1->next != NULL; p1 = p1->next)
{
for (p2 = p1->next; p2!=NULL; p2 = p2->next)
{
if ((*cmp)(p1->data, p2->data))
{
swap(p1->data, p2->data);
}
}
}
}
void Creat(LIST head, int size)
{
LIST p = head;
for(int i = 1;i <= size; i ++) { list newnode="(LIST)malloc(sizeof(Node));" newnode->next = NULL;
cin >> newnode->data;
p->next = newnode;
p = newnode;
}
}
void ForwardInsert(LIST head, Elemtype x)
{
LIST newhead = (LIST)malloc(sizeof(Node));
newhead->data = x;
newhead->next = head->next;
head->next = newhead;
return;
}
void Travel(LIST head)
{
LIST p = head;
while(p->next != NULL)
{
p = p->next;
cout << p->data << " ";
}
cout << "\n";
return;
}
void BackInsert(LIST head, Elemtype x)
{
LIST p = head;
LIST back = (Node*)malloc(sizeof(Node));
back->next = NULL;
back->data = x;
while(p->next != NULL)
{
p = p->next;
}
p->next = back;
return;
}
Status IsEmpty(LIST head)
{
if(head->next == NULL)
{
cout << "is Empty!" << "\n";
return OK;
}else
{
cout << "not Empty!" << "\n";
return ERROR;
}
}
void AllDelete(LIST head)
{
LIST p = head->next;
LIST temp = head;
while(p != NULL)
{
temp = p;
p = p->next;
free(temp);
}
head->next = NULL;
return;
}
void SomeDataDelete(LIST head, Elemtype x)
{
LIST p = head->next;
LIST last = head;
LIST temp = NULL;
while(p != NULL)
{
if(temp != NULL)
{
free(temp);
temp = NULL;
}
if(p->data == x)
{
last->next = p->next;
temp = p;
}else
{
last = last->next;
}
p = p->next;
}
return;
}
void SomeDataInsert(LIST head,Elemtype x,int num)
{
LIST p = head;
LIST last = head;
int idx = 0;
while(p->next != NULL)
{
p = p->next;
idx ++;
if(idx == num)
{
LIST NewNode = (LIST)malloc(sizeof(Node));
NewNode->data = x;
last->next = NewNode;
NewNode->next = p;
}
last = last->next;
}
}
</=></cstdlib></algorithm></cstdio></cstring></iostream>
静态链表
静态链表其实就是将 指针域用 游标来代替 指针。
游标： Cursor
所有它的大小也取决于最先开始建立的数组大小。
这里插入一张《大话数据结构》的图片
实现基本功能和逆置的静态链表：
点击查看代码
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#define OK 1
#define ERROR 0
#define MAXSIZE 1000
using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
for(int i = 0; i < MAXSIZE - 1; i ++ )
space[i].cur = i + 1;
space[MAXSIZE - 1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
return OK;
}
/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一个元素的cur存的值 */
/* 就是要返回的第一个备用空闲的下标 */
if (space[0]. cur)
space[0]. cur = space[i].cur; /* 由于要拿出一个分量来使用了， */
/* 所以我们就得把它的下一个 */
/* 分量用来做备用 */
return i;
}
/* 将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素的cur值赋给要删除的分量cur */
space[0].cur = k; /* 把要删除的分量下标赋值给第一个元素的cur */
}
/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
int j = 0;
int i = L[MAXSIZE-1].cur;
while(i)
{
i = L[i].cur;
j ++;
}
return j;
}
/* 在L中第i个元素之前插入新的数据元素e */
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
int j, k, l;
k = MAXSIZE - 1; /* 注意k首先是最后一个元素的下标 */
if (i < 1 || i > ListLength(L) + 1)
return ERROR;
j = Malloc_SSL(L); /* 获得空闲分量的下标 */
if (j)
{
L[j].data = e; /* 将数据赋值给此分量的data */
for(l = 1; l <= 1 i - 1; l++) * 找到第i个元素之前的位置 k="L[k].cur;" l[j].cur="L[k].cur;" 把第i个元素之前的cur赋值给新元素的cur l[k].cur="j;" 把新元素的下标赋值给第i个元素之前元素的ur return ok; } error; 删除在l中第i个数据元素 status listdelete(staticlinklist l, int i) { j, k; if (i < ||> ListLength(L))
return ERROR;
k = MAXSIZE - 1;
for (j = 1; j <= i - 1; j++) k="L[k].cur;" j="L[k].cur;" l[k].cur="L[j].cur;" free_ssl(l, j); return ok; } status listtraverse(staticlinklist l) { int while(i) cout << l[i].data " "; j++; "\n"; reverse(staticlinklist k; l[i].cur="j;" l[maxsize-1].cur="j;" main() staticlinklist l; i; "--- creat ---" "num: n;cin>> n;
for(int i = 1; i <= n ; i ++ ) { int e; cin>> e;
ListInsert(L, i, e);
}
ListTraverse(L);
cout << "--- Reverse ---" << "\n";
Reverse(L);
ListTraverse(L);
return 0;
}
</=></=></=></algorithm></cstdio></cstring></iostream>
说到静态链表，就不得不说它的一个应用： 邻接表。
邻接表可以用作图的存储，可以存储有向图或无向图
- idx 游标，可认为是第 idx的意思
- h[N] 有N个顶点，每个点都可能会连有边， h[i]存储 顶点i的所有出边指向的点的 集合
- e[N] 存储该节点的出边指向的顶点
- ne[N] 存储该节点的下一个节点的 游标
- w[N] 存储该节点代表的边的权重
int h[N], e[N], ne[N], idx;
// 添加一条边a->b
void add(int a, int b) //a到b添加一条边 事实上是 头插法
{
e[idx] = b;//节点idx存储顶点b
ne[idx] = h[a];//将节点idx指向的节点 指向 a顶点所指向的节点（头节点）
h[a] = idx ++ ; //将头指针的指向为新的头节点
}
// 初始化
idx = 0;
memset(h, -1, sizeof h); //初始化 所有的头指针指向-1
//这样当遍历的时侯,因为游标不可能出现-1，就可以当作遍历终止条件
参考文献
- 程杰. 大话数据结构：溢彩加强版[M]. 北京: 清华大学出版社, 2020.
Original: https://www.cnblogs.com/Az1r/p/16720710.html
Author: 江水为竭
Title: 数据结构：线性表
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/685959/
转载文章受原作者版权保护。转载请注明原作者出处！