// 180316数据结构.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "stdio.h"
#define LISTSIZE 100
typedef int DataType;//typedef用户自定义数据类型，定义DataType为整型，增加程序的可移植性
/*结构体类型定义顺序表类型*/
typedef struct {
//数组在内存中占用一组连续的内存空间，具有表现顺序表存储区域的优越特性
DataType items[LISTSIZE];//元素数据类型为抽象类型,具体实现时定义为具体类型;此处静态存储
int length;//表长
}SqList;
/*建立顺序表*/
void Create_SqList(SqList *L)
{
//ListEmpty(*L);？？？
int i,n;
printf("请输入待建立的顺序表表长：");
scanf_s("%d", &n);
for (i = 0;i < n;i++)
scanf_s("%d",&L->items[i]);
L->length = n;//??。
/*for (i=0;i<L->length;i++)
{
printf("%d",L->items[i]);//取地址里面的元素
}*/
printf("顺序表创建成功！！\n");
}
/*初始化顺序表*/
/*int InitList(SqList *L)//初始化顺序表
{/*L为指向顺序表的指针*/
/*L->length = 0;
return 1;//可能出现异常
}*/
/*求顺序表的表长*/
int ListLength(SqList L) {
//printf("\n 顺序表初始长度：%d", L.length);
return L.length;
}
/*判断顺序表是否为空:若为0，返回1*/
int ListEmpty(SqList L) {
/*L为顺序表*/
if (L.length == 0)
{
// printf("顺序表为空！");
return 1;//返回异常
}
else
{
//printf("\n 顺序表不为空！");
return 0;
}
}
/*判断顺序表是否已满:L.length==LISTSIZE*/
/*int Full_List(SqList L)
{
if (L.length == LISTSIZE)
{
return 1;
}
else
{
printf("顺序表未满！");
return 0;
}
}//Full_List(fibo);*/
/*int Full_List(SqList *L)
{
if (L->length == LISTSIZE)
{
return 1;
}
else
{
printf("顺序表未满！");
return 0;
}
}//Full_List(&fibo);
*/
int Full_List(SqList &L)
{
if (L.length == LISTSIZE)
{
return 1;
}
else
{
printf("顺序表未满！");
return 0;
}
}
/*清空顺序表*/
void Clear_List(SqList L)
{
L.length = 0;
}
/*显示顺序表：直接根据数组下标打印出各数据元素*/
void Print_SqList(SqList L)
{
if (ListEmpty(L) == 1)
{
printf("空表\n");
return;
}
else
{
printf("\n该顺序表中的所有数据元素依此为:");
for (int i = 0;i < ListLength(L);i++)
printf("%d\t", L.items[i]);
}
}
//查找系列操作：
/*取顺序表中的数据元素(按位置查找）：返回第i个数据元素,[i-1]:根据数组下标随机存取数据，需要考虑位置的合法性以及顺序表是否为空*/
int Get_SqListElem(SqList L, int i)
{
if (ListEmpty(L) || i<1 || i>ListLength(L))
{
printf("\n表空或输入的位置不对！\n");
return 1;
}
printf("\n顺序表第%d个位置上的元素为:%d\n",i,L.items[i-1]);
return L.items[i - 1];
}//时间复杂度为：O（1）
/*按元素查找*/
int Find(SqList L, DataType item) {
/*L为顺序表，item为待查找的数据元素*/
int pos = 0;
if (ListEmpty(L)) {
printf("顺序表为空表，无法进行查找操作！\n");
return 1;
}
while (pos < L.length && L.items[pos] != item)
pos++;
if (pos < L.length)//？？
{
//return pos + 1;
printf("\n%d为顺序表中第%d个元素\n", item, pos + 1);
return pos + 1;
}
else
return 0;
}//时间复杂度为：O（n）
/*寻找数据元素的前驱：利用顺序表在逻辑结构相邻的结点，存储位置也相邻*/
DataType Locate_Prior(SqList L, DataType e)
{
int i = 0;
while (i < L.length && L.items[i] != e)
i++;
if (i == 0)
{
printf("第一个元素没有前驱结点！\n");
return 0;
}
else if(i<=L.length-1)
{
printf("\n结点%d的前驱结点为：%d\n", e, L.items[i-1]);
return L.items[i - 1];
}
else {
printf("\n所查找元素不属于该顺序表！\n");
return 0;
}
}//时间复杂度为：O（n）
/*插入*/
SqList ListInsert(SqList *L, int pos, DataType item) {
/*pos为插入位置，item为待插入的数据元素*/
int i;
if (L->length >= LISTSIZE) {//避免产生上溢出错
printf("顺序表已满，无法进行插入操作！\n");
}
if (pos <1 || pos > L->length + 1) {//1<=i<=n+1
printf("插入位置不合法,其取值范围应该是[1,length+1]\n");//
}
for (i = L->length - 1;i >= pos - 1;i--)/*移动元素???为什么是length-1*:位序和数组下标的关系*/
L->items[i + 1] = L->items[i];/*插入*/
L->items[pos - 1] = item;//？？？
L->length++;//表长增一
return *L;
}//平均时间复杂度为：o(n)
/*遍历*/
/*int TraverseList(SqList L) {/*L为顺序表*/
/*int i;
for (i = 0;i < L.length;i++)
printf("%d\t", L.items[i]);
printf("\n");
return 1;
}*/
/*删除*/
SqList ListDelete(SqList *L, int pos) {//删除
int i;
if (ListEmpty(*L)) {//避免下溢
printf("顺序表为空表，无法进行删除操作！\n");
}
if (pos < 1 || pos>L->length) {
printf("删除位置不合法,[1,length]\n");
}
for (i = pos;i < L->length;i++)/*移动并删除指定元素*/
L->items[i - 1] = L->items[i];
L->length--;/*表长减一*/
return *L;
}//平均时间复杂度为：o(n)
/*删除顺序表中最小值返回，并用表尾元素代替空出的位置：*/
bool Del_Min_Elem(SqList &L)
{
int pos=0;//记录最小值的位置
if (ListEmpty(L) == 1)
return false;
int min_elem = L.items[0];
for(int i=0;i<L.length;i++)
if (L.items[i] < min_elem)
{
min_elem=L.items[i];
pos = i;
}
printf("\n被删除的最小值为：%d\n",min_elem);
L.items[pos] = L.items[L.length-1];
L.length--;
return true;
}
/*删除所有值为x的数据元素：*/
SqList Del_value_x(SqList &L, DataType x)//为什么用&L,L却失败！！！
{
int k = 0;
for (int i = 0;i < L.length;i++)
if (L.items[i] != x)
{
L.items[k] = L.items[i];
k++;
}
L.length = k;
return L;
}
/*删除相同元素*/
/*void Repetition(SqList *L) {
int i, j;
DataType item;
for (i = 0;i < L->length;i++) {
j = i + 1;
//与顺序表第i个位置后的所有元素相比较，若有相同，则删除
while (j<L->length)
{
if (L->items[j] == L->items[i])
ListDelete(L, j + 1, &item);
else
j++;
}
}*/
/*顺序表逆置：*/
void Reverse(SqList &L)
{
int i;
DataType x;
for (i = 0;i < L.length / 2;i++)
{
x = L.items[i];
L.items[i] = L.items[L.length - i - 1];
L.items[L.length - i -1] = x;
}
}
/*删除s,t之间的值*/
bool del_s_t(SqList &L, DataType s, DataType t)
{
int k = 0;
if (L.length == 0 || s >= t)
return false;
for (int i = 0;i < L.length;i++)
if (L.items[i] >= s && L.items[i] <= t)
{
k++;
}
else {
L.items[i - k] = L.items[i];
}
L.length -= k;
return true;
}
int main()
{
/*int i = 0;
int data[7] = { 0,1,1,2,3,5,8 };*/
//DataType item;
SqList fibo;
Create_SqList(&fibo);//创建顺序表
ListEmpty(fibo);
Full_List(fibo);
ListLength(fibo);//求顺序表长
//Clear_List(fibo);?
//ListEmpty(fibo);?
Get_SqListElem(fibo, 3);
Print_SqList(fibo);
Find(fibo, 2);
Locate_Prior(fibo, 2);
ListInsert(&fibo, 3, 300);
Print_SqList(fibo);
ListDelete(&fibo, 2);
Print_SqList(fibo);
Del_Min_Elem(fibo);
Print_SqList(fibo);
Reverse(fibo);
Print_SqList(fibo);
Del_value_x(fibo, 8);
Print_SqList(fibo);
del_s_t(fibo, 3, 5);
Print_SqList(fibo);
//printf("\n\n建立顺序表\n\n");
//InitList(&fibo);
/*建立顺序表*/
/*for (i = 0;i < 7;i++)
{
if (!ListInsert(&fibo, i + 1, data[i]))
{
printf("\n运行错误\n");
return 0;
}
}*/
//printf("\n\n删除前的顺序表元素\n");
//TraverseList(fibo);
/*del_s_t(fibo,2,3);
TraverseList(fibo);*/
/*printf("\n\n删除前逆置的顺序表\n");
Reverse(fibo);
TraverseList(fibo);
if (!ListDelete(&fibo, 7, &item))
{
printf("\n运行错误！\n");
return 0;
}
printf("\n\n删除后的顺序表\n");
TraverseList(fibo);
printf("\n\n查找元素的位置：\n");
Find(fibo, 2);
printf("\n\n删除相同元素后的顺序表\n\n");
Repetition(&fibo);
TraverseList(fibo);
printf("\n\n删除后的表长\n");
ListLength(fibo);*/
getchar();
return 1;
}