标签：移动 不能 构造 列表 font http 状态 nio 一个
#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);
// }
#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");
}
#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");
}
#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");
}
#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");
}
#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");
}
#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");
}
#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");
}
#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;
}
#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");
}
/* 模板代码，用于其他题目格式的复制粘贴 */
#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");
}
标签：移动 不能 构造 列表 font http 状态 nio 一个
原文地址：https://www.cnblogs.com/ZQXAYQX-1710545089/p/12970313.html
