第二章 线性表
目录
0 前言
2.0 顺序表和单链表必须掌握的操作
顺序表：归并排序、二分（折半）查找
链表：头插法、尾插法、逆置法【头插/指针反转】、归并法、双指针法【常用于找中间结点】
共同操作：插入、删除（指定值/指定范围值）、查找、最值、逆置、合并
2.1 线性表的定义和基本操作
线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列
线性表的两种存储方式：
一、顺序存储————顺序表
二、链式存储:
指针实现：单链表、双链表、循环链表
数组实现：静态链表
线性表的基本操作：
2.2 线性表的顺序表示
顺序表的存储密度高，每个结点只存储数据元素。
顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除操作需要移动大量元素
顺序表最主要的特点是随机访问，即通过首地址和元素序号可在时间 O(1) 内找到指定的元素。【即随机存取方式】
随机存取方式说明：
可以通过存储在线性表中的第一个数据元素的地址，找到任意位置的数据元素。
设线性表L存储的起始位置为：LOC(A)【A即为A0】，sizeof(ElemType)是每个数据元素所占用存储空间的大小，则：
LOC（An）= LOC（A）+ (n-1)×sizeof(ElemType)
顺序表的两种分配方式：静态存储和动态存储
其中动态存储分配空间的大小可以在运行时决定
#define MAXSIZE 50
#define InitSize 100
/*一、数组静态分配*/
/*结构体struct，将多个基本数据类型组合在一起形成新的数据类型*/
typedef struct {
ElemType data[MAXSIZE]; //数组，存储数据元素
int length; //线性表当前长度
}SqList; //该结构体数据类型的名字
/*二、数组动态分配*/
typedef struct {
ElemType *data; //数组，存储数据元素
int length; // 线性表当前长度
}SqList;
//动态分配语句
L.data = (Elemtype*)malloc(sizeof(ElemType)*InitSize)) //C语言
L.data = new ElemType[InitSize]; //C++
2.3 线性表的链式表示
链式存储线性表，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻。
因此插入和删除不需要移动元素，而只需修改指针，但是，也会失去顺序表随机存取的优点。
由于单链表元素离散地分布在存储空间中，所以单链表是非随机存取的存储结构（即不能找到表中某个特定的结点，需从头遍历）
头结点、头指针、首元结点区别：
头结点是带头结点的链表中的第一个结点，通常不存储信息（数据）
头指针始终指向链表的第一个结点
首元结点链表中的第一个数据元素结点
链表的结点类型表示：
typedef int ElemType;
//单链表结点类型
typedef struct LNode //定义单链表结点类型
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode;
typedef struct LNode *LinkList; /* 定义LinkList ,可在LNode结构体后面简写*/
//双链表结点类型
typedef struct DNode //定义双链表结点类型
{
ElemType data; //数据域
struct DNode *prior,*next; //前驱和后继指针
}DNode,*DLinkList;
//静态链表
#define MaxSize 50 //静态链表的最大长度
typedef struct //定义单链表结点类型
{
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
}SLinkList[MaxSize];
//静态链表以 next == -1 作为结束的标志
链表的前插的两种方法：【通常是后插】
//方法一
GetElem(L,i-1); //查找插入位置的前驱结点
/如果颠倒的话就相当于s->next = s
s->next = p->next; //将p的后继结点赋值给s的后继
p->next = s; //将s赋值给p的后继
//方法二
s->next = p->next; //修改指针域，不能颠倒
p->next = s;
temp = p->data; //交换数据域部分
p->data = s->data;
s->data = temp;
删除同理
循环链表判空：
2.4 顺序表和链表的比较与选取
1.存取(读写)方式
顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。例如在第i个位置上执行存或取的操作，顺序表仅需一次访问，而链表则需从表头开始依次访问i次。
2.逻辑结构与物理结构
采用顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻。而采用链式存储时，逻辑上相邻的元素，物理存储位置则不一定相邻，对应的逻辑关系是通过指针链接来表示的。
3.查找，插入和删除操作
对于插入操作：
顺序表通常（默认）是前插操作
链表通常（默认）是后插操作
对于按值查找：
顺序表无序时，两者的时间复杂度均为O(n);
顺序表有序时，可采用折半查找，此时的时间复杂度为O(log₂n)。
对于按序号查找：
顺序表支持随机访问，时间复杂度仅为O(1)，
而链表的平均时间复杂度为O(n)。
顺序表的插入、删除操作，平均需要移动半个表长的元素。
链表的插入、删除操作，只需修改相关结点的指针域即可。由于链表的每个结点都带有指针域，故而存储密度不够大。
4.空间分配
顺序存储:
静态存储分配情形下，一旦存储空间装满就不能扩充，若再加入新元素，则会出现内存溢出，因此需要预先分配足够大的存储空间。
预先分配过大，可能会导致顺序表后部大量闲置;预先分配过小，又会造成溢出。
动态存储分配虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且若内存中没有更大块的连续存储空间，则会导致分配失败。
链式存储:
结点空间只在需要时申请分配，只要内存有空间就可以分配，操作灵活、高效。
实际中选取存储结构：
1.基于存储的考虑
存储密度（Storage Density）是指结点数据本身所占的存储量和整个结点结构所占的存储量之比，即：
存储密度=（结点数据本身所占的存储量）/（结点结构所占的存储总量）
难以估计线性表的长度或存储规模时，不宜采用顺序表;链表不用事先估计存储规模，但链表的存储密度较低，显然链式存储结构的存储密度是小于1的。
2.基于运算的考虑
在顺序表中按序号访问 ai 的时间复杂度为O(1)，而链表中按序号访问的时间复杂度为O(n),因此若经常做的运算是按序号访问数据元素，则显然顺序表优于链表。
在顺序表中进行插入、删除操作时，平均移动表中一半的元素，当数据元素的信息量较大且表较长时，这一点是不应忽视的;
在链表中进行插入、删除操作时，虽然也要找插入位置，但操作主要是比较操作，从这个角度考虑显然后者优于前者。
3.基于环境的考虑
顺序表容易实现，任何高级语言中都有数组类型;链表的操作是基于指针的，相对来讲，前者实现较为简单，这也是用户考虑的一个因素。
2.2.3 综合应用题：（P19-T1~P21-T13）
T0 List.h / List.cpp
#ifndef LIST_H
#define LIST_H
#include"stdio.h"
#include<windows.h>
#define MAXSIZE 50 //存储空间初始分配量
/*函数结果状态*/
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status; //Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int ElemType;//ElemType类型根据实际情况而定，这里假设为int
/*数组分配方式*/
//①数组静态分配
/*结构体struct，将多个基本数据类型组合在一起形成新的数据类型*/
typedef struct {
ElemType data[MAXSIZE]; //数组，存储数据元素
int length; //线性表当前长度
}SqList; //该结构体数据类型的名字
//*②数组动态分配*/
//L.data = (Elemtype*)mallo(sizeof(ElemType)*InitSize))
//L.data = new ElemType[InitSize];
//typedef struct {
// ElemType *data; //数组，存储数据元素
// int length; // 线性表当前长度
//}SqList;
/*九大操作*/
//①初始化顺序线性表
Status InitList(SqList& L);
//②判断表是否为空
//初始条件：顺序线性表L已存在。
//操作结果：若L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty(SqList L);
//③将L重置为空表
//初始条件：顺序线性表L已存在。
//操作结果：将L重置为空表
Status ClearList(SqList &L);
//④返回L中数据元素个数
//初始条件：顺序线性表L已存在。
//操作结果：返回L中数据元素个数
Status ListLength(SqList L);
//⑤返回L中第i个数据元素的值
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
//操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始
Status GetElem(SqList L, int i, ElemType& e);
//⑥返回L中第1个与e满足关系的数据元素的位序
//初始条件：顺序线性表L已存在
//操作结果：返回L中第1个与e满足关系的数据元素的位序。若这样的数据元素不存在，则返回值为0
int LocateElem(SqList L, ElemType e);
//⑦在第i个数据之前插入数据e
//初始条件：顺序线性表L已存在,1≤i≤ListLength(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/*在函数体内部进行操作其实是作用于一个局部变量，如果不用“&”操作，那么我们不能把插入操作真正作用于传入的顺序表上
使用“&”说明：要对数据进行修改时【例如赋值】就用“&”，不用对输入参数进行修改【例如查询】就不用“&”*/
Status ListInsert(SqList& L, int i, ElemType e);
//⑧删除L的第i个数据元素
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList& L, int i, ElemType& e);
Status visit(ElemType c);
//⑨遍历线性表
//初始条件：顺序线性表L已存在
//操作结果：依次对L的每个数据元素输出
Status ListTraverse(SqList L);
//线性表La和线性表Lb并集操作【La∪Lb】
void Union(SqList La, SqList Lb);
#endif
#include<stdio.h>
#include"List.h"
/*九大操作*/
//一、初始化顺序线性表
Status InitList(SqList& L)
{
L.length = 0;****************
return OK;
}
//二、判断表是否为空
//初始条件：顺序线性表L已存在。
//操作结果：若L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty(SqList L)
{
if (L.length == 0)
return TRUE;
else
return FALSE;
}
//三、将L重置为空表
//初始条件：顺序线性表L已存在。
//操作结果：将L重置为空表
Status ClearList(SqList &L)
{
L.length = 0;
return OK;
}
//四、返回L中数据元素个数
//初始条件：顺序线性表L已存在。
//操作结果：返回L中数据元素个数
Status ListLength(SqList L)
{
return L.length;
}
//五、返回L中第i个数据元素的值
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
//操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始
Status GetElem(SqList L, int i, ElemType& e)
{
if (i >L.length || i <1 || L.length == 0)
return ERROR;
e = L.data[i - 1];
return OK;
}
//六、返回L中第1个与e满足关系的数据元素的位序
//初始条件：顺序线性表L已存在
//操作结果：返回L中第1个与e满足关系的数据元素的位序。若这样的数据元素不存在，则返回值为0
//时间复杂度为：T(n) = O(n)
int LocateElem(SqList L, ElemType e)
{
int i;
if (L.length == 0)
return 0;
for (i = 0; i < L.length; i++)
{
if (L.data[i] == e)
break;
}
//如果遍历完后数组中没有数等于e，那么结果返回0
if (i >= L.length)
return 0;
return i + 1;
}
//七、在第i个数据之前插入数据e
//初始条件：顺序线性表L已存在,1≤i≤ListLength(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/*在函数体内部进行操作其实是作用于一个局部变量，如果不用“&”操作，那么我们不能把插入操作真正作用于传入的顺序表上
使用“&”说明：要对数据进行修改时【例如赋值】就用“&”，不用对输入参数进行修改【例如查询】就不用“&”*/
Status ListInsert(SqList& L, int i, ElemType e)
{
//当i比第一位置小或者比最后一位置后一位置【初始化时表为0，要从头（第1个位置）开始插入】还要大时
if (i<1 || i>L.length+1)
return ERROR;
if (L.length == MAXSIZE)
return ERROR;
for (int j = L.length; j >= i; j--)
L.data[j] = L.data[j - 1];
L.data[i-1] = e;
L.length++;
return OK;
}
//八、删除L的第i个数据元素
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList& L, int i, ElemType& e)
{
if (i<1 || i>L.length)
return ERROR;
e = L.data[i-1];
for (int j = i; j < L.length; j++)
L.data[j - 1] = L.data[j];
L.length--;
return OK;
}
Status visit(ElemType c)
{
printf("%d ", c);
return OK;
}
//九、遍历线性表
//初始条件：顺序线性表L已存在
//操作结果：依次对L的每个数据元素输出
Status ListTraverse(SqList L)
{
int i;
for (i = 0; i < L.length; i++)
visit(L.data[i]);
printf("\n");
return OK;
}
//线性表La和线性表Lb并集操作【La∪Lb】
void Union(SqList La, SqList Lb)
{
}
/* 测试代码，可新建main.cpp文件运行 */
// int main()
// {
// SqList L;
// //SqList Lb;
// ElemType e;
// Status i;
// int j, k;
// i = InitList(L);
// printf("\n初始化L后：L.length=%d\n", L.length);
// for (j = 1; j <= 5; j++)
// i = ListInsert(L, 1, j);
// printf("\n在L的表头依次插入1～5后：L.data=");
// ListTraverse(L);
// printf("L.length=%d \n", L.length);
// i = ListEmpty(L);
// printf("\nL是否空：i=%d(1:是 0:否)\n", i);
// i = ClearList(L);
// printf("清空L后：L.length=%d\n", L.length);
// i = ListEmpty(L);
// printf("L是否空：i=%d(1:是 0:否)\n", i);
// for (j = 1; j <= 10; j++)
// ListInsert(L, j, j);
// printf("\n在L的表尾依次插入1～10后：L.data=");
// ListTraverse(L);
// printf("L.length=%d \n", L.length);
// ListInsert(L, 1, 0);
// printf("在L的表头插入0后：L.data=");
// ListTraverse(L);
// printf("L.length=%d \n", L.length);
// GetElem(L, 5, e);
// printf("\n第5个元素的值为：%d\n", e);
// for (j = 3; j <= 4; j++)
// {
// k = LocateElem(L, j);
// if (k)
// printf("\n第%d个元素的值为%d\n", k, j);
// else
// printf("\n没有值为%d的元素\n", j);
// }
// k = ListLength(L); /* k为表长 */
// for (j = k + 1; j >= k; j--)
// {
// i = ListDelete(L, j, e); /* 删除第j个数据 */
// if (i == ERROR)
// printf("\n删除第%d个数据失败\n", j);
// else
// printf("\n删除第%d个的元素值为：%d\n", j, e);
// }
// printf("依次输出L的元素：");
// ListTraverse(L);
// j = 5;
// ListDelete(L, j, e); /* 删除第5个数据 */
// printf("删除第%d个的元素值为：%d\n", j, e);
// printf("依次输出L的元素：");
// ListTraverse(L);
// system("pause");
// return 0;
// ////构造一个有10个数的Lb
// //i = InitList(&Lb);
// //for (j = 6; j <= 15; j++)
// // i = ListInsert(&Lb, 1, j);
// //Union(&L, Lb);
// //printf("依次输出合并了Lb的L的元素：");
// //ListTraverse(L);
// }
T1
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T1：
从序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素（value）的值。
空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行 */
/* 自己做的 */
/* 如果顺序表为空，那么返回0，否则返回被删元素值e */
int Delete_Min(SqList &L,ElemType &e)
{
// if(L.data == 0) return -1; /* 错误一：此处错写成L.data == 0 导致运行结果错误，正解为L.length == 0*/
if(L.length == 0) return -1;
e = L.data[0];
int j;
for(int i=0;i<L.length;i++)
{
if(e > L.data[i]) e = L.data[i];
j = i;
}
L.data[j] = L.data[L.length-1];
L.length--;
return e;
}
/* 参考答案 */
bool Del_Min(SqList &L,ElemType &value)
{
//删除顺序表L中最小值元素结点，并通过引用型参数value返回其值
//若删除成功，则返回true，否则返回false
if(L.length == 0) //表空，中止操作返回
return false;
value = L.data[0]; //初始化value值
int pos = 0; //假定0号元素的值最小，作用：标记最小元素位置
for(int i = 0; i < L.length; i++) //循环作用：让value记忆当前具有最小值的元素。 【注：此处for循环括号可省略】
{
if(L.data[i] < value)
{
value = L.data[i];
pos = i;
}
}
L.data[pos] = L.data[L.length-1]; //空出的位置由最后一个元素填补
L.length--;
return true;
}
/* 主函数 */
int main()
{
/* 初始化SqList顺序表，其中L1为空表，L2表中含有值为3、1、2的三个元素 */
SqList L1;
SqList L2;
InitList(L1);
InitList(L2);
/* 声明value值 */
int value;
/* 向L2表头插入0、1、2 */
for(int i=0;i<3;i++)
{
ListInsert(L2,1,i);
}
printf("L1: ");
ListTraverse(L1);
printf("L2: ");
ListTraverse(L2);
/* 自己做的 */
printf("L1: ");
printf((Delete_Min(L1,value) == -1) ? "Error ,List is null or value don't exist" : "L1 min = %d",value);
printf("\nL2: ");
printf((Delete_Min(L2,value) == -1) ? "Error ,List is null or value don't exist" : "L2 min = %d\n",value);
/* 参考答案 */
// if(Del_Min(L1,value))
// {
// printf("L1: ");
// ListTraverse(L1);
// printf("L1 min = %d\n",value);
// }else
// {
// printf("Error ,List is null or value don't exist\n");
// }
// if(Del_Min(L2,value))
// {
// printf("L2:");
// ListTraverse(L2);
// printf("L2 min = %d\n",value);
// }else
// {
// printf("Error ,List is null or value don't exist\n");
// }
system("pause");
}
T2
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T2:
设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为 O(1) */
/* 分析：空间复杂度说明
如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，可表示为 O(1)。
int i = 1;
int j = 2;
++i;
j++;
int m = i + j;
第一行new了一个数组出来，这个数据占用的大小为n，后面虽然有循环，但没有再分配新的空间所以空间复杂度为 S(n) = O(n)，以此类推二维数组S(n) = O(n^2)
int[] m = new int[n]
for(i = 1; i <= n; ++i) {
j = i;
j++;
}
*/
/* 参考答案 */
void Reverse(SqList &L)
{
ElemType temp;
for(int i=0;i<(L.length-1)/2;i++)
{
temp = L.data[i];
L.data[i] = L.data[L.length-1-i];
L.data[L.length-1-i] = temp;
}
}
int main()
{
/* 初始化SqList，L1：元素奇数个，L2：元素偶数个 */
SqList L1;
SqList L2;
InitList(L1);
InitList(L2);
/* 往L1中插入1~9 */
printf("L1:");
for(int i=1;i<10;i++)
{
ListInsert(L1,1,i);
}
ListTraverse(L1);
/* 往L2中插入1~10 */
printf("L2:");
for(int i=1;i<=10;i++)
{
ListInsert(L2,1,i);
}
ListTraverse(L2);
/* 参考答案 */
Reverse(L1);
printf("Reverse L1:\n");
ListTraverse(L1);
Reverse(L2);
printf("Reverse L2:\n");
ListTraverse(L2);
system("pause");
}
T3
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T3:【P19-T4~P19-T5的基本形式】
对长度为n的顺序表L，编写一个时间复杂度为 O(n)、空间复杂度为 O(1)的算法，该算法删除线性表中所有值为x的数据元素 */
/* 自己做的 */
//2020/5/22 23：20 错解！！！！！，仅仅只是把值为e的位序与靠后的位序交换，没有考虑到它们中间还有其他值不为e的数字
//--------------------------------------------华丽的分割线------------------------=------------------------
//2020/5/22 15：37
//【错解】本人思路：将等于x的值放到表的前面，当遍历表L时，每次循环L表中等于x的数据元素都放在后面并且截断1个表长，最后获取前面的所有元素
// void Delete_X(SqList &L,ElemType e)
// {
// int pos = L.length-1; //值为（表长-1）【数组下标从零开始】 标记符号作用：将得到的值为x的数据元素放到后面
// for(int i=0;i<L.length;i++)
// {
// if(L.data[i] == e)
// {
// L.data[i] = L.data[pos];
// pos--;
// L.length--;
// }
// }
// }
/* 参考答案1 */
//思路1：将不等于x的值放到表的前面，当遍历完表L时，L表中不等于x的数据元素都在前面，等于x的数据元素都在后面，再截取L.length = k，获取前面的所有元素
//形象说明：找到一个不为x的数就把它放到表前面，再找到一个把紧接着上一个放，直到找完所有数。【最后找到多少数表长就是多少】
void del_x_1(SqList &L,ElemType x)
{
int k = 0; //记录值不等于x的元素个数
for(int i=0;i<L.length;i++)
if(L.data[i] != x)
{
L.data[k] = L.data[i];
k++; //不等于x的元素加1
}
L.length = k;
}
/* 参考答案2 */
//与思路1差不多
void del_x_2(SqList &L,ElemType x)
{
int k = 0,i = 0; //k记录值等于x的元素个数和位序
while(i<L.length){
if(L.data[i] == x)
k++; //等于x的元素加1
else //如果元素不等于x，将当前元素前移k个位置【本质上还是将 “值不为x的元素放到前面”】
L.data[i-k] = L.data[i]; //这里面用的很巧妙【详细说明见Excellent.md文件第一点】
i++;
}
L.length = L.length - k; //顺序表L的长度减k
}
/* 参考答案3————请读者自行尝试 */
//思路3：设置头尾两个指针（i = 1,j = n）,从两端向中间移动，凡遇到最左端值为x的元素时，直接将最右端非x的元素左移至值为x的数据元素位置，直至相遇
void del_x_3(SqList &L,ElemType e)
{
}
/* 主函数 */
int main()
{
/* 初始化一个长度为n的线性表L,并赋予它数据元素 */
SqList L;
ElemType e1 = 1,e2 = 4;
InitList(L);
for(int i=0;i<5;i++)
ListInsert(L,1,i);
ListInsert(L,2,1);
ListInsert(L,2,5);
ListInsert(L,1,4);
printf("L: ");
ListTraverse(L);
/* 测试函数 */
printf("After delete %d , L: ",e1);
// del_x_1(L,e1);
del_x_2(L,e1);
ListTraverse(L);
printf("Then after delete %d , L: ",e2);
// del_x_1(L,e2);
del_x_2(L,e2);
ListTraverse(L);
system("pause");
}
T4
#include <stdio.h>
#include <windows.h>
// #include <iostream>
// using namespace std;
// #include <algorithm> //sort函数只能在C++下才能使用 std::sort(a,a+L.length);
#include "List.h"
#include "List.cpp"
/* P19-T4:
从 “有序” 顺序表中删除其值在给定值s与t之间（要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行 */
/* 自己做的 */
void Delete_st(SqList &L,ElemType s,ElemType t)
{
int k = 0; //标识符号作用：将在（s，t）范围之外的值放到顺序表的前面
for(int i=0;i<L.length;i++)
{
if(L.data[i]<s || L.data[i]>t)
{
L.data[k] = L.data[i];
k++;
}
}
L.length = k; //压缩空间为（s，t）范围之外的值所包含的空间
//不建议在函数中写输出语句，最好将返回值设定为bool类型或int类型，由返回值在主函数中确定不同的输出
if(s>=t)
printf("s and t are unresonable\n");
if(L.length==0)
printf("List is null\n");
}
/* 参考答案 */
//注意：本参考答案要求表为“有序”【从小到大排序】顺序表
bool Del_s_t2(SqList &L,ElemType s,ElemType t)
{
int i,j;
if(s>=t||L.length==0)
return false;
for(i=0;i<L.length && L.data[i]<s;i++); //循环作用：寻找大于等于s的第一个元素，运行出来后的L.data[i]>s
if(i>=L.length) return false; //所有元素值均小于s，返回false，个人感觉不需要
for(j=i;j<L.length && L.data[j]<=t;j++); //循环作用：寻找大于t的第一个元素，运行出来后的L.data[j]>t
for(;j<L.length;i++,j++)
L.data[i] = L.data[j]; //前移，填补被删元素位置
L.length = i; //L.data[i] 到 L.data[j-1]是被删除的部分，此时的i在L.data[i]>s的基础上累加
return true;
}
/* 主函数 */
int main()
{
/* 初始化长度为n的线性表L，L1,并赋予它们数据元素 */
SqList L,L1;
InitList(L);
InitList(L1);
for(int i=0;i<8;i++)
{
ListInsert(L,1,i);
ListInsert(L1,1,7-i);
}
printf("L: ");
ListTraverse(L);
printf("L1: ");
ListTraverse(L1);
/* 测试函数 */
/* 自己做的 */
//删除指定区域后L表数据元素
printf("after delete designated area , L:\n");
Delete_st(L,2,6);
ListTraverse(L);
Delete_st(L,6,2);
/* 参考答案 */
printf("\nafter delete designated area , L1:\n");
Del_s_t2(L1,2,6); //有序顺序表，只能是从小到大顺序排列的此函数才可用
ListTraverse(L1);
system("pause");
}
T5
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T5:【本例以及P19-T4都可以参考P19-T3，它们的区别就是一个删除一个确定数，另外两个删除一群在要求范围内的数】
从 顺序表 中删除其值在给定值s与t之间（包含s和t,要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行 */
/* 自己做的【同P19-T4】 */
void Delete_st(SqList &L,ElemType s,ElemType t)
{
int k = 0; //标识符号作用：将在（s，t）范围之外的值放到顺序表的前面
for(int i=0;i<L.length;i++)
{
if(L.data[i]<s || L.data[i]>t)
{
L.data[k] = L.data[i];
k++;
}
}
L.length = k; //压缩空间为（s，t）范围之外的值所包含的空间
if(s>=t)
printf("s and t are unresonable\n");
if(L.length==0)
printf("List is null\n");
}
/* 参考答案 */
bool Del_s_t(SqList &L,ElemType s,ElemType t)
{
int i,k = 0; //标记符号k作用：1、记录在（s,t）范围内的值的个数； 2、（s,t）范围内值的位序,用于前移动元素
if(L.length==0||s>=t)
return false; //线性表为空或s，t不合法，返回
for(i=0;i<L.length;i++) //循环作用：
{
if(L.data[i]>=s && L.data[i]<=t)
k++;
else //当前元素前移k个位置
L.data[i-k] = L.data[i]; //这里面用的很巧妙【详细说明见Excellent.md文件第一点】
}
L.length -= k; //长度减小k【因为有k个值为(s,t)内的数需要删除】
}
/* 主函数 */
int main()
{
/* 初始化一个长度为n的线性表L,并赋予它数据元素 */
SqList L;
InitList(L);
for(int i=0;i<8;i++)
ListInsert(L,1,(i-2)*(i-2)+i+1); //确保顺序表无序
printf("L: ");
ListTraverse(L);
/* 测试函数 */
/* 自己做的 */
printf("after delete designated area , L:");
Delete_st(L,2,6);
ListTraverse(L);
Delete_st(L,6,2);
/* 参考答案 */
printf("delete designated area again , L:");
Del_s_t(L,3,15);
ListTraverse(L);
system("pause");
}
T6
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T6:
从“有序”顺序表中删除所有其值重复的元素，使表中所有元素的值均不同
歧义：一、删除所有其值重复的元素（全部删除）
二、删除所有其值重复的元素（保留一个）*/
/* 参考答案 */
//最后所有重复值保留一个。。。题目有歧义
bool Delete_Same(SqList &L)
{
if(L.length==0) return false;
int i,j; //i存储第一个不相同的元素，j为工作指针
for(i=0,j=1;j<L.length;j++)
{
if(L.data[i]!=L.data[j]) //查找下一个与上一个元素值不同的元素
L.data[++i] = L.data[j];//找到后将元素前移
}
L.length = i + 1;
return true;
}
/* 参考答案提示————请读者自行尝试 */
//使用散列表实现（有序和无序都行）顺序表中删除所有其值重复的元素
/* 主函数 */
int main()
{
/* 初始化一个长度为n的线性表L,并赋予它数据元素 */
SqList L,L1;
InitList(L);
ListInsert(L,1,5);
ListInsert(L,1,4);
ListInsert(L,1,4);
ListInsert(L,1,3);
ListInsert(L,1,3);
ListInsert(L,1,3);
ListInsert(L,1,2);
ListInsert(L,1,2);
ListInsert(L,1,2);
ListInsert(L,1,2);
ListInsert(L,1,1);
printf("L: ");
ListTraverse(L);
/* 测试函数 */
printf("after delete repeated value ,L:\n");
// Delete_repeat(L);
Delete_Same(L);
ListTraverse(L);
system("pause");
}
T7
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T7:
将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表 */
/* 自己做的 时间复杂度 T(n) = O(n)*/
void List_Union(SqList &L,SqList La,SqList Lb)
{
int i = 0,j = 0,k = 0; //标记符号作用：给L.data依次赋予La表和Lb表中较小的值，当一个表遍历完时，将另外一个表的剩余值加到剩余的L表后面
for(;j<Lb.length;k++) //循环作用：La表和Lb表之间相互比较，小者放入L表中，直到其中一个表遍历完毕
{
if(La.data[i]<Lb.data[j])
{
L.data[k] = La.data[i];
i++;
}
else
{
L.data[k] = Lb.data[j];
j++;
}
if(i==La.length||j==Lb.length)
break;
}
//将剩下的为遍历完的表的数据全部放到L表的后面
if(i==La.length){
for(int p=j;p<Lb.length;p++)
{
L.data[k] = Lb.data[p];
k++;
}
}
else{
for(int q=j;q<L.length;q++)
{
L.data[k] = La.data[q];
k++;
}
}
L.length = k;
}
/* 参考答案 */
bool Merge(SqList A,SqList B,SqList &C)
{
//大于顺序表的最大长度
if(A.length+B.length>C.length)
return false;
int i = 0,j = 0,k = 0;
while(i<A.length && j<B.length) //循环作用：两两比较，小者存入结果表
{
if(A.data[i]<=B.data[j])
C.data[k++] = A.data[i++];
else
C.data[k++] = B.data[j++];
}
//还剩下一个没有比较完的顺序表，直接把剩下的元素加到C表中
while(i<A.length)
C.data[k++] = A.data[i++];
while(j<B.length)
C.data[k++] = B.data[j++];
C.length = k;
return true;
}
/* 主函数 */
int main()
{
/* 初始化有序顺序表La,Lb和待合并表L */
SqList L;
SqList La;
SqList Lb;
InitList(La);
InitList(Lb);
for(int i=14;i>=4;i=i-2)
ListInsert(La, 1, i);
for(int j=15;j>=5;j=j-2)
ListInsert(Lb, 1, j);
L.length = 50;
printf("La: ");
ListTraverse(La);
printf("Lb: ");
ListTraverse(Lb);
/* 测试函数 */
List_Union(L,La,Lb);
// Merge(La,Lb,L);
printf("L: ");
ListTraverse(L);
system("pause");
}
T8
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P19-T8:
已知在一维数组A[m+n]中依次存放两个线性表（a1，a2，a3，……，am）和（b1，b2，b3，……，bn）。
试编写一个函数，将数组中两个顺序表的位置互换
换种思路理解就是：将调换数组A的前m个元素和后n个元素调换顺序*/
/* 自己做的 */
void Exchange_A(int m,int n,int A[],SqList &L)
{
for(int i=0;i<n;i++)
L.data[i] = A[m+i];
for(int j=n;j<n+m;j++)
L.data[j] = A[j-n];
L.length = m + n;
}
/* 参考答案 */
//全部元素原地逆置
void Reverse(int A[],int left,int right,int arraysize)
{
if(left>=right||right>=arraysize)
return ;
int mid = (left+right)/2;
for(int i=0;i<=mid-left;i++) //循环作用：C语言 对0.5处小数实行退一法，故i<=mid-left(等于号不能掉)
{
int temp = A[left+i];
A[left+i] = A[right-i];
A[right-i] = temp;
}
}
//将A表和B表位置逆置
void Exchange(int A[],int m,int n,int arraysize)
{
Reverse(A,0,m+n-1,arraysize); //先整体逆置，此时B（倒序）在前，A（倒序）在后
Reverse(A,0,n-1,arraysize); //再局部逆置前半部分，此时B在前，A（倒序）在后
Reverse(A,n,m+n-1,arraysize); //最后局部逆置后半部分，此时B在前，A在后
}
/* 主函数 */
int main()
{
/* 初始化数组和表 */
SqList L;
InitList(L);
int A[10]={1,5,8,4,6,9,11,20,34,6};
for(int i=0;i<sizeof(A)/sizeof(A[0]);i++)
printf("%d ",A[i]);
// /* 测试C语言对于在0.5处的小数的强制转化为int类型的进位方式————退一法 */
// printf("\n(5+4)/2 = %d",(5+4)/2); //结果为4，退一法
/* 测试函数 */
/* 自己做的 */
printf("\nExchange:\n");
Exchange_A(5,5,A,L);
ListTraverse(L);
/* 参考答案 */
printf("\nExchange:\n");
Exchange(A,5,5,10);
for(int i=0;i<sizeof(A)/sizeof(A[0]);i++)
printf("%d ",A[i]);
system("pause");
return 0;
}
T9
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P20-T9：
线性表（a1，a2，a3，……，an）中的元素递增有序且按顺序存储于计算机内。要求设计一算法：
完成用最少时间在表中查找数值为x的元素，若找到则将其与后置元素位置相交换，若找不到则将其插入表中并使表中的元素仍递增有序
该函数设计的有问题，当交换值后再想做到递增有序就无法实现，即：只能交换功能使用后这函数就废了 */
/* 自己做的 */
//【顺序查找】————没能在最少时间查找到x，不合格！！！！
// void GetOrInsert(SqList &L,ElemType x)
// {
// int mark = 0; //标记符号作用：用于确定给定的数据元素是否被找到 0：没被找到 1：被找到
// for(int i=0;i<L.length;i++)
// {
// //找到则将其与后置元素位置相交换
// if(L.data[i]==x&&i!=L.length-1)
// {
// int t = L.data[i];
// L.data[i] = L.data[i+1];
// L.data[i+1] = t;
// mark = 1;
// break; //必须退出循环，否则下一次又会把L.data[i+1]与其后置元素替换，直到替换到最后一个
// }
// }
// if(mark == 0){
// //将x插入表中并使表中的元素仍递增有序
// for(int j=0;j<L.length;j++)
// {
// //如果x介于L.data[j]与L.data[j+1]之间，表长加1，L.data[j+1]及其后面的数据元素后移一位
// if(x>L.data[j]&&x<L.data[j+1])
// {
// L.length++;
// for(int k=L.length;k>=j+1;k--)
// L.data[k] = L.data[k-1];
// L.data[j+1] = x;
// }
// }
// }
// }
/* 参考答案————将答案给的数组类型换成顺序表结构体类型 */
//折半查找
void SearchExchangeInsert(SqList &L,ElemType x)
{
int n = L.length; //顺序表长度
int low = 0,high = n-1,mid;
while(low<=high)
{
mid = (low + high)/2; //找中间位置
if(L.data[mid]==x) break; //找到x退出while循环
else if(L.data[mid]<x) low = mid + 1; //到中点mid的右半部去查
else high = mid - 1; //到终点mid的左半部去查
}
//下面两个if语句只会执行一个
if(L.data[mid]==x&&mid!=n-1) //若最后一个元素与x相等，则不存在其与后继交换的操作
{
ElemType t = L.data[mid];
L.data[mid] = L.data[mid+1];
L.data[mid+1] = t;
}
if(low>high)
{
int i;
L.length++;
for(i=n;i>high;i--)
L.data[i+1] = L.data[i];
L.data[i+1] = x;
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
SqList L;
int A[10];
InitList(L);
for(int i=9;i>=1;i=i-2)
ListInsert(L,1,i);
printf("L: ");
ListTraverse(L);
/* 测试函数 */
/* 自己做的 */
printf("L query 4:\n");
// GetOrInsert(L,4);
SearchExchangeInsert(L,4);
ListTraverse(L);
printf("L query 3:\n");
// GetOrInsert(L,3);
SearchExchangeInsert(L,3);
ListTraverse(L);
// /* 测试函数的问题 */
// printf("L query 6:\n");
// // GetOrInsert(L,6);
// SearchExchangeInsert(L,6); //再插入无法做到递增有序
ListTraverse(L);
system("pause");
}
T10【2010统考真题】
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P20-T10：
设将n（n>1）个整数存放在一维数组R中。试设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移P（0<P<n）个位置。
即将R中的数据(X0,X1…..Xn-1)循环左移P个位置后，变换为(Xp, Xp+1,…..Xn-1 , X0,X1……Xp-1) */
/* 自己做的 */
//Tn = O(n) S(n) = O(p)
void leftShift(int A[],int p,int n)
{
int B[p]; //数组B记录前面p个数
for(int i=0;i<n;i++) //循环作用：遍历数组，将数组元素循环左移 【执行n次】
{
//如果数组下标大于等于左移位置数，将数组左移位置数的下标开始循环左移
if(p<=i)
A[i-p] = A[i];
else
B[i] = A[i]; //存储前p个数
}
for(int j=n-p;j<n;j++) //【执行p次】
{
A[j] = B[j-n+p]; //B[j-n+p]就是B[j-(n-p)]，为了取到从0到p-1的数组所存储的数（p个）
}
}
/* 参考答案 */
//Tn = O(n) S(n) = O(1)
//逆置算法
void Reverse(int R[],int from,int to)
{
int temp,i;
for(i=0;i<(to-from+1)/2;i++)
{
temp=R[from+i];
R[from+i]=R[to-i];
R[to-i]=temp;
}
}
//调用三次逆置算法
void Converse(int R[],int n,int p)
{
Reverse(R,0,p-1); //逆置前半部分
Reverse(R,p,n-1); //逆置后半部分
Reverse(R,0,n-1); //全部逆置，完成循环左移操作
}
/* 主函数 */
int main()
{
/* 初始化数组 */
int A[7] = {0,1,2,3,4,5,6};
int p = 3;
int n = sizeof(A)/sizeof(A[0]);
printf("Array A: ");
for(int i=0;i<n;i++)
printf("%d ",A[i]);
/* 测试函数 */
// leftShift(A,p,n);
Converse(A,n,p);
printf("\nAfter left shift , Array A: ");
for(int i=0;i<n;i++)
printf("%d ",A[i]);
system("pause");
}
T11【2011统考真题】
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P20-T11：
一个长度为L(L≥1)的升序序列S，处在第[L/2]个位置的数称为S的中位数。例如，若序列S1=(11，13，15，17，19)，则S1中的中位数是15。
两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2，4，6，8，20)，则S1和S2的中位数是11。
现有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。
*/
/* 自己做的 */
//Tn = O(n) S(n) = O(n)
//思路：先求两个序列的并集，然后并集的第L-1个位置(第L个数)即为中位数
int Medium_AB(int A[],int B[],int n) //n为A、B两个数组的长度
{
int C[2*n],j = 0,k = 0; //空间消耗：2n+2
for(int i=0;i<2*n;i++) //循环作用：合并AB表，执行次数2n
{
if(A[j]<=B[k]) {C[i] = A[j]; j++; }
else {C[i] = B[k]; k++; }
}
return C[n-1]; //返回中位数
}
/* 参考答案 */
//Tn = O(log2(n)) S(n) = O(1)
//分别求两个序列A、B的中位数，设为 a 和 b，比较a和b
int middle_search(int A[],int B[],int n)
{
int m1,m2,s1,s2,d1,d2;
s1 = s2 = 0; //A、B的首位数
d1 = d2 = n-1; //A、B的末位数
while(s1!=d1||s2!=d2)
{
m1 = (s1+d1)/2;
m2 = (s2+d2)/2;
if(A[m1]==B[m2]) //如果 a = b 则a或b即为所求中位数
return A[m1];
if(A[m1]<B[m2]) //如果A的中位数比B的中位数小
{
d2 = m2; //舍弃B中间点以后的部分,保留中间点
if((s1+d1)%2==0)//如果当前比较元素为奇数
{
s1 = m1; //舍弃A中间点以前的部分,保留中间点
}else{
s1 = m1+1; //舍弃A中间点以前的部分,不保留中间点
}
}else{ //如果A的中位数比B的中位数大
d1 = m1; //舍弃A中间点以后的部分,保留中间点
if((s2+d2)%2==0)//如果当前比较元素为偶数
{
s2 = m2; //舍弃B中间点以前的部分,保留中间点
}else{
s2 = m2+1; //舍弃B中间点以前的部分,保留中间点
}
}
}
if(A[s1]<B[s2]) //取小者
return A[s1];
else return B[s2];
}
/* 主函数 */
int main()
{
/* 初始化数组 */
int A[5] = {2,3,6,8,20};
int B[5] = {11,13,15,17,19};
printf("Array A :");
for(int i=0;i<5;i++)
printf("%d ",A[i]);
printf("\nArray B :");
for(int i=0;i<5;i++)
printf("%d ",B[i]);
/* 测试函数 */
int C = Medium_AB(A,B,5);
int C1 = middle_search(A,B,5);
printf("\nMedium number is %d ",C1);
system("pause");
return 0;
}
T12【2013统考真题】
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P20-T12：
已知一个整数序列A=(a0，a1，…，an-1)，其中0≤ai<n(0≤i<n)。若存在ap1=ap2=…=apm=x且m>n/2（0≤pk<n，1≤k≤m），则称x为A的主元素。
例如A=(0，5，5，3，5，7，5，5)，则5为主元素；又如A=(0，5，5，3，5，1，5，7)，则A中没有主元素。
假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素；否则输出-1
【测试样例】{0,5,5,3,5,7,5,5}
【输出结果】5
【测试样例】{0,5,5,3,5,1,5,7}
【输出结果】-1 */
/* 自己做的 */
//Tn = O(n^2) S(n) = O(1)
int mainElement(int A[],int n)
{
//暴力穷举找出众数个数
int count;
int a;
for(int i=0;i<n;i++)
{
count = 0;
for(int j=0;j<n;j++)
{
if(A[i]==A[j]){
count++;
a = A[i];
}
}
}
//将众数个数与n/2比较
if(count>n/2) return a;
else return -1;
}
/* 参考答案 */
//基于只有一个数相同的情况下
//Tn = O(n) S(n) = O(1)
int Majority(int A[],int n)
{
int i,c,count = 1; //c:用来保存候选主元素 count:记录候选主元素出现的次数
c = A[0]; //设置A[0]为候选主元素
for(i=1;i<n;i++) //循环作用：查找候选主元素
if(A[i]==c)
count++; //对A中候选主元素计数
else
if(count>0) //如果不是候选主元素
count--;
else //更换候选主元素，重新计数
{
c = A[i];
count = 1;
}
if(count>0)
for(i=count=0;i<n;i++)//统计候选主元素实际出现的次数，此处重置count = 0
if(A[i]==c)
count++;
if(count>n/2) return c;
else return -1;
}
/* 主函数 */
int main()
{
/* 初始化数组 */
int A[8] = {0,5,5,3,5,7,5,5};//0,5,5,3,5,1,5,7
printf("Array A :");
for(int i=0;i<8;i++)
printf("%d ",A[i]);
/* 测试函数 */
int a = mainElement(A,8);
int b = Majority(A,8);
printf("\nA's mainElement : %d",b);
system("pause");
}
T13【2018统考真题】
#include <stdio.h>
#include <windows.h>
#include "List.h"
#include "List.cpp"
/* P20-T13：
给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。
例如:
数组{-5, 3, 2, 3}中未出现的最小正整数是1;
数组{1, 2, 3}中未出现的最小正整数是4。
最小的没有出现的正整数:
如果1没有出现 那么最小结果为1
如果1到n都出现那么最小的结果为n+1
因此结果的范围1～n+1 */
/* 参考答案 */
int findMissMin(int A[],int n)
{
int i,*B; //标记数组
B = (int *)malloc(sizeof(int)*n); //分配空间
memset(B,0,sizeof(B)); //赋初值为0
for(i=0;i<n;i++)
if(A[i]>0 && A[i]<=n) //若A[i]的值介于1~n,则标记数组B[A[i]-1]————实现B[0]..B[n-1]与1..n一一对应，对应上了则标记数组为1
B[A[i]-1] = 1;
for(i=0;i<n;i++) //扫描数组B，找到目标值
if(B[i]==0) break;
return i+1;
}
/* 主函数 */
int main()
{
/* 初始化表 */
int A[4] = {-5, 3, 2, 3};
printf("Array A :");
for(int i=0;i<4;i++)
printf("%d ",A[i]);
/* 测试函数 */
int a = findMissMin(A,4);
printf("\nA's MinInteger : %d",a);
system("pause");
return 0;
}
2.3.7 综合应用题：（P40-T1~P44-T25）【自此开始全部使用 C语言】
T0 LinkList.h LinkList.c
#ifndef LINKLIST_H
#define LINKLIST_H
#include <stdio.h>
#include <time.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MaxSize 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
typedef struct LNode //定义单链表节点类型
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode;
typedef struct LNode *LinkList; /* 定义LinkList ,可在LNode结构体后面简写*/
//双链表结点类型
typedef struct DNode //定义双链表结点类型
{
ElemType data; //数据域
struct DNode *prior,*next; //前驱和后继指针
}DNode,*DLinkList;
//静态链表
typedef struct //定义单链表结点类型
{
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
}SLinkList[MaxSize];
Status visit(ElemType c);
/* 单链表操作 */
Status InitList(LinkList *L); /* 初始化顺序线性表 */
Status ListEmpty(LinkList L); /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ClearList(LinkList *L);/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
int ListLength(LinkList L);/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
Status GetElem(LinkList L,int i,ElemType *e);/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
int LocateElem(LinkList L,ElemType e);/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
Status ListInsert(LinkList *L,int i,ElemType e);/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListDelete(LinkList *L,int i,ElemType *e) ;/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListTraverse(LinkList L);/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
void CreateListHead(LinkList *L, int n);/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void List_HeadInsert(LinkList *L);/* 输入元素值（如果为9999表示输入结束），建立带表头结点的单链线性表L（头插法） */
void CreateListTail(LinkList *L, int n); /* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void List_TailInsert(LinkList *L);/* 输入元素值（如果为9999表示输入结束），建立带表头结点的单链线性表L（尾插法）,正向建立单链表 */
void CircleList_TailInsert(LinkList *L);/* 尾插法建立带表头结点的 循环单链表 */
Status CircleListTraverse(LinkList L);/* 遍历 循环单链表 */
/* 双链表 */
void DList_TailInsert(DLinkList *L);/* 尾插法建立带表头结点的 双链表 */
Status DListTraverse(DLinkList L);/* 遍历 双链表 */
void CircleDList_TailInsert(DLinkList *L);/* 尾插法建立带表头结点的 循环双链表 */
Status CircleDListTraverse(DLinkList L);/* 遍历 循环双链表 */
#endif
/* LinkList.c */
#include"LinkList.h"
Status visit(ElemType c)
{
printf("%d ",c);
return OK;
}
/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(LinkList)malloc(sizeof(LNode)); /* 产生头结点,并使L指向此头结点 */
if(!(*L)) /* 存储分配失败 */
return ERROR;
(*L)->next=NULL; /* 指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE;
else
return TRUE;
}
/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0;
LinkList p=L->next; /* p指向第一个结点 */
while(p)
{
i++;
p=p->next;
}
return i;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 */
*e = p->data; /* 取第i个元素的数据 */
return OK;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(p->data==e) /* 找到这样的数据元素 */
return i;
p=p->next;
}
return 0;
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L;
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(LNode)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
LinkList p=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(LNode));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(LNode)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
/* 输入元素值（如果为9999表示输入结束），建立带表头结点的单链线性表L（头插法） */
void List_HeadInsert(LinkList *L)
{
LinkList p;
int i;
*L = (LinkList)malloc(sizeof(LNode)); //创建头结点
(*L)->next = NULL; //初始为空链表
scanf("%d",&i); //输入结点的值
while(i!=9999) //输入9999表示结束
{
p = (LinkList)malloc(sizeof(LNode));//创建新结点
p->data = i; //新结点数据元素为 输入值i
p->next = (*L)->next; //空链表转变为 带P结点的新链表,以此类推……
(*L)->next = p; //将新结点插入表中，L为头指针
scanf("%d",&i);
}
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(LNode)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (LNode *)malloc(sizeof(LNode)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
/* 输入元素值（如果为9999表示输入结束），建立带表头结点的单链线性表L（尾插法）,正向建立单链表 */
void List_TailInsert(LinkList *L)
{
int x; //设元素类型为整型
*L = (LinkList)malloc(sizeof(LNode)); //创建头结点
LinkList s,r = *L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999) //输入9999表示结束
{
s = (LinkList)malloc(sizeof(LNode));
s->data = x;
r->next = s; //从空链表转变为 带s结点的新链表,以此类推……
r = s; //r指向新的表尾结点，因为表尾插入，这时候s就是新的表尾，所以原表L需要重新指向
scanf("%d",&x);
}
r->next = NULL; //尾结点指针置空
}
/* 循环单链表尾插法 */
void CircleList_TailInsert(LinkList *L)
{
int x; //设元素类型为整型
*L = (LinkList)malloc(sizeof(LNode)); //创建头结点
LinkList s,r = *L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999) //输入9999表示结束
{
s = (LinkList)malloc(sizeof(LNode));
s->data = x;
r->next = s; //从空链表转变为 带s结点的新链表,以此类推……
r = s; //r指向新的表尾结点，因为表尾插入，这时候s就是新的表尾，所以原表L需要重新指向
scanf("%d",&x);
}
r->next = (*L); //尾结点指针指向头结点
}
/* 循环单链表的遍历 */
Status CircleListTraverse(LinkList L)
{
LinkList p=L->next;
while(p!=L)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
/* 双链表 */
/* 双链表尾插法 */
void DList_TailInsert(DLinkList *L)
{
int x; //设元素类型为整型
*L = (DLinkList)malloc(sizeof(DNode)); //创建头结点
DLinkList s,r = *L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999) //输入9999表示结束
{
s = (DLinkList)malloc(sizeof(DNode));
s->data = x;
r->next = s; //从空链表转变为 带s结点的新链表,以此类推……
s->prior = r; //s的前驱指向r【此时的表尾】
r = s; //r指向新的表尾结点，因为表尾插入，这时候s就是新的表尾，所以原表L需要重新指向
scanf("%d",&x);
}
r->next = NULL; //尾结点指针置空
}
/* 双链表的遍历 */
Status DListTraverse(DLinkList L)
{
DLinkList p=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
/* 循环双链表尾插法 */
void CircleDList_TailInsert(DLinkList *L)
{
int x; //设元素类型为整型
*L = (DLinkList)malloc(sizeof(DNode)); //创建头结点
//循环双链表
(*L)->next = (*L);
(*L)->prior = (*L);
DLinkList s,r = *L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999) //输入9999表示结束
{
s = (DLinkList)malloc(sizeof(DNode));
s->data = x;
r->next = s; //从空链表转变为 带s结点的新链表,以此类推……
s->prior = r; //s的前驱指向r【此时的表尾】
r = s; //r指向新的表尾结点，因为表尾插入，这时候s就是新的表尾，所以原表L需要重新指向
scanf("%d",&x);
}
(*L)->prior = r; //头结点指针前驱指针尾结点
r->next = (*L); //尾结点指针后继指向头结点
}
/* 循环双链表的遍历 */
Status CircleDListTraverse(DLinkList L)
{
DLinkList p=L->next;
while(p!=L)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
/* 测试主函数 */
// int main()
// {
// LinkList L;
// ElemType e;
// Status i;
// int j,k;
// i=InitList(&L);
// printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
// for(j=1;j<=5;j++)
// i=ListInsert(&L,1,j);
// printf("在L的表头依次插入1～5后：L.data=");
// ListTraverse(L);
// printf("ListLength(L)=%d \n",ListLength(L));
// i=ListEmpty(L);
// printf("L是否空：i=%d(1:是 0:否)\n",i);
// i=ClearList(&L);
// printf("清空L后：ListLength(L)=%d\n",ListLength(L));
// i=ListEmpty(L);
// printf("L是否空：i=%d(1:是 0:否)\n",i);
// for(j=1;j<=10;j++)
// ListInsert(&L,j,j);
// printf("在L的表尾依次插入1～10后：L.data=");
// ListTraverse(L);
// printf("ListLength(L)=%d \n",ListLength(L));
// ListInsert(&L,1,0);
// printf("在L的表头插入0后：L.data=");
// ListTraverse(L);
// printf("ListLength(L)=%d \n",ListLength(L));
// GetElem(L,5,&e);
// printf("第5个元素的值为：%d\n",e);
// for(j=3;j<=4;j++)
// {
// k=LocateElem(L,j);
// if(k)
// printf("第%d个元素的值为%d\n",k,j);
// else
// printf("没有值为%d的元素\n",j);
// }
// k=ListLength(L); /* k为表长 */
// for(j=k+1;j>=k;j--)
// {
// i=ListDelete(&L,j,&e); /* 删除第j个数据 */
// if(i==ERROR)
// printf("删除第%d个数据失败\n",j);
// else
// printf("删除第%d个的元素值为：%d\n",j,e);
// }
// printf("依次输出L的元素：");
// ListTraverse(L);
// j=5;
// ListDelete(&L,j,&e); /* 删除第5个数据 */
// printf("删除第%d个的元素值为：%d\n",j,e);
// printf("依次输出L的元素：");
// ListTraverse(L);
// i=ClearList(&L);
// printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
// CreateListHead(&L,20);
// printf("整体创建L的元素(头插法)：");
// ListTraverse(L);
// i=ClearList(&L);
// printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
// CreateListTail(&L,20);
// printf("整体创建L的元素(尾插法)：");
// ListTraverse(L);
// return 0;
// }
T1
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* 自此之后全部使用C语言!!!!!! */
/* P40-T1：
设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点 */
/* 参考答案 */
void Del_X_3(LinkList *L,ElemType x)
{
//递归实现在单链表L中删除值尾x的结点
LinkList p; //p指向待删除结点
if((*L)==NULL) //递归出口
return;
if((*L)->data==x) //若L所指结点的值为x
{
p = *L; //将当前结点赋值给p，以待删除
*L = (*L)->next; //L指向下一结点 (*L)->next等价于(**L).next
free(p); //释放p结点的存储空间，即删除
Del_X_3(L,x); //这里不是&L的原因：L就是LinkList *类型【LNode**】
}
else
Del_X_3(&((*L)->next),x); //这里是因为要取下一个结点，所以先确定LinkList（LNode*）后取地址
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
Del_X_3(&L,3);
ListTraverse(L);
system("pause");
return 0;
}
T2【基本形式，删除值为x的结点-->删除指定范围内的结点】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T2：（P40-T7的基本形式）
在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法实现上述操作 */
/* 参考答案 */
void Del_X_1(LinkList *L,ElemType x)
{
LinkList p = (*L)->next; //p初始指向首元结点【用于找到被删除结点】
LinkList pre = (*L),q; //pre指向头结点【用于找到被删结点的前驱结点】
while (p!=NULL)
{
if(p->data==x) //这里可以指定删除数值范围内的结点
{
q = p; //p指向该待删除结点
p = p->next; //p指向下一个结点【不能等到删除结点之后再指向下一个结点，因为此时该节点为被删了，找不到正确的指针域了】
pre->next = q->next;//删除该节点
free(q);
}else{ //前驱结点和被删除结点同步后移
pre = p;
p = p->next;
}
}
}
/* 参考答案2————尾插法建立单链表 */
void Del_X_2(LinkList *L,ElemType x)
{
LinkList p = (*L)->next;
LinkList r = *L,q; //r指向尾指针，q指向待删除结点
while(p!=NULL)
{
if(p->data!=x) //p结点值不为x时将其连接到L尾部
{
r->next = p;
r = p; //r指向新的表尾结点
p = p->next; //指向下一结点，继续扫描
}else{ //p结点值为x时将结点释放（删除）
q = p;
p = p->next; //指向下一结点，继续扫描【必须在释放空间之前指向下一结点】
free(q);
}
}
//尾插法必备————插入结束后置尾指针尾NULL
r->next = NULL;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
Del_X_1(&L,3);
ListTraverse(L);
Del_X_2(&L,2);
ListTraverse(L);
system("pause");
return 0;
}
T3【反向输出————递归调用/头插法】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T3：
设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值 */
/* 参考答案 */
//递归实现，建议调试学习————使用时需要传入首元结点，而不是头结点
void R_Print(LinkList L)
{
if(L->next!=NULL) //从首元结点数据域开始递归，直到尾结点
R_Print(L->next);
if(L!=NULL) //递归到尾结点时输出尾结点元素
printf("%d ",L->data);
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
R_Print(L->next); //需要传入首元结点，而不是头结点
system("pause");
return 0;
}
T4
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T4：
试编写在带头结点的单链表L中删除一个最小值结点的高效算法（假设最小值结点是唯一的）
没有头结点的单链表实现上会有所不同*/
/* 参考答案 */
//函数返回void也没问题
//T(n) = O(n) S(n) = O(1)
LinkList Delete_Min(LinkList *L)
{
LinkList pre = *L , p = pre->next; //p为工作指针，pre指向其前驱
LinkList minpre = pre , minp = p; //保存最小结点minp及其前驱
while(p!=NULL) //循环作用：遍历链表，找到最小值结点
{
if(p->data<minp->data) //如果找到比p更小的结点，则保存其最小结点
{
minp = p;
minpre = pre;
}
//继续扫描下一结点
pre = pre->next;
p = p->next;
}
//删除最小值结点
minpre->next = minp->next;
free(minp);
return *L;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
L = Delete_Min(&L); //返回LinkList类型
ListTraverse(L);
system("pause");
return 0;
}
T5【逆置————头插法/指针反转】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T5：
试编写将带头结点的单链表就地逆置 S(n) = O(1)*/
/* 参考答案 */
//头插法
LinkList Reverse_1(LinkList L)
{
LinkList p = L->next; //p为工作指针，初始指向L的首元结点
LinkList r;
L->next = NULL; //初始置L的指针域为空，这里将L断开成 “头结点” 和 “数据元素结点” 两部分
while(p!=NULL)
{
r = p->next; //暂存p的后继
p->next = L->next; //将p结点插入到头结点之后，插入第一个数据结点时p的指针域指向NULL，
//后来新插入的数据结点的指针域都指向前一个插入的数据结点【调试一下，一清二楚】
L->next = p; //L指向p，完成插入
p = r; //扫描下一个数据元素结点，将其头插
}
return L;
}
/* 参考答案2 */
//指针反转————非常巧妙666
LinkList Reverse_2(LinkList L)
{
//依次遍历线性表L，并将结点指针反转
LinkList p = L->next;
LinkList r = p->next , pre; //r为工作指针，指向原p结点的后继结点
p->next = NULL; //置首元结点的指针域为空（因为它将作为新表的尾结点）表的第一部分：a1-->NULL
while(r!=NULL) //循环作用：从第二个元素结点开始处理，使其指针指向前一个元素结点，依次遍历，如果r为空，则说明p是最后一个结点
{
pre = p; //存储r的前一个结点
p = r; //p后移【后移至第n个结点】
r = r->next; //r后移【后移至第n+1个结点】
p->next = pre; //指针反转，表的第二部分：an-->an-1-->an-2...-->a2-->a1
}
//数据元素结点处理完毕，最后将头结点指向an
L->next = p; //循环完毕后，此时的p指向an，即头结点指向an 表的第三部分：头结点-->an
//三部分完成结果————L表： 头结点-->an-->an-1-->an-2...a2-->a1-->NULL
return L;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
L = Reverse_1(L);
ListTraverse(L);
L = Reverse_2(L);
ListTraverse(L);
system("pause");
return 0;
}
T6【找最值的变形】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T6：
有一个带头结点的单链表L，设计一个算法使其元素递增有序 */
/* 参考答案 */
void Sort(LinkList *L)
{
LinkList p = (*L)->next , pre;
LinkList r = p->next;
p->next = NULL; //置首元结点的指针域为空，分离 “头结点+首元结点” 和 “其他数据元素结点”
p = r; // “其他数据元素结点” 部分（p），初始p从第二个元素结点开始
while(p!=NULL){ //循环作用：用于将p中 【“其他数据元素结点”】 元素从小到大弄到 “头结点+首元结点” 中去
r = p->next; //保存p结点后继元素指针
pre = *L; // “头结点+首元结点” 部分（L表），初始指向头结点
//循环作用：
while(pre->next!=NULL&&pre->next->data<p->data) //【调试一下，啥都明白】
pre = pre->next; //如果p中当前数据元素 < L表数据元素 且 L表不为空，指针后移【确定插入的位置】
//插入比较完成的p结点，大的插到后面，小的插到前面
p->next = pre->next;
pre->next = p;
p = r; //继续扫描
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
Sort(&L);
ListTraverse(L);
system("pause");
return 0;
}
T7
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P40-T7：（P40-T2的变化形式）
设在一个带表头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值（作为函数参数给出）之间的元素 */
/* 参考答案 */
void RangeDelete(LinkList *L,int min,int max)
{
LinkList pr = *L , p = (*L)->next;
while(p!=NULL)
{
if(p->data>min && p->data<max)
{
pr->next = p->next;
free(p);
p = pr->next; //p指向下一个结点，继续扫描
}else{ //不在删除范围内，指针同时后移，继续扫描
pr = p;
p = p->next;
}
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
RangeDelete(&L,2,4);
ListTraverse(L);
system("pause");
return 0;
}
T8
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T8：
给定两个单链表，编写算法找出两个链表的公共结点
说明：两个单链表有公共结点则表示它们从某一结点开始数据域都指向同一个接结点，拓扑形状类似于 “Y” */
/* 参考答案 */
//T(n) = O(len1+len2) S(n) = O(1)
LinkList Search_1st_Common(LinkList L1,LinkList L2)
{
//计算两个链表的表长
int len1 = ListLength(L1);
int len2 = ListLength(L2);
int dist;
LinkList longList,shortList; //分别指向表长较长和较短的链表
if(len1>len2)
{
longList = L1->next;
shortList = L2->next;
dist = len1 - len2;
}else{
longList = L2->next;
shortList = L1->next;
dist = len2 - len1;
}
while(dist--) //循环作用：表长的链表先遍历到第dist个结点，然后与短链表同步
longList = longList->next;
while(longList!=NULL) //循环作用：同步寻找共同结点
{
if(longList==shortList) //如果找到了，返回公共结点
return longList;
else{ //否则：同步后移继续寻找
longList = longList->next;
shortList = shortList->next;
}
}
return NULL;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L1,L2,L3;
InitList(&L3);
List_TailInsert(&L1);
L2 = L1->next; //指向L1首元结点【不过因为遍历默认是遍历带头结点的链表，所以最后遍历结果不带首元结点元素】
ListTraverse(L1);
ListTraverse(L2);
/* 测试函数 */
L3 = Search_1st_Common(L1,L2);
printf("%d\t%d",L3->data,L3->next);
system("pause");
return 0;
}
T9
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T9：
给定(已生成)一个带表头结点的单链表，设head为头指针，结点的结构为(data，next)，data为整型元素，next为指针。
试写出算法：按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间。(要求：不允许使用数组作辅助空间。) */
/* 参考答案 */
void Min_Delete(LinkList *head)
{
LinkList pre , p; //p为工作指针，初始指向首元结点，pre指向p的前驱
LinkList q; //待删除结点
while ((*head)->next!=NULL) //循环作用：删除节点
{
pre = *head;
p = pre->next;
while (p->next!=NULL) //循环作用：找出结点的数据元素大小顺序，从小到大找出来
{
if(p->next->data<pre->next->data) //pre->next->data最开始是首元结点数据元素
pre = p; //记住当前最小值结点前驱
p = p->next; //继续扫描
}
printf("%d ",pre->next->data);
//删除结点
q = pre->next;
pre->next = q->next;
free(q);
}
//最后不能忘记删除头结点
free(head);
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
Min_Delete(&L);
system("pause");
return 0;
}
T10
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T10：
将一个带头结点的单链表A分解为两个带头结点的单链表A和B。
使得A表中含有原表中序号为奇数的元素,而B表中含有原表中序号为偶数的元素,且保持其相对顺序不变。
说明：必须设置标记符号来判断序号奇偶性，因为此处链表元素个数可能为奇数，会将不存在的结点插入表中，从而出错*/
/* 参考答案 */
LinkList DisCreat_l(LinkList *A)
{
int i = 0; //标识符号作用：确定序号的奇偶性
//初始化B表，并分配尾指针ra、rb指向A、B两表
LinkList B = (LinkList)malloc(sizeof(LNode));
B->next = NULL;
LinkList ra = *A , rb = B;
//分解A表【 “头结点”部分(A) 和 “数据元素结点”部分(p) 】以待再重新组合
LinkList p = (*A)->next;
// (*A)->next = NULL; 这里头结点不置空也没事【因为尾插时A表指针域还是会变】
while (p!=NULL) //循环作用：往A、B两表尾插结点
{
i++; //遍历一个数据元素结点数值加1
if(i%2==0) //若序号为偶数，则插入B表
{
rb->next = p;
rb = p;
}else{ //否则，插入A表
ra->next = p;
ra = p;
}
p = p->next; //插入完成一个就继续扫描
}
//尾插法标配————置尾指针为空
ra->next = NULL;
rb->next = NULL;
return B;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L,B;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
B = DisCreat_l(&L);
ListTraverse(L);
ListTraverse(B);
system("pause");
return 0;
}
T11
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T11：
设C = {a1,b1,a2,b2......,an,bn},采用头结点的hc单链表来存放，
设计一个就地算法，将其拆成 A = {a1,a2....a2} B = {bn,bn-1,...b1}
说明：此处可以不设置标记符号来判断序号奇偶性，因为此处链表元素个数本就为偶数，不会将不存在的结点插入表中
但是如果输入的测试元素为{1 2 3 4 5}，就会在A表尾插完5后，再头插时出错*/
/* 参考答案 */
//与P41-T9差不多，只是此时B表不设尾指针，设头指针，B表用头插法，A表仍然用尾插法
//但是要注意：头插法会断链，因此要设置 “指针记忆结点的后继” 同样的尾插法也要在 “循环完成后置尾指针为空”
LinkList DisCreat_2(LinkList *A)
{
int i = 0; //标识符号作用：确定序号的奇偶性
//初始化B表，并分配尾指针ra指向A表
LinkList B = (LinkList)malloc(sizeof(LNode));
B->next = NULL;
LinkList ra = *A;
//分解A表【 “头结点”部分(A) 和 “数据元素结点”部分(p) 】以待再重新组合
LinkList p = (*A)->next , q;
while (p!=NULL) //循环作用：往A、B两表尾插结点
{
/* 使用标记符号确定奇偶性 */
// i++; //遍历一个数据元素结点数值加1
// if(i%2==0) //若序号为偶数，则插入B表【头插法】
// {
// q = p->next;
// p->next = B->next;
// B->next = p;
// p = q;
// }else{ //否则，插入A表【尾插法】
// ra->next = p;
// ra = p;
// p = p->next; //插入完成一个就继续扫描
// }
/* 不使用标记符号 */
//尾插元素进A表
ra->next = p;
ra = p;
p = p->next;
//头插元素进B表
if(p!=NULL) q = p->next;
p->next = B->next;
B->next = p;
p = q;
}
//尾插法标配————置尾指针为空
ra->next = NULL;
return B;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L,B;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
B = DisCreat_2(&L);
ListTraverse(L);
ListTraverse(B);
system("pause");
return 0;
}
T12
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T12：
在一个递增有序的线性表L中，有数值相同的元素存在。若存储方式为单链表，设计一个算法删除数值相同的元素，使表中不再有重复的元素。
例如：（7，10，10，21，30，42，42，42，51，70）将变作（7，10，21，30，42，51，70）*/
/* 参考答案 */
void Del_Same(LinkList *L)
{
LinkList p = (*L)->next; //p为工作指针
LinkList q; //q作为p结点的后继，也是待删除元素
if(p==NULL)
return ;
while (p->next!=NULL) //循环作用：删除重复结点
{
q = p->next; //q指向p的后继结点
if(p->data==q->data) //找到重复值的结点并删除
{
p->next = q->next;
free(q);
}else
p = p->next; //继续扫描
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L,B;
List_TailInsert(&L); //7 10 10 21 30 42 42 42 51 70 9999
ListTraverse(L);
/* 测试函数 */
Del_Same(&L);
ListTraverse(L);
system("pause");
return 0;
}
T13
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T13：
假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，
并要求利用原来两个单链表的结点存放归并后的单链表。 */
/* 参考答案 */
void MergeList(LinkList *La,LinkList *Lb)
{
LinkList pa = (*La)->next , pb = (*Lb)->next;
LinkList r; //头插法标配————用于暂存
(*La)->next = NULL;
while (pa&&pb) //循环作用：比较pa和pb数据元素的值，小者依次进入La，直到有一个链表被遍历完
{
if(pa->data<=pb->data)
{
r = pa->next; //暂存pa后继结点指针
//头插法
pa->next = (*La)->next;
(*La)->next = pa;
pa = r; //下一个，继续扫描
}else{
r = pb->next; //暂存pb后继结点指针
//头插法
pb->next = (*La)->next;
(*La)->next = pb;
pb = r; //下一个，继续扫描
}
}
if(pa) //循环完成后必定至少有一个表被遍历完，如果pa仍然存在，那么此时pb一定为空表，反之亦然
pb = pa; //给pb赋值为pa【未被遍历的部分】,接下来就只需要处理pb即可
while (pb) //循环作用：将剩下的结点依次头插进La表
{
r = pb->next; //暂存pb后继结点指针
//头插法
pb->next = (*La)->next;
(*La)->next = pb;
pb = r; //下一个，继续扫描
}
free(Lb); //Lb用完了就可以消失了
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList La,Lb;
List_TailInsert(&La);
List_TailInsert(&Lb);
ListTraverse(La);
ListTraverse(Lb);
/* 测试函数 */
MergeList(&La,&Lb);
ListTraverse(La);
system("pause");
return 0;
}
T14
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P41-T14：
A,B是两个带头结点的单链表,其中元素递增有序。设计一个算法从A和B中公共元素产生单链表C,要求不破坏A,B的结点 */
/* 自己做的————不合题意，仅做测试 */
//这里改变了A链表，将A链表当成C链表重新生成
void Common(LinkList *A,LinkList *B)
{
LinkList p = (*A)->next , q = (*B)->next;
LinkList r = *A,s;
(*A)->next = NULL;
while (p&&q)
{
if(p->data<q->data)
{
p = p->next;
}else if(p->data>q->data){
q = q->next;
}else{
//尾插法
r->next = q;
r = q;
//继续往后扫描
p = p->next;
q = q->next;
}
}
//尾插法标配————置尾结点为空
r->next = NULL;
}
/* 参考答案 */
//返回值修改成返回C链表
LinkList Get_Common(LinkList A,LinkList B)
{
LinkList p = A->next , q = B->next;
//初始化单链表C
LinkList C = (LinkList)malloc(sizeof(LNode));
LinkList r = C,s; //尾插法标配————r为尾指针，s用于复制结点
A->next = NULL;
while (p&&q) //循环作用：将A、B两表共有元素插入C表中
{
if(p->data<q->data) //A表元素小了，指针后移
{
p = p->next;
}else if(p->data>q->data){ //B表元素小了，指针后移
q = q->next;
}else{ //AB表元素相等，擦汗如C表
//初始化s结点并复制q结点，以待用于尾插进C表
s = (LinkList)malloc(sizeof(LNode));
s->data = q->data;
//尾插法
r->next = s;
r = s;
//继续往后扫描
p = p->next;
q = q->next;
}
}
//尾插法标配————置尾结点为空
r->next = NULL;
return C;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList La,Lb,C;
List_TailInsert(&La);
List_TailInsert(&Lb);
ListTraverse(La);
ListTraverse(Lb);
/* 测试函数 */
// Common(&La,&Lb);
C = Get_Common(La,Lb);
ListTraverse(C);
system("pause");
return 0;
}
T15
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T15：
已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中
交集与共有元素的小细节——————本题与P41-T14都强调 “其元素递增排列” 如此一来求共有元素的算法可以相当于求交集
因此本题可以用 “求共有元素” 的算法，但实际上：
求交集，就是求不重复的共有元素。【见下面一个例子】
A：1 2 3 3 4 5
B：2 3 3 4 4 6
A和B的共有元素：2 3 3 4
A ∩ B = 2 3 4
因此严格意义上的 “求交集”答案也没有实现，毕竟集合中的元素是可以相等的 */
/* 自己做的【同P41-T14】 */
void MergeList(LinkList *A,LinkList *B)
{
LinkList p = (*A)->next , q = (*B)->next;
LinkList r = *A;
(*A)->next = NULL;
while (p&&q)
{
if(p->data<q->data)
{
p = p->next;
}else if(p->data>q->data){
q = q->next;
}else{
//尾插法
r->next = q;
r = q;
//继续往后扫描
p = p->next;
q = q->next;
}
}
//尾插法标配————置尾结点为空
r->next = NULL;
}
/* 参考答案 */
void Union(LinkList *La, LinkList *Lb){
//求两个递增的有序链表La和Lb的交集，使用头指针Lc指向
LinkList pa, pb, pc, u;
pa = (*La)->next; //pa是链表La的工作指针，初始化为首元结点
pb = (*Lb)->next; //pb是链表Lb的工作指针，初始化为首元结点
pc = *La; //用La的头结点作为Lc的头结点
while(pa && pb){ //两个链表La和Lb均未达到表尾结点
if(pa -> data == pb -> data){ //相等，交集并入结果表中
pc -> next = pa;
pc = pa;
pa = pa -> next; //取La中的元素，将pa链接在pc的后面，pa指针后移
u = pb;
pb = pb -> next;
free(u); //删除Lb中的对应的相等元素
}
else if(pa -> data < pb -> data){ //删除较小者La中的元素
u = pa;
pa = pa -> next;
free(u);
}
else{ //删除较小者Lb中的元素
u = pb;
pb = pb -> next;
free(u);
}
}
while(pa){ //Lb为空，删除非空表La中的所有元素
u = pa;
pa = pa -> next;
free(u);
}
while(pb){ //La为空，删除非空表Lb中的所有元素
u = pb;
pb = pb -> next;
free(u);
}
pc -> next = NULL; //置链表Lc尾标记
free(Lb); //释放Lb的头结点
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList La,Lb;
List_TailInsert(&La);
List_TailInsert(&Lb);
ListTraverse(La);
ListTraverse(Lb);
/* 测试函数 */
// MergeList(&La,&Lb);
Union(&La,&Lb);
ListTraverse(La);
system("pause");
return 0;
}
T16
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T16：
两个整数序列 A=a1,a2,a3,...,am 和 B=b1,b2,b3,...,bn 已经存入两个单链表中,判断序列B是否是序列A的连续子序列
连续子序列： 给定k个整数的序列{N1,N2,...,Nk }，其任意连续子序列可表示为{ Ni, Ni+1, ..., Nj }，其中 1≤i≤j≤k */
/* 参考答案 */
int Pattern(LinkList A,LinkList B)
{
//答案给的是无头结点的，这里p、q都应该指向A、B表的首元结点
LinkList p = A->next , pre = p , q = B->next; //p:A链表工作指针 pre：A链表开始结点 q：B链表工作指针
while (p&&q) //扫描直至A、B序列有一方遍历完毕
{
if(p->data==q->data) //A、B序列数值相同，继续扫描下去
{
p = p->next;
q = q->next;
}else{
pre = pre->next; //A链表开始结点后移
p = pre;
q = B->next; //B链表开始结点始终从B开始
}
}
if(q==NULL) //最终q为空说明B是A的连续子序列
return 1;
else //否则不是
return 0;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList La,Lb;
List_TailInsert(&La);
List_TailInsert(&Lb);
ListTraverse(La);
ListTraverse(Lb);
/* 测试函数 */
printf("%d ",Pattern(La,Lb));
system("pause");
return 0;
}
T17
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T17：
设计一个算法用于判断带头结点的循环双链表是否对称 */
/* 参考答案 */
int Symmetry(DLinkList L)
{
DLinkList p = L->next , q = L->prior;
while (p!=q && q->next!=p) //【不含头结点】遍历完成————p!=q:结点个数为奇数时 q->next!=p或p->prior!=q:节点个数为偶数时
{
if(p->data==q->data) //对称的数据元素结点的值相等即可继续扫描
{
p = p->next;
q = q->prior;
}else //至少有一个不对称，返回0
return 0;
}
return 1; //全部对称，返回1
}
/* 主函数 */
int main()
{
/* 初始化表 */
DLinkList L;
CircleDList_TailInsert(&L);
CircleDListTraverse(L);
/* 测试函数 */
printf("%d (1:Yes 0:No)",Symmetry(L));
system("pause");
return 0;
}
T18
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T18：
有两个循环单链表，头指针分别是h1和h2，实现算法将链表h2连接到h1之后，连接后的链表仍然是循环链表的形式 */
/* 参考答案 */
LinkList Link(LinkList *h1,LinkList *h2)
{
LinkList p,q; //分别指向两个链表的尾结点
p = *h1;
while (p->next!=*h1) //循环作用：寻找h1尾结点
p = p->next;
q = *h2;
while (q->next!=*h2) //循环作用：寻找h2尾结点
q = q->next;
p->next = (*h2)->next; //答案：p->next = *h2 直接将h2结点连接到h1之后，这样遍历输出的时候会输出h2的结点值，故：接上h2的首元结点
q->next = *h1; //h2尾结点指向h1
return *h1;
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L1,L2;
CircleList_TailInsert(&L1);
CircleList_TailInsert(&L2);
CircleListTraverse(L1);
CircleListTraverse(L2);
/* 测试函数 */
Link(&L1,&L2);
CircleListTraverse(L1);
system("pause");
return 0;
}
T19【找最值】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T19：
设有一个带头结点的循环单链表,其结点值均为正整数。试设计一个算法,反复找出单链表中结点值最小的结点并输出,
然后将该结点从中删除,直到单链表空为止，再删除表头结点 */
/* 参考答案 */
void Del_All(LinkList *L)
{
LinkList p,pre,minp,minpre;
while ((*L)->next!=(*L)) //循环作用：不断删除最小结点并输出
{
p = (*L)->next; //p为工作指针
pre = (*L); //pre指向p的前驱
minp = p; //指向最小指针结点
minpre = pre;
while (p!=*L) //循环作用：找出最小值结点
{
if(p->data<minp->data) //遇到更小的结点，用minp保存
{
minp = p;
minpre = pre;
}
//继续扫描
pre = p;
p = p->next;
}
printf("%d ",minp->data); //输出最小值结点元素
//删除结点
minpre->next = minp->next;
free(minp);
}
//所有数据元素结点删除完毕后不能忘记删除头结点
free(*L);
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
CircleList_TailInsert(&L);
CircleListTraverse(L);
/* 测试函数 */
Del_All(&L);
//CircleListTraverse(L); 头结点已经删除，但是L表还存在不知道咋回事
system("pause");
return 0;
}
T20
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T20：
设有一头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred（前驱指针）、data（数据）和next（后继指针）域外，
还有一个访问频度域freq。在链表被起用前，其值均初始化为零。 每当在链表中进行一次Locat(L, x)运算时，令元素值为x的结点中freq域的值增1，
并使此链表中结点保持按访问频度非增（递减）的顺序排列，同时最近访问的结点排在频度相同的结点的最后，以便使频繁访问的结点总是靠近表头。
试编写符合上述要求的Locate(L, x)运算的算法，该运算为函数过程，返回找到结点的地址，类型为指针型。
题目太长了，废话太多，简单解释：
表中除了双链表本身的数据域（data）、前驱和后继指针（*pred 和 *next）之外，还有一个频度域（跟data数据类型相同————frep）
编写Locate(L,x)算法使得双链表访问x次数多的放到表的前面，后面的依原来的顺序排序 */
typedef struct DList
{
ElemType data,frep; //数据域、频度域
struct DList *pred,*next; //前驱和后继指针、访问频度域
}DList,*LinkedList;
/* 参考答案 */
LinkedList Locate(LinkedList *L,ElemType x)
{
//本算法先查找数据x、查找成功时结点的访问频度域增1
//最后将该结点按频度递减插入链表中适当位置（同频度最近访问的再前面）
LinkedList p = (*L)->next,q;
while (p && p->data!=x)
p = p->next;
if(!p)
{
printf("don't exist Element x in struct DList\n ");
exit(0);
}else{
p->frep++; //令元素值为x的结点的frep域加1
if(p->next!=NULL) p->next->pred = p->pred;
p->pred->next = p->next; //将p结点从链表上摘下
q = p->pred; //以下查找p结点的插入位置
while (q!=(*L) && q->frep<=p->frep)
q = q->pred;
p->next = q->next;
q->next->pred = p; //将p结点插入，一定是排在同频率的第一个
p->pred = q;
q->next = p;
}
return p; //返回值为x的结点的指针
}
void LinkedList_TailInsert(LinkedList *L)
{
int x; //设元素类型为整型
*L = (LinkedList)malloc(sizeof(DList)); //创建头结点
LinkedList s,r = *L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999) //输入9999表示结束
{
s = (LinkedList)malloc(sizeof(DList));
s->data = x;
s->frep = 0;
r->next = s; //从空链表转变为 带s结点的新链表,以此类推……
s->pred = r; //s的前驱指向r【此时的表尾】
r = s; //r指向新的表尾结点，因为表尾插入，这时候s就是新的表尾，所以原表L需要重新指向
scanf("%d",&x);
}
r->next = NULL; //尾结点指针置空
}
void LinkedListTraverse(LinkedList L)
{
LinkedList p=L->next;
while(p)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkedList L;
LinkedList_TailInsert(&L);
LinkedListTraverse(L);
/* 测试函数 */
Locate(&L,2);
Locate(&L,3);
Locate(&L,4);
Locate(&L,3);
LinkedListTraverse(L);
system("pause");
return 0;
}
T21【2009统考真题】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P42-T21：
【2009统考真题】已知一个带有表头结点的单链表,结点结构为
data link（这里沿用next）
假设该链表只给出了头指针list。在不改变链表的前提下,请设计一个尽可能高效的算法,
查找链表中倒数第k个位置上的结点(k为正整数)。若查找成功,算法输出该结点的data域的值,并返回1;否则,只返回0。 */
/* 自己做的 */
//T(n) = O(n) S(n) = O(1)————扫描了两次【10分】
int Search_K(LinkList list,ElemType k)
{
int n = 0; //用于记录单链表的长度
LinkList q = list->next;
while (q!=NULL) //循环作用：扫描整个单链表得出链表长度，第一次扫描
{
n++;
q = q->next; //继续扫描
}
q = list->next; //重置q于首元结点处
if(k>n) return 0;
else{
for(int i=0;i<n-k;i++) //循环作用：指向倒数第k个结点，第二次扫描
q = q->next;
printf("%d\n",q->data);
return 1;
}
}
/* 参考答案 */
//T(n) = O(n) S(n) = O(1)————扫描了一次【15分满分】
int Search_K_1(LinkList list,ElemType k)
{
LinkList p = list->next , q = list->next;
int count = 0; //用于记录单链表的长度
while (p!=NULL) //循环作用：扫描整个单链表得出链表长度，仅仅扫描一次
{
if(count<k) count++;
else q = q->next; //继续扫描
p = p->next;
}
if(count<k) return 0;
else{
printf("%d\n",q->data);
return 1;
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
Search_K(L,3);
Search_K_1(L,3);
system("pause");
return 0;
}
T22【2012统考真题】
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P43-T22：【此题本质上和P41-T8一样】
【2012统考真题】链接：https://www.nowcoder.com/questionTerminal/36f639eb4c224a0facfd136797788a12
假定采用带头结点的单链表保存单词，当两个单词有相同的后缀时，则可共享相同的后缀存储空间，例如，“ loading ”和“ being ”的存储映像如下图所示。
设 str1 和 str2 分别指向两个单词所在单链表的头结点，链表结点结构为 | data | next |，
请设计一个时间上尽可能高效的算法，找出由 str1 和 str2 所指向两个链表共同后缀的起始位置（如图中字符 i 所在结点的位置 p ） */
/* 自己做的 */
//T(n) = O(n) S(n) = O(1)
LinkList Common(LinkList str1,LinkList str2)
{
//计算两个链表的表长
int len1 = ListLength(str1);
int len2 = ListLength(str2);
int dist;
LinkList longList,shortList; //分别指向表长较长和较短的链表
if(len1>len2)
{
longList = str1->next;
shortList = str2->next;
dist = len1 - len2;
}else{
longList = str2->next;
shortList = str1->next;
dist = len2 - len1;
}
while(dist--) //循环作用：表长的链表先遍历到第dist个结点，然后与短链表同步
longList = longList->next;
while(longList!=NULL) //循环作用：同步寻找共同结点
{
if(longList==shortList) //如果找到了，返回公共结点
return longList;
else{ //否则：同步后移继续寻找
longList = longList->next;
shortList = shortList->next;
}
}
return NULL;
}
/* 参考答案 */
//T(n) = O(n) S(n) = O(1)
//此处不需要对str1和str2链表进行操作，故不需要指针（或引用）
LinkList find_addr(LinkList str1,LinkList str2)
{
int m,n;
LinkList p,q;
m = ListLength(str1);
n = ListLength(str2);
//下面两个循环的主要作用：使得两个单链表保持同步（使长链表和短链表同步）
for(p=str1;m>n;m--) //若m>n,使p指向链表中的第m-n+1个结点
p = p->next;
for(q=str2;m<n;n--) //若m<n,使q指向链表中的第m-n+1个结点
q = q->next;
while (p->next!=NULL && p->next!=q->next) //循环作用：如果p、q的下一结点不同 并且 其中一个表遍历完了，则p、q指针同步后移
{
p = p->next;
q = q->next;
}
return p->next; //返回共同后缀的起始地址
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L1,L2,L3,L4;
List_TailInsert(&L1);
L2 = L1->next; //指向L1首元结点【不过因为遍历默认是遍历带头结点的链表，所以最后遍历结果不带首元结点元素】
ListTraverse(L1);
ListTraverse(L2);
/* 测试函数 */
L3 = Common(L1,L2);
printf("%d\t%d\n",L3->data,L3->next);
L4 = find_addr(L1,L2);
printf("%d\t%d",L4->data,L4->next);
system("pause");
return 0;
}
T23【2015统考真题】
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include "LinkList.h"
#include "LinkList.c"
/* P43-T23：
【2015统考真题】链接：https://www.nowcoder.com/questionTerminal/e72f9c107a9d4ca09e95a4c74c492ab6?orderByHotValue=1&mutiTagIds=597&page=1&onlyReference=false
用单链表保存m个整数，结点的结构为：[data][link]，且|data|≤n（n为正整数）。【给定单链表head】
现要求设计一个时间复杂度尽可能高效的算法，对于链表中data的绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。*/
/* 自己做的 */
//题意理解错误，只能删除指定值为n/-n的重复结点
// void Del_abs(LinkList *head,ElemType n)
// {
// int k1 = abs(n) , k2 = -k1; //待删除数字的正负值
// int i = 0; //i:k1结点和k2结点插入次数
// LinkList p = (*head)->next,q; //p：工作指针 q:防止断链
// LinkList r = (*head); //尾插法标配————尾指针
// (*head)->next = NULL; //一分为二，“头结点部分” 和 “数据元素结点部分”
// while (p!=NULL)
// {
// if(p->data!=k1 && p->data!=k2) //如果不是k1或k2结点，则尾插进head
// {
// //尾插
// q = p->next;
// r->next = p;
// r = p;
// p = q;
// }else if(p->data==k1 && i==0){ //如果是第一次遇到k1结点，则尾插进head，并置i=1，不再插入k1或k2结点
// i = 1; //k1结点已经插入一次
// q = p->next;
// r->next = p;
// r = p;
// p = q;
// }else if(p->data==k2 && i==0){ //如果是第一次遇到k2结点，则尾插进head，并置i=1，不再插入k1或k2结点
// i = 1; //k2结点已经插入一次
// q = p->next;
// r->next = p;
// r = p;
// p = q;
// }else
// p = p->next; //继续扫描
// }
// r->next = NULL; //尾插法标配————插入完成后置尾结点为空
// }
/* 参考答案 */
// h为链表，n为辅助空间【不得小于数据元素结点data值】
void Func(LinkList h,int n)
{
LinkList p = h,r; //r：用于删除结点
int *q,m;
q = (int*)malloc(sizeof(int)*(n+1)); //申请n+1个辅助空间
//初始化辅助空间
for(int i=0;i<n+1;i++)
*(q+i) = 0; //初始化为0，即结点数值都没出现过
while (p->next!=NULL)
{
m = p->next->data>0 ? p->next->data : -(p->next->data);
if(*(q+m)==0) //判断该结点数值是否已经出现过
{
*(q+m) = 1; //首次出现
p = p->next; //继续扫描
}else{
//删除多次出现的结点
r = p->next;
p->next = r->next;
free(r);
}
}
free(q); //释放辅助空间
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
//测试数据：2 5 6 8 7 -6 21 15 -7 -15 -5
//测试结果：2 5 6 8 7 21 15 【所有绝对值重复的值都能删去】
// Del_abs(&L,15); //题意理解错误，【只能删除指定绝对值重复的值】
Func(L,100);
ListTraverse(L);
system("pause");
return 0;
}
T24
#include <stdio.h>
#include <windows.h>
#include "LinkList.h"
#include "LinkList.c"
/* P44-T24：
设计一个算法完成以下功能：判断一个链表是否有环，如果有，找出环的入口并返回，否则返回NULL
*/
/* 参考答案 */
LinkList FindLoopStart(LinkList head)
{
LinkList fast = head , slow = head; //设置快慢两个指针
while (slow!=NULL && fast->next!=NULL) //循环作用：找到快慢指针两者相遇结点
{
slow = slow->next; //慢指针每次走一步
fast = fast->next->next; //快指针每次走两步
if(slow==fast) break; //两者相遇
}
if(slow==NULL || fast->next==NULL) //没有环，返回NULL
return NULL;
LinkList p1 = head , p2 = slow;
while (p1!=p2) //循环作用：找到入口点
{
p1 = p1->next;
p2 = p2->next;
}
return p1; //返回入口点
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L,q,r;
List_TailInsert(&L);
r = L->next; //找到尾结点
q = L->next->next->next; //q指向第二个元素结点
while (r->next!=NULL) //找出尾结点
r = r->next;
r->next = q; //尾结点指向q，环形成
// ListTraverse(L); //测试数据：1 2 3 4 5 6 9999
//遍历结果：1 2 3 4 5 6 3 4 5 6 3 4 5 6 ……（3 4 5 6 无限循环,环的起点为3）
/* 测试函数 */
L = FindLoopStart(L);
printf("%d\t%d",L->data,L->next);
system("pause");
return 0;
}
T25【2019统考真题】
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include "LinkList.h"
#include "LinkList.c"
/* P43-T23：
【2019统考真题】设线性表L=(a1，a2，a3，……，an-2，an-1，an)采用带头结点的单链表保存。
请设计一个空间复杂度为O(1)且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表L'=(a1，an，a2，an-1，a3，an-2…)。*/
/* 参考答案 */
void change_list(LinkList h)
{
LinkList p,q,r,s;
p = q = h;
while (q->next!=NULL) //寻找中间结点
{
p = p->next;
q = q->next;
if(q->next!=NULL) q = q->next;
}
q = p->next; //p所指结点为中间结点，q为后半段链表的首结点
p->next = NULL; //一分为二，将链表分成 “前半部分” 和 “后半部分”
while (q!=NULL) //循环作用：将链表后半段逆置
{
r = q->next; //暂存q的下一结点
//头插法
q->next = p->next;
p->next = q;
q = r; //继续扫描
}
s = h->next; //s指向前半部分的第一个数据结点，即插入点【从第二个数据结点开始插入】
q = p->next; //q指向后半段的第一个数据结点
p->next = NULL; //此处置空的说明：为什么要这么做？ 以测试数据 1、2、3 为例子
//经过调试显示，如果没有这个置空，那么：
// q结点地址：0xc91b90 data：3 | next：0x0【NULL】
// s结点地址：0xc91af8 data：1 | next：0xc91b18 --> data：2 | next：0xc91b90 --> data：3 | next：0x0【NULL】
//当执行下面循环中的 q->next = s->next语句时，俄罗斯套娃就来了，此时：
// q结点地址：0xc91b90 data：3 | next：0xc91b18 --> data：2 | next：0xc91b90（q结点） -->无尽的套娃【3 2 3 2 3 2……】
// s结点地址：0xc91af8 data：1 | next：0xc91b18 --> data：2 | next：0xc91b90（q结点） -->无尽的套娃【1 2 3 2 3 2……】
//因此必须要置空，置空的话，s在结点值为2时就为NULL，这样就不会形成连环套了
while (q!=NULL)
{
r = q->next; //暂存下一个结点
//插入【后插】，插入后此时q为前半段结点
q->next = s->next;
s->next = q;
s = q->next; //指向q的下一个结点【s始终指向第1、3、5、……、2n-1个结点，也就是保持前半部分结点不动，后半部分结点后插进这些结点之后】
q = r; //继续扫描
}
}
/* 主函数 */
int main()
{
/* 初始化表 */
LinkList L;
List_TailInsert(&L);
ListTraverse(L);
/* 测试函数 */
change_list(L);
ListTraverse(L);
system("pause");
return 0;
}
浙公网安备 33010602011771号