数据结构之—线性表之—顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中

顺序表的特点：逻辑上相邻的两个元素在物理位置上也是相邻的。

顺序表的优点：可以实现随机存取数据并且复杂度相同为常量级。

顺序表的缺点：插入删除元素需要移动大量元素导致复杂度变为O(n)。

/**********************************************************************
* Copyright (c)2015,WK Studios
* Filename:   SeqList.h
* Compiler: GCC,VS,VC6.0  win32
* Author:WK
* Time: 2015 25 4
************************************************************************/

#ifndef _SEQLIST_H
#define _SEQLIST_H

#include<iostream>
#include<assert.h>
using namespace std;

#define ElemType int
#define SEQLIST_INIT_SIZE 10 //顺序表表存储空间的初始分配量
#define SEQLIST_INCREMENT 5//顺序表存储空间的分配增量
typedef struct Seqlist
{
ElemType *base;//指向顺序表存储空间首地址的基指针
size_t capacity;//顺序表的容量,就是最大长度,用无符号整型表示，以下雷同
size_t list_size;//顺序表中存在的元素的个数

}Seqlist;
//1.初始化顺序表，就是构造一个空的顺序表
bool Init_List(Seqlist &L);//void Init_List(Sqlist *L)可以使用指针也可以使用引用，只是使用指针要传入地址，以下雷同
//2.在顺序表存在的情况下销毁顺序表
bool Destory_List(Seqlist &L);
//3.在顺序表存在的情况下清空顺序表，就是将顺序表重置为空表
bool Clear_List(Seqlist &L);
//4.在顺序表存在的情况下判断是否为空表,为空返回true否则返回false
bool Is_Empty(Seqlist &L);
//5.在顺序表存在的情况下判断表是否满
bool Is_Full(Seqlist &L);
//6.在顺序表存在的情况下返回顺序表中元素的个数
size_t List_Length(Seqlist &L);
//7.在顺序表存在的情况下查找第i个数据(从1开始计数，不是用数据下标查找)，并用元素e保存
bool Find_Elem(Seqlist &L,size_t i,ElemType &e);
//8.在顺序表存在的情况下头插法插入数据e
bool Push_Front(Seqlist &L,ElemType &e);
//9.在顺序表存在的情况下尾插法插入数据e
bool Push_Back(Seqlist &L,ElemType &e);
//10.在顺序表存在的情况下删除第一个元素，并且后边的数据前移
bool Pop_Front(Seqlist &L);
//11.在顺序表存在的情况下删除最后一个元素
bool Pop_Back(Seqlist &L);
//12.在顺序表存在的情况下,给顺序表第i个(从1开始计数，不是用数据下标)位置插入数据e
bool List_Insert_Posi(Seqlist &L,size_t i,ElemType &e);
//13.在顺序表存在的情况下，显示出顺序表的元素
void List_Show(Seqlist &L);
//14.在顺序表满的情况下增加存储空间
bool Add_Mem(Seqlist &L);
//15.返回第一个数据所在位置
size_t begin();
//16.返回最后一个数据所在位置
size_t end(Seqlist &L);
//17.在顺序表存在的情况下删除指定位置i(从1开始计数，不是用数据下标)的数据
bool  List_Delet_Posi(Seqlist &L,size_t i);
//18.在顺序表存在的情况下修改指定位置i(从1开始计数，不是用数据下标)的数据
bool List_Modify_Posi(Seqlist &L,size_t i,ElemType &e);
//19.在顺序表存在的情况下修改第一个元素
bool Modify_Front(Seqlist &L,ElemType &e);
//20.在顺序表存在的情况下修改最后一个元素
bool Modify_Back(Seqlist &L,ElemType &e);
//21.在顺序表存在的情况下翻转顺序表
bool List_Rever(Seqlist &L);
//22.在顺序表存在的情况下,并且数据是数字的时候进行排序
bool List_Sort(Seqlist &L);
//23.在顺序表存在的情况下,并且数据是数字的时候并且排好序根据数值查找元素并返回数据下标
size_t List_Bin_Search(Seqlist &L,ElemType &e);
//24.在顺序表存在的情况下,根据数值查找元素(无序有序都可以查找,效率不佳)，并返回数据下标
size_t List_Normal_Search(Seqlist &L,ElemType &e);
//25.在顺序表存在的情况下根据数值删除元素
bool List_Delete_Val(Seqlist &L,ElemType &e);
//26.在顺序表存在的情况下根据数值修改元素
bool List_Modify_Val(Seqlist &L,ElemType &oe,ElemType &e);
//27.在顺序表存在的情况下判断是否有序
bool Is_Order(Seqlist &L);
#endif

/**********************************************************************
* Copyright (c)2015,WK Studios
* Filename:  main.cpp
* Compiler: GCC,VS,VC6.0  win32
* Author:WK
* Time: 2015 25 4
************************************************************************/
#include"SeqList.h"

//1.初始化顺序表，就是构造一个空的顺序表
bool Init_List(Seqlist &L)//void Init_List(Sqlist *L)可以使用指针也可以使用引用，只是使用指针要传入地址，以下雷同
{

L.base=(ElemType*)malloc(sizeof(ElemType)*SEQLIST_INIT_SIZE );
assert(L.base!=NULL);//if(!base){cout<<"内存分配失败\n";  exit(0);}
L.capacity=SEQLIST_INIT_SIZE;
L.list_size=0;
return true;
}
//2.在顺序表存在的情况下销毁顺序表
bool Destory_List(Seqlist &L)
{
free(L.base);//释放指向顺序表存储空间首地址的指针即是基址
L.base=NULL; //释放之后指针符空，防止称为野指针，导致内存泄漏
L.capacity=0;
L.list_size=0;
return true;
}
//3.在顺序表存在的情况下清空顺序表，就是将顺序表重置为空表
bool Clear_List(Seqlist &L)
{
L.list_size=0;
return true;
}
//4.在顺序表存在的情况下判断是否为空表,为空返回true否则返回false
bool Is_Empty(Seqlist &L)
{
return L.list_size==0;
}
//5.在顺序表存在的情况下判断表是否满
bool Is_Full(Seqlist &L)
{
return L.list_size>=L.capacity;
}
//6.在顺序表存在的情况下返回顺序表中元素的个数
size_t List_Length(Seqlist &L)
{
return L.list_size;
}
//7.在顺序表存在的情况下查找第i个数据(从1开始计数，不是用数据下标查找)，并用元素e保存
bool Find_Elem(Seqlist &L,size_t i,ElemType &e)
{
if(Is_Empty(L))
{
return false;
}
else
{
e=L.base[i-1];
return true;
}

}
//8.在顺序表存在的情况下头插法插入数据e
bool Push_Front(Seqlist &L,ElemType &e)
{
return  List_Insert_Posi(L,begin()+1,e);
}
//9.在顺序表存在的情况下尾插法插入数据e
bool Push_Back(Seqlist &L,ElemType &e)
{
return  List_Insert_Posi(L,end(L)+1,e);

}
//10.在顺序表存在的情况下删除第一个元素，并且后边的数据前移
bool Pop_Front(Seqlist &L)
{
return List_Delet_Posi(L,begin()+1);
}
//11.在顺序表存在的情况下删除最后一个元素
bool Pop_Back(Seqlist &L)
{
return List_Delet_Posi(L,end(L));
}
//12.在顺序表存在的情况下,给顺序表第i个(从1开始计数，不是用数据下标)位置插入数据e
bool List_Insert_Posi(Seqlist &L,size_t i,ElemType &e)
{
if(i<0||i>L.capacity+1)
{
return false;
}
if(Is_Full(L))
{
Add_Mem(L);
}
for(int j=L.list_size; j>i-1; --j)
{
L.base[j] = L.base[j-1];
}
L.base[i-1] = e;
L.list_size++;
return true;
}
//13.在顺序表存在的情况下，显示出顺序表的元素
void List_Show(Seqlist &L)
{
for(int i=0;i<L.list_size;++i)
{
cout<<L.base[i]<<" ";
}
cout<<"\n";
}
//14.在顺序表满的情况下增加存储空间
bool Add_Mem(Seqlist &L)
{
ElemType *Newbase;
if(!(Newbase=(ElemType *)realloc(L.base,(L.capacity+SEQLIST_INCREMENT)*sizeof(ElemType))))
{
cout<<"增加内存失败\n";
exit(0);
}
L.base=Newbase;
L.capacity+=SEQLIST_INCREMENT;

return true;
}
//15.返回第一个数据所在位置
size_t begin()
{
return 0;
}
//16.返回最后一个数据所在位置
size_t end(Seqlist &L)
{
return L.list_size;
}
//17.在顺序表存在的情况下删除指定位置i(从1开始计数，不是用数据下标)的数据
bool  List_Delet_Posi(Seqlist &L,size_t i)
{
if(Is_Full(L))
{
cout<<"空表无需删除数据！\n";
return false;
}
if(i<=0||i>L.capacity+1)
{
cout<<"删除元素的位置不存在！\n";
return false;
}
for(int j=i-1;j<L.list_size-1;++j)
{
L.base[j]=L.base[j+1];

}
L.list_size--;
return true;
}
//18.在顺序表存在的情况下修改指定位置i(从1开始计数，不是用数据下标)的数据
bool List_Modify_Posi(Seqlist &L,size_t i,ElemType &e)
{
if(Is_Empty(L))
{
cout<<"空表无需修改！\n";
return false;
}
L.base[i-1]=e;
return true;
}
//19.在顺序表存在的情况下修改第一个元素
bool Modify_Front(Seqlist &L,ElemType &e)
{
return List_Modify_Posi(L,begin()+1,e);

}
//20.在顺序表存在的情况下修改最后一个元素
bool Modify_Back(Seqlist &L,ElemType &e)
{
return List_Modify_Posi(L,end(L),e);
}
//21.在顺序表存在的情况下翻转顺序表
bool List_Rever(Seqlist &L)
{
if(Is_Empty(L))
{
cout<<"空表无需逆转！\n";
return false;
}
ElemType *p,*q;

for( p=L.base,q=L.base+L.list_size-1;q>p;--q,++p)
{
ElemType temp=*p;
*p=*q;
*q=temp;
}
return true;
}
//22.在顺序表存在的情况下,并且数据是数字的时候进行排序
bool List_Sort(Seqlist &L)//这里使用冒泡排序,由小到大
{
if(Is_Full(L))
{
cout<<"空表无需排序\n";
return false;
}
for(int i=0;i<L.list_size-1;i++)
for(int j=0;j<L.list_size-1-i;j++)
{
if(L.base[j]>L.base[j+1])
{
ElemType temp=L.base[j+1];
L.base[j+1]=L.base[j];
L.base[j]=temp;
}
}
return true;

}
//23.在顺序表存在的情况下,并且数据是数字的时候并且排好序根据数值查找元素并返回数据下标
size_t List_Bin_Search(Seqlist &L,ElemType &e)
{
if(Is_Empty(L))
{
cout<<"空表无需查找\n";
return -1;
}
for(int left=0,int right=L.list_size-1,int middle=(left+right)/2;
left<=right;
middle=(left+right)/2)
{

if(L.base[middle]==e)
{
return middle;
}
if(L.base[middle]>e)
{
right=middle-1;
}

if(L.base[middle]<e)
{
left=middle+1;
}
}

return -1;
}
//24.在顺序表存在的情况下,根据数值查找元素(无序有序都可以查找,效率不佳)，并返回数据下标
size_t List_Normal_Search(Seqlist &L,ElemType &e)
{
if(Is_Empty(L))
{
cout<<"空表无需查找\n";
return -1;
}
for( int i=0;i<L.list_size;++i)
{
if(L.base[i]==e)
return i;
}
return -1;
}
//25.在顺序表存在的情况下根据数值删除元素
bool List_Delete_Val(Seqlist &L,ElemType &e)
{
if(Is_Empty(L))
{
cout<<"空表无需查找\n";
return false;
}
List_Delet_Posi(L, List_Normal_Search(L,e));
}
//26.在顺序表存在的情况下根据数值修改元素
bool List_Modify_Val(Seqlist &L,ElemType &oe,ElemType &e)
{
if(Is_Empty(L))
{
cout<<"空表无需修改\n";
return false;
}
List_Modify_Posi(L, List_Normal_Search(L,oe),e);
}
//27.在顺序表存在的情况下判断是否有序
bool Is_Order(Seqlist &L)
{
if(Is_Empty(L))
{
cout<<"空表\n";
return false;
}

int flag1=0,flag2=0;
for( int i=0;i<L.list_size-1;++i)
{
if(L.base[i]<L.base[i+1])
{
flag1++;
}
if(L.base[i+1]<L.base[i])
{
flag2++;
}

}
if(flag1==L.list_size-1||flag2==L.list_size-1)
{
return true;
}
cout<<"没有排序，请先排好序！\n";
return false;
}

/**********************************************************************
* Copyright (c)2015,WK Studios
* Filename:  main.cpp
* Compiler: GCC,VS,VC6.0  win32
* Author:WK
* Time: 2015 25 4
************************************************************************/
#include"SeqList.h"
int main()
{
Seqlist mylist;
Init_List(mylist);//用指针时候必须传入地址 Init_List(&mylist)以下雷同
int select = 1;
ElemType item=0;
int pos;
while(select)
{
cout<<"************************************************"<<endl;
cout<<"* [1] Push_Front          [2] push_Back        *"<<endl;
cout<<"* [3] show                [0] quit_system      *"<<endl;
cout<<"* [4] List_Insert_Posi    [5] Pop_Front        *"<<endl;
cout<<"* [6] Pop_back            [7] List_Delet_Posi  *"<<endl;
cout<<"* [8]  Destory_List       [9]  Clear_List      *"<<endl;
cout<<"* [10] List_Modify_Posi   [11]  Modify_Front   *"<<endl;
cout<<"* [12] Modify_Back        [13] List_Rever      *"<<endl;
cout<<"* [14] List_Sort          [15] List_Bin_Search *"<<endl;
cout<<"* [16] List_Normal_Search [17] List_Delete_Val *"<<endl;
cout<<"* [18]  List_Modify_Val   [19] Find_Elem       *"<<endl;
cout<<"************************************************"<<endl;
cout<<"Please select a number which represent you want to operate:>";
cin>>select;
switch(select)
{
case 1:
cout<<"请输入要插入的数据(-1结束):>";
while(cin>>item,item!=-1)
{
Push_Front(mylist,item);
}
break;
case 2:cout<<"请输入要插入的数据(-1结束):>";
while(cin>>item,item!=-1)
{
Push_Back(mylist,item);
}

break;
case 3:
List_Show(mylist);
break;
case 4:
while(cout<<"请输入要插入的位置:(-1结束)>",
cin>>pos,
cout<<"请输入要插入的值(-1结束):>",
cin>>item ,item!=-1)
{
List_Insert_Posi(mylist,pos,item);
}
break;
case 5:
Pop_Front(mylist);
break;
case 6:

Pop_Back(mylist);

break;
case 7:
while(cout<<"请输入要删除的位置:(-1结束)>",
cin>>pos,pos!=-1)
{
List_Delet_Posi(mylist,pos);
}

break;
case 8:
Destory_List(mylist);
break;
case 9:
Clear_List(mylist);
break;
case 10:
while(cout<<"请输入要修改的位置的位置:(-1结束)>",
cin>>pos,
cout<<"请输入要修改的值(-1结束):>",
cin>>item ,item!=-1)
{
List_Modify_Posi(mylist,pos,item);
}
break;
case 11:
while( cout<<"请输入要修改的首元素值(-1结束):>",
cin>>item ,item!=-1)
{
Modify_Front (mylist,item);
}
break;
case 12:
while( cout<<"请输入要修改的尾元素值(-1结束):>",
cin>>item ,item!=-1)
{
Modify_Back(mylist,item);
}
break;
case 13:
List_Rever(mylist);
break;
case 14:
List_Sort(mylist);
break;
case 15:
if(Is_Order(mylist))
{
while( cout<<"请输入要查找的元素值(-1结束):>",
cin>>item ,item!=-1)
{
cout<<"元素所在位置："<<List_Bin_Search(mylist,item)<<"\n";
}
}
break;
case 16:
while( cout<<"请输入要查找的元素值(-1结束):>",
cin>>item ,item!=-1)
{
cout<<"元素所在位置："<<List_Normal_Search(mylist,item)<<"\n";
}

break;
case 17:
while( cout<<"请输入要删除的元素值(-1结束):>",
cin>>item ,item!=-1)
{
List_Delete_Val(mylist,item);
}

break;
case 18:
while( cout<<"请输入要修改的的旧元素值(-1结束):>",
cin>>pos,
cout<<"请输入要修改的的新元素值(-1结束):>",
cin>>item ,item!=-1)
{
List_Modify_Val(mylist,pos,item);
}
break;
case 19:
ElemType e;
while(cout<<"请输入要查找的位置值(-1结束):>",
cin>>pos,pos!=-1)
{
Find_Elem (mylist,pos,e);
}
cout<<"要查找的值是："<<e<<"\n";
break;

default:
cout<<"Thanks for using!\n";
break;
}
}

return 0;

}