C++ 线性表知识点摘录

线性表（linear list）

是一种数据结构，是由 n 个具有相同特性的数据元素构成的序列。

线性表中元素的个数 n 即为线性表的长度，当 n = 0 时称为空表。线性表的相邻元素之间存在着序偶关系。

如用（ a[0] ，…… ，a[i-1] ，a[i] ，a[i+1] ，…… ，a[n-1] ）表示一个线性表，则称 a[i-1] 是 a[i] 的前驱，a[i+1] 是 a[i] 的后继。

线性表的特性

• 线性表中必存在唯一的一个“第一元素”；

• 线性表中必存在唯一的一个“最后元素” ；

• 除最后一个元素之外，均有唯一的后继；

• 除第一个元素之外，均有唯一的前驱。

线性表的一般操作

• 将线性表变为空表；

• 返回线性表的长度，即表中元素个数；

• 获取线性表某位置的元素；

• 定位某个元素在线性表中的位置；

• 在线性表中插入一个元素；

• 删除某个元素；

• 判断线性表是否为空；

• 遍历输出线性表的所有元素；

• 线性表排序。

线性表的表示方法

线性表可以用链表来实现。链表是通过指针链接在一起的一组数据项（结点）。

链表的每个结点都是同类型的结构，该结构中一般包含两类信息：

1. 数据域，存储业务相关的数据（如财务系统的数据域为财务信息，车辆管理系统的业务信息为车辆信息）；

2. 指针域，用于构建结点的链接关系。单链表的实现只需要一个指针。

单链表的形式如下：

如上图所示，该单链表共包含了4个结点，4个结点的数据域分别是28、52、2、96。每个结点还包含一个指针，指向下一个结点。最后一个结点的指针域置为“NULL”，表示后面没有结点了。

第一个结点的地址存放在一个指针变量 head 中（ head 指向链表第一个结点， head 本身不是一个结点）。访问该单链表只需要知道 head 的值就可以了，因为通过 head 可以访问到第一个结点，通过第一个结点的指针域可以访问第二个结点 …… 直到访问链表中所有的结点。

要实现上述链表，只需要定义如下结构：

// 定义结点结构
struct node
{
    
    
    int data;     // 数据域
    node * next;     // 指针域，指向下一个结点
};

如下程序可以构建上述图中链表（其中：每个结点都是 node 类型的一个结构变量，head 则是node*类型的指针）：

node a, b, c, d, *head;
head = &a;     // 让 head 指针指向结点 a
a.data = 28;     // 给 a 的数据域赋值
a.next = &b;     // 让 a 的指针域指向结点 b
b.data = 52;  b.next = &c;     // 给 b 的数据域赋值，并让 b 的指针域指向结点 c
c.data = 2;  c.next = &d;     // 给 c 的数据域赋值，并让 c 的指针域指向结点 d
d.data = 96;  d.next = NULL;     // 给 d 的数据域赋值，并将 d 的指针域置为 NULL，表示后面没有结点了

很显然，这样写程序比较麻烦，而且在不知道有多少结点的情况下也根本无法处理。怎么可以解决这个问题呢？

C 和 C++ 的内存动态分配方法可以很好的解决这个问题。C++ 提供了两种动态分配内存的方法：

1. C 语言提供的 malloc 和 free 函数，代码如下：

node *t = (node *)malloc(sizeof(node));
t->data = 2;
free(t);

• sizeof 是一个运算符，sizeof(node)用于计算并返回一个 node 类型变量所占内存空间的大小（字节数）；

• malloc(int n)用于申请动态分配 n 个字节大小的数据空间，并返回该空间的首地址；

• (node )是类型转换运算符，malloc 函数返回的地址是void类型，转换成node类型后赋值给指针变量 t（ t 的类型是node）。

所以上面第一条语句执行后，指针 t 指向一块动态分配的内存空间，该空间大小为一个 node 类型变量的大小。

第二条语句通过指针 t 访问该空间（当作 node 变量）的数据域 data，给它赋值为2。free 函数用于释放 t 指向的动态分配空间（不需要该空间后再释放）。

2. C++ 扩展的 new 和 delete 运算符，代码如下：

node *t = new node;
t->data = 2;
delete t;

---

//示例：模拟微信聊天框的动态存储（并且输出）
#include<iostream>
#include<cstring>
using namespace std;
int main(){
    
    
	char *sen[10];//指针类型的数组，十个地址
	char tmp[10240];//输入的文本不多于10240个字符
	int i;
	for(i=0;i<10;i++){
    
    
		cin.getline(tmp,10240);
		sen[i]=new char[strlen(tmp)+1];//加 1 是为了存储 '\0'，这里分配了动态的内存空间
		strcpy(sen[i],tmp);//拷贝到 sen[] 中
	}
	for(i=0;i<10;i++){
    
    
		cout<<sen[i]<<endl;
		delete[]sen[i];//每次输出后释放空间
	}
	return 0;
}

---

那么使用动态内存分配的方法实现上述的单链表的代码如下：

node *head, *t, *p; t = new node; // 动态分配一个 node 结点的空间，并让 t 指向它 
head = t; // 该结点是第一个结点，让 head 指向它 
t->data = 28; // 给第一个结点的数据域赋值 
p = new node; // 动态分配第二个 node 结点的空间，并让 p 指向它 
t->next = p; // 修改第一个结点的指针域为第二个结点的地址（第一个结点的指针域指向第二个结点） 
p->data = 52; // 给第二个结点的数据域赋值 
t=p; // 让 t 指向最后一个结点 
p = new node; // 动态分配第三个 node 结点的空间，并让 p 指向它（ p 不再指向第二个结点了） 
t->next = p; // 修改第二个结点的指针域为第三个结点的地址（第二个结点的指针域指向第三个结点） 
p->data = 2; // 给第三个结点的数据域赋值 
t = p; // 让 t 指向最后一个结点 
p = new node; // 动态分配第四个 node 结点的空间，并让 p 指向它（ p 不再指向第三个结点了） 
t->next = p; // 修改第三个结点的指针域为第四个结点的地址（第三个结点的指针域指向第四个结点） 
p->data = 96; // 给第四个结点的数据域赋值 
p->next = NULL; // 给第四个结点的指针域置为 NULL，表示后面没有结点了

上述程序语句虽然好像变多了，程序也好像变复杂了，但细读会发现这段程序可以很方便地改成循环，这样处理后其实是使得程序更简单了，并且适用于任意多个结点的情况。

改成循环后，单链表里面可能包含0个或多个结点，如果包含多个结点，则下面程序中的语句可以让指针 t 指向链表的最后一个结点，具体代码如下：

node *t = head;     // t 指向第一个结点
// 如果 t->next 不为 NULL，即后面还有结点
while(t->next != NULL)
{
    
    
    t = t->next;     // 把 t 指向结点的指针域（下一个结点地址）赋值给 t，t 指向下一个结点
}
// 循环结束时，t->next 为 NULL，即 t 指向的结点后面没有结点了。

栈

栈（ stack ）又名堆栈，是一种功能受限的线性表，具有先进后出的特性。

其限制为仅允许在线性表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。

向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；

从一个栈删除元素又称作出栈、弹栈或退栈，它是把栈顶元素删除掉，使其下面的元素成为新的栈顶元素。

接下来首先声明结构类型：

// 定义结点结构
struct node
{
    
    
    int data;     // 数据域
    node * next;     // 指针域，指向下一个结点
};
typedef node * intStack;  // 定义类型别名，intStack 即相当于 node*

定义 intStack 是为了使程序的可读性更好一些。