《线性表的总结---线性顺序表（静态，动态）---线性链表（动态）》

//【静态顺序表的练习】
/*
需求：创建一个静态的顺序表存放整数，大小为10，完成以下操作
1，输入6个整数，打印出顺序表中的内容，并显示表中剩余的空间个数。
2，在顺序表中的第3个位置插入元素0，打印输出顺序表中的内容，并显示表中剩余的空间个数。
3，再试图插入表中第11个位置整数0，程序提示超出范围。
4，删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。
*/

/*
#include<stdio.h>
#define MaxSize 10

//想顺序表中插入元素
void insertElem(int Sqlist[],int &len,int i,int x)
{
int t;
if(len==MaxSize || i<1 || i>len+1)
{
printf("插入位置非法！ ");
return;
}
for(t=len-1;t>=i-1;t--)
Sqlist[t+1]=Sqlist[t];
Sqlist[i-1]=x;
len = len+1;
}

//向顺序表中删除元素
void DelElem(int Sqlist[],int &len,int i)
{
int j;
if(i<1 || i>len)
{
printf("This insert is illegal");
return; //非法删除
}
for(j=i;j<=len-1;j++)
Sqlist[j-1]=Sqlist[j]; //将第i个元素之后的元素前移
len = len-1;
}

//主函数
int main()
{
int Sqlist[MaxSize]; //定义一个静态顺序表
int len,i;
printf("请输入6个整数（以空格分开）:");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("表中的元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的6个整数
printf("%3d",Sqlist[i]);
//显示顺序表中的剩余空间
printf(" 表中剩余空间为：%d ",MaxSize-len);

//调用insertElem(int Sqlist[],int &len,int i,int x)函数，向顺序表中插入元素
//向顺序表中的第3位置插入整数0
printf("在表中的第3个位置插入整数0");
insertElem(Sqlist,len,3,0);
printf(" ");
printf("表中的元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的所有元素
printf("%3d",Sqlist[i]);
//显示表中剩余空间
printf(" 表中剩余空间为： %d ",MaxSize-len);

//调用insertElem(int Sqlist[],int &len,int i,int x)函数，在表中的第11位置插入整数0
printf("在表中的第11个位置插入整数0：");
insertElem(Sqlist,len,11,0);

//调用DeElem(int Sqlist[],int &len,int i)函数，删除顺序表中的第6个元素
printf("删除表中第6个元素");
DelElem(Sqlist,len,6);
printf("表中元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的所有元素
printf("%3d",Sqlist[i]);
printf(" 表中剩余空间为： %d ",MaxSize-len);
return 0;

}
*/

//【动态顺序表的练习】
/*
需求：编写一个程序，动态的创建一个顺序表。要求：顺序表的初始长度为10，向顺序表中输入15个整数
并打印出来；再删除顺序表中的第5个元素，打印出删除后的结果.
*/

/*
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType; //将int定义为ElemType
typedef struct
{
int *elem;
int length;
int listsize;
}Sqlist;

//初始化一个顺序表
void initSqlist(Sqlist &L)
{
L.elem = (int *)malloc(MaxSize*sizeof(ElemType));
if(!L.elem)
exit(0);
L.length = 0;
L.listsize = MaxSize;
}

//向顺序表中插入元素
void InsertElem(Sqlist &L,int i,ElemType item)
{//向顺序表L中第i个位置上插入元素item
ElemType *base,*insertPtr,*p;
if(i<1 || i>L.length+1)
exit(0);
if(L.length>=L.listsize)
{
base = (ElemType *)realloc(L.elem,(L.listsize+10)*sizeof(ElemType));
L.elem = base;
L.listsize+=100;
}
insertPtr = &(L.elem[i-1]); //记下要插入元素位置的地址
for(p = &(L.elem[L.length-1]);p>=insertPtr;p--)
*(p+1) = *p;
*insertPtr = item;
L.length++;
}

//从顺序表中删除元素
void DelElem(Sqlist &L,int i)
{
ElemType *delItem,*q;
if(i<1 || i>L.length)
exit(0);
delItem = &(L.elem[i-1]);
q = L.elem+L.length-1;
for(++delItem;delItem<=q;++delItem)
*(delItem-1) = *delItem;
L.length--;
}

//主函数
int main()
{
Sqlist l;
int i;
//调用initSqlist(Sqlist &L)函数，初始化一个顺序表
initSqlist(l);
printf("顺序表已创建完毕...");
printf(" ");
printf("向顺序表中插入1~15个整数(数字之间用空格分开) ");
for(i=0;i<15;i++)
InsertElem(l,i+1,i+1);
printf("这个顺序表中的元素是：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf(" ");

//调用DelElem(Sqlist &L,int i)函数，删除第5个元素
DelElem(l,5);
printf("第5个元素已被删除...");
printf(" ");
printf("元素删除后，顺序表中的元素入下：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf(" ");
return 0;
}

*/

//【数据结构版---线性表-线性表的顺序表示和实现（静态）】
//实现插入元素和删除元素的功能
/*
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MaxSize 10

typedef int Status; //函数结果状态类型
typedef int ElemType; //元素类型

//向静态顺序表中插入元素
Status InsertElem(int Sqlist[],int *len,int i,ElemType x)
{
int t;
if(*len==MaxSize || i<1 || i>*len+1)
{
printf("非法插入...");
return OVERFLOW;
}
for(t=*len-1;t>=i-1;t--)
Sqlist[t+1] = Sqlist[t];
Sqlist[i-1] = x;
*len=*len+1;
return OK;
}

//向静态顺序表中删除元素
Status DelElem(int Sqlist[],int *len,int i)
{
int j;
if(i<1 || i>*len)
{
printf("非法删除...");
exit(0);
}
for(j=i;j<*len-1;j++)
Sqlist[j-1] = Sqlist[j];
*len = *len - 1;
return OK;
}

//主函数（测试）
int main()
{
int Sqlist[MaxSize]; //定义一个静态顺序表
int len,i;
int e1,e2,x;

printf("请从键盘输入6个整数(数字之间以空格分开):");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("初始静态顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf(" 静态顺序表的剩余空间是：%d",MaxSize - len);
printf(" ");

//调用InsertElem(int Sqlist[],int *len,int i,int x)函数，插入元素
printf("输入你要插入的位置:");
scanf("%d",&e1);
printf(" ");
printf("输入你要插入的元素:");
scanf("%d",&x);
InsertElem(Sqlist,&len,e1,x);
//输出当前静态顺序表中的元素，验证是否正确插入
printf("当前顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf(" ");
printf("静态顺序表的剩余空间是：%d",MaxSize-len);
printf(" ");

//调用DelElem(int Sqlist[],int *len,int i)函数，删除指定元素
printf("输入你要删除的元素序号:");
scanf("%d",&e2);
DelElem(Sqlist,&len,e2);
//输出当前静态顺序表中的元素，验证是否正确删除
printf("当前顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf(" ");
printf("静态顺序表的剩余空间是：%d",MaxSize-len);
printf(" ");

return 0;
}
*/

//【数据结构版---线性表-线性表的顺序表示和实现（动态）】
/*
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100 //动态顺序表存储空间的初始分配量
#define LISTINCREMENT 10 //动态顺序表存储空间的分配增量

typedef int Status; //函数结果状态
typedef int ElemType; //元素类型
typedef struct
{
ElemType *elem;
int length;
int listsize;
}Sqlist;

//初始化一个顺序表
Status InitList_Sq(Sqlist &L)
{
L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)
exit(OVERFLOW); //存储分配失败
L.length = 0; //动态线性表的初始长度为0
L.listsize = LIST_INIT_SIZE; //动态线性表的初始容量
return OK;
}

//向动态线性表中插入元素
Status InsertElem(Sqlist &L,int i,ElemType e)
{
ElemType *newbase,*q,*p;
if(i<1 || i>L.length+1)
return ERROR;
if(L.length >= L.listsize)
{//当前存储空间已满，增加分配
newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); //分配失败
L.elem = newbase;
L.listsize+=LISTINCREMENT;
}
q = &(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1) = *p;
*q = e;
++L.length;
return OK;
}

//顺序表的创建

//(老师的作业结果用这个代码)
//Status Creat_Sq(Sqlist &L)
//{
// ElemType temp;
// printf("请输入你要插入到动态顺序表中的元素(ending 9999):");
// scanf("%d",&temp);
// while(temp!=9999)
// {
// InsertElem(L,L.length+1,temp);
// printf("请输入你要插入到动态顺序表中的元素(ending 9999):");
// scanf("%d",&temp);
// }
// return OK;
//}

Status Creat_Sq(Sqlist &L)
{
ElemType temp,n,i;
printf("请输入你要插入元素的个数：");
scanf("%d",&n);
printf(" 请输入你要插入的元素（以空格分开）:");
for(i=0;i<n;i++)
{
scanf("%d",&temp);
InsertElem(L,L.length+1,temp);
}
return OK;
}

//顺序表的遍历
Status Print_Sq(Sqlist L)
{
int i;
for(i=0;i<L.length;i++)
printf("%4d",L.elem[i]);
printf(" ");
return OK;
}

//向动态顺序表中删除元素
Status DelElem(Sqlist &L,int i,ElemType &e)
{
ElemType *p,*q;
if(i<1 || i>L.length)
return ERROR;
p = &(L.elem[i-1]);
e = *p; //把要删除的元素的值赋给e
q = L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1) = *p;
--L.length;
return OK;
}

//顺序表的查找
Status Locate_Sq(Sqlist L,ElemType e)
{
int i,n;
char change;
ElemType *p;
p = L.elem;
for(i=0;i<L.length;i++)
{
if(*p++ == e)
n = i;
}
printf("你要找的%d是第%d个元素 ",L.elem[n],n+1);
return OK;
}

//顺序表的排序
void Sort_Sq(Sqlist &L)
{
int i,j;
char change;
ElemType temp;
i = L.elem[L.length-1];
for(change = TRUE;i>=1;i--)
{
change = FALSE;
for(j=0;j<i-1;j++)
{
if(L.elem[j]>L.elem[j+1])
{
temp = L.elem[j];
L.elem[j] = L.elem[j+1];
L.elem[j+1] = temp;
change = TRUE;
}
}
}
}

//主函数
int main()
{
ElemType e,e1,e2,e3,e4;
Sqlist sq;

InitList_Sq(sq);
printf("动态顺序表已创建好... ");
Creat_Sq(sq);
printf(" ");
printf("顺序表中的元素有: ");
Print_Sq(sq);
printf(" ");

printf("请输入要插入的位置：");
scanf("%d",&e1);
printf(" 请输入你要插入的元素：");
scanf("%d",&e2);
InsertElem(sq,e1,e2);
printf("插入元素后，顺序表中的元素如下: ");
Print_Sq(sq);
printf(" ");

printf("请输入你要删除的元素的位置：");
scanf("%d",&e3);
DelElem(sq,e3,e);
printf("删除指定元素后，顺序表中的元素如下： ");
Print_Sq(sq);
printf(" ");

printf("请输入你要查找的元素：");
scanf("%d",&e4);
Locate_Sq(sq,e4);

Sort_Sq(sq);
printf("排序后的结果是： ");
Print_Sq(sq);
return 0;
}
*/

//【数据结构版--线性表的链式表示和实现】
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //infeasible-->不可行的
#define NULL 0

typedef int Status;
typedef int ElemType;

//定义结构体
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;

//带表头结点的单链表的插入
Status Listinsert_L(LinkList &L,int i,ElemType e)
{
LinkList p,s;
int j;
p = L;
j = 0;
while(p && j<i-1)
{
p = p->next;
++j;
}
if(!p || j>i-1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); //生产新结点
s->data=e;
s->next=p->next;
p->next=s;
L->data++;
return OK;
}

//【头插法】逆序输入n个元素的值，创建一个带表头节点的单链表
/*
void CreatList_L(LinkList &L,int n)
{
int i;
LNode *p;

L=(LinkList)malloc(sizeof(LNode));
L->data=0; //令表头中的数据域内的值为0（其值为表中元素的个数）
L->next=NULL; //建立带表头节点的单链表
printf("Please input data:(输入8个整数,由大到小输入) ");
for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next = L->next;
L->next=p;
L->data++; //递增表中元素的个数
}
// printf("%d",L->data); //此处L->data的功能是输出表中元素的个数
}
*/
//尾插法
Status CreatList_L(LinkList &L)
{
ElemType temp;
L=(LinkList)malloc(sizeof(LNode));
if(!L) return ERROR;
L->data=0;
L->next=NULL;
printf("Please Input data (9999) ending ");
scanf("%d",&temp);
while(temp!=9999)
{
Listinsert_L(L,L->data+1,temp);
scanf("%d",&temp);
}
return OK;
}

//查找单链表中第i个元素，若存在，其值赋给e并返回OK,否则返回ERROR
Status GetElem_L(LinkList L,int i,ElemType &e)
{
//L为带头结点的单链表的头指针
LNode *p1;
p1=L->next;
int j=1; //初始化，p指向第一个结点，j为计数器
while(p1 && j<i)
{
p1 = p1->next;
++j;
}
if(!p1 || j>i)
return ERROR; //第i个元素不存在
e=p1->data;
return OK;
}

//带头结点单链表的删除
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
LNode *p,*q;
int j;
p = L;
j=0;
while(p->next && j<i-1) //注意不能写成（p && j<i-1）
{
p=p->next;
++j;
}
if(!(p->next) || j>i-1)
return ERROR;
q = p->next;
p->next = q->next;
e = q->data;
//printf("%d",e);
free(q);
L->data--; //使链表中的元素个数减一
return OK;
}
//求单链表的长度的函数
void Length_L(LinkList L)
{
int num=0;
LinkList p;
p=L->next;
while(p)
{

printf("%3d",p->data);
p=p->next;
num++;
}
printf(" 这个单链表的长度为：%d",num);
}

//定义输出链表函数
Status Print_L(LinkList L)
{
LinkList p;
p=L->next;
printf("this list contains %d elements ",L->data);
while(p)
{
printf("%4d->",p->data);
p=p->next;
}
printf("NULL ");
return OK;
}

/*已知线性表中的元素以值递增有序排列,并以单链表作存储结构。
写一高效算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）
同时释放被删节点空间，并分析算法时间复杂度。

（考虑当这个线性表不是有序排列该怎么办，那就写一个单链表的排序算法，
若单链表的元素无序，则先调用排序算法进行排序，再调用此算法进行删除）*/

Status Delete_Between(LinkList &L,int mink,int maxk)
{
LNode *p,*q;
p = L;
while(p->next->data<=mink)
p=p->next; //p是最后一个不大于mink的元素
if(p->next) //如果还有比mink更大的元素
{
q=p->next;
while(q->data<maxk)
q=q->next; //q是第一个不小于maxk的元素
p->next=q;
}
return OK;

}
//建立主函数
int main()
{
LinkList L;
int n=8,i,i_1,i_2,e,e_1,e_2,e_3,e_4;

//调用CreatList_L函数，创建一个单链表
//printf("Please input the number in the list: ");
//CreatList_L(L,n); //调用头插法时用
CreatList_L(L);
printf(" ");

//调用GetElem_L函数，查找单链表中的第i个元素,调用Length_L函数，求表长
printf("单链表中的数据为： ");
Print_L(L);
printf(" ");
printf(" 请输入你要获取的元素序号:");
scanf("%d",&i);
GetElem_L(L,i,e);
printf("the %dth number is:%d",i,e);
printf(" ");

//调用Listinsert_L函数，实现元素插入功能,然后调用输出链表函数，输出插入后的链表
printf("清输入插入元素的位置： ");
scanf("%d",&i_1);
printf(" 请输入要插入的元素： ");
scanf("%d",&e_1);
Listinsert_L(L,i_1,e_1);
Print_L(L);
printf(" ");

//调用Delete函数，用来删除指定的元素,然后再调用Print_L函数输出删除元素后的链表
printf("请输入要删除的位置是： ");
scanf("%d",&i_2);
ListDelete_L(L,i_2,e_2);
Print_L(L);
printf(" ");

//调用Delete_Between函数，用来删除指定两个元素之间的元素,然后调用Print函数，输出操作后的链表
printf(" 删除a和b之间的元素，请输入：");
scanf("%d%d",&e_3,&e_4);
Delete_Between(L,e_3,e_4);
Length_L(L);
Print_L(L);
printf(" ");

return 0;
}