顺序表的基本操作

顺序表的顺序存储

#include <stdio.h>
#include <conio.h>//主要用来处理一些人为的输入输出操作
#define MAX 30    //定义线性表的最大长度
enum BOOL{False,True};  //定义BOOL型，判断类型只用来判断返回值的真假，Bool类型只有TRUE和FALSE两种状态
typedef struct{
   char elem[MAX];       //线性表
   int last;             //last指示当前线性表的长度
}sqlist;
void initial(sqlist &v);    //初始化线性表
BOOL insert(sqlist &v,int loc,char ch); //在线性表中插入元素
BOOL del(sqlist&v,int loc,char &ch);   //在线性表中删除元素
int locate(sqlist v,char ch);        //在线性表中定位元素 
void print(sqlist v);             //显示线性表中所有元素
int main()
{sqlist S;      //S为一线性表
 int loc,flag=1;
 char j,ch;
 BOOL temp;
printf("本程序用来实现顺序结构的线性表。\n");
 printf("可以实现查找、插入、删除等操作。\n");
 initial(S);         //初始化线性表
 while(flag)
    { printf("请选择:\n");
      printf("1.显示所有元素\n");
      printf("2.插入一个元素\n");
      printf("3.删除一个元素\n");
      printf("4.查找一个元素\n");
      printf("5.退出程序    \n");
      scanf(" %c",&j);
      switch(j)
	{case '1':print(S); break; //显示所有元素
	 case '2':{printf("请输入要插入的元素(一个字符)和插入位置:\n");
		   printf("格式：字符，位置；例如:a,2\n");
		   scanf(" %c,%d",&ch,&loc);  //输入要插入的元素和插入的位置
		   temp=insert(S,loc,ch);     //插入
		   if(temp==False)  printf("插入失败!\n");  //插入失败
                   else  {printf("插入成功!\n");   print(S);} //插入成功
		   break;
		  }
	 case '3':{printf("请输入要删除元素的位置:");
		   scanf("%d",&loc);    //输入要删除的元素的位置
		   temp=del(S,loc,ch);  //删除
		   if(temp==True) printf("删除了一个元素:%c\n",ch); //删除成功
		   else printf("该元素不存在!\n");  //删除失败
		   print(S);
		   break;
		  }
	 case '4':{printf("请输入要查找的元素:");
		   scanf(" %c",&ch);      //输入要查找的元素
		   loc=locate(S,ch);      //定位
		   if(loc!=-1) printf("该元素所在位置:%d\n",loc+1); //显示该元素位置
		   else    printf("%c 不存在!\n",ch);//当前元素不存在
		   break;
		  }
	 default:flag=0;printf("程序结束，按任意键退出!\n");
	}
    }
 getch();
}
void initial(sqlist &v)
{//初始化线性表
 int i;
 printf("请输入初始线性表长度：n="); //输入线性表初始化时的长度
 scanf("%d",&v.last);
 printf("请输入从1到%d的各元素(字符)，例如:abcdefg\n",v.last);
 getchar();
 for(i=0;i<v.last;i++) scanf("%c",&v.elem[i]); //输入线性表的各元素
}

BOOL insert(sqlist &v,int loc,char ch)        
{//插入一个元素，成功返回True，失败返回False
 int i;
 if((loc<1)||(loc>v.last+1))
   {printf("插入位置不合理!\n");  //位置不合理
    return False;
   }
 else if(v.last>=MAX)         //线性表已满
     {printf("线性表已满!\n");
      return False;
     }
 else {for(i=v.last-1;i>=loc-1;i--) v.elem[i+1]=v.elem[i];//其后元素依次后移
       v.elem[loc-1]=ch;     //插入元素
       v.last++;                      //线性表长度加一
       return True;
     }
}

BOOL del(sqlist &v,int loc,char &ch)           
{//删除一个元素，成功返回True，并用ch返回该元素值，失败返回False
 int j;
 if(loc<1||loc>v.last)    //删除位置不合理
    return False;
 else {ch=v.elem[loc-1];  //ch取得该元素值
       for(j=loc-1;j<v.last-1;j++) v.elem[j]=v.elem[j+1];   //其后元素依次前移
       v.last--;       //线性表长度减一
       return True;
      }
}

int locate(sqlist v,char ch)
{//在线性表中查找ch的位置，成功返回其位置，失败返回-1
 int i=0;
 while(i<v.last&&v.elem[i]!=ch) i++;  //当前位置后移，直到找到为止
 if(v.elem[i]==ch)               //找到当前元素
    return i;
 else  return(-1);
}
void print(sqlist v)          //显示当前线性表所有元素
{int i;
 for(i=0;i<v.last;i++) printf("%c ",v.elem[i]);
 printf("\n");
}

顺序表的链式存储

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(LNode)  //定义LEN为一个节点的长度
enum BOOL{False,True};  //定义BOOL型
typedef struct node
{char data;    //数据域
 struct node *next;//指向下一个节点的指针（指针域） 
}LNode,*LinkList;
void CreatList(LinkList &,int);   //生成一个单链表
BOOL ListInsert(LinkList &,int,char); //在单链表中插入一个元素
BOOL ListDelete(LinkList &,int,char &); //在单链表中删除一个元素
BOOL ListFind_keyword(LinkList,char,int &); //按关键字查找一个元素
BOOL ListFind_order(LinkList,char &,int);  //按序号查找一个元素
void ListPrint(LinkList);      //显示单链表所有元素
int main()
{LinkList L;
 BOOL temp;
 int num,loc,flag=1;
 char j,ch;
 printf("本程序实现链式结构的线性表的操作。\n");
 printf("可以进行插入，删除，定位，查找等操作。\n");
 printf("请输入初始时链表长度:"); //输入生成单链表时的元素个数
 scanf("%d",&num);
 CreatList(L,num);      //生成单链表
 ListPrint(L);          
 while(flag)
    { printf("请选择:\n");
      printf("1.显示所有元素\n");  //显示链表元素
      printf("2.插入一个元素\n");  //插入链表元素
      printf("3.删除一个元素\n");  //删除链表元素
      printf("4.按关键字查找元素\n");  //按关键字查找
      printf("5.按序号查找元素\n"); //按序号查找
      printf("6.退出程序      \n");  //退出
      scanf(" %c",&j);//字符类型 
      switch(j)
	{case '1':ListPrint(L); break;//条件数字也是字符类型 
	 case '2':{printf("请输入元素(一个字符)和要插入的位置:\n");
		   printf("格式:字符，位置；例如:a,3\n");
		   scanf(" %c,%d",&ch,&loc);       //输入要插入的元素和要插入的位置    %c前的空格吃的是换行 
		   temp=ListInsert(L,loc,ch);      //插入
		   if(temp==False) printf("插入失败!\n"); //插入失败
		   else printf("插入成功!\n"); //成功插入
		   ListPrint(L);
		   break;
		  }
	 case '3':printf("请输入要删除的元素所在位置:");
		  scanf("%d",&loc);              //输入要删除的节点的位置
		  temp=ListDelete(L,loc,ch);    //删除
		  if(temp==False) printf("删除失败!\n"); //删除失败
		  else printf("成功删除了一个元素:%c\n",ch);   //删除成功，显示该元素
		  ListPrint(L);
		  break;
	 case '4':if(L->next==NULL)                   //链表为空
		     printf("链表为空!\n");
		  else{printf("请输入要查找的元素(一个字符):");
		       scanf(" %c",&ch);                //输入要查找的元素  空格基本上都是用来吃换行的 
		       temp=ListFind_keyword(L,ch,loc); //按关键字查找
		       if(temp==False) printf("没有找到该元素!\n"); //查找失败
		       else printf("该元素在链表的第%d个位置。\n",loc); 
                                         //成功查找，显示该元素位置
		      }
		  break;
	 case '5':if(L->next==NULL)                   //链表为空
		     printf("链表为空!\n");
		  else{printf("请输入要查找的位置:");
		       scanf("%d",&loc);    //输入要查找的元素的位置
		       temp=ListFind_order(L,ch,loc); //按序号查找
		       if(temp==False) printf("该位置不存在!\n"); //查找失败
		       else printf("第%d个元素是：%c\n",loc,ch);
                                //成功查找，显示该元素
		      }
		  break;
	 default:flag=0;printf("程序结束，按任意键退出!\n");
	}
    }
getch();  //用来执行退出程序 
}
void CreatList(LinkList &v,int n)
{//生成一个带头结点的有n个元素的单链表 
 int i;
 LinkList p;
 v=(LinkList)malloc(LEN); //生成头结点
 v->next=NULL;
 printf("请输入%d个字符：例如：abcdefg\n",n);
 getchar();
 for(i=n;i>0;--i)
    {p=(LinkList)malloc(LEN); //生成新结点
     scanf("%c",&p->data);
     p->next=v->next;
     v->next=p;
    }
}
BOOL ListInsert(LinkList &v,int i,char e)
{//在单链表的第i各位置插入元素e，成功返回True，失败返回False
 LinkList p,s;
 int j=0;
 p=v;
 while(p&&j<i-1) {p=p->next;++j;} //查找第i-1个元素的位置
 if(!p||j>i-1) return False;  //没有找到
 s=(LinkList)malloc(LEN);     //生成一个新结点     
 s->data=e;            
 s->next=p->next;        //将新结点插入到单链表中 
 p->next=s;
 return True;
}

BOOL ListDelete(LinkList &v,int i,char &e)
{//在单链表中删除第i个元素，成功删除返回True，并用e返回该元素值，失败返回False
 LinkList p,q;
 int j=0;
 p=v;
 while(p->next&&j<i-1)  //查找第i-1个元素位置
    {p=p->next;++j;}
 if(!(p->next)||j>i-1) return False; //查找失败
 q=p->next;p->next=q->next; //删除该元素    
 e=q->data;         //e取得该元素值
 free(q);           //释放该元素空间
 return True;
}

BOOL ListFind_keyword(LinkList v,char e,int &i)
{//在单链表中查找关键字为e的元素，成功返回True,并用i返回该元素位置，
 //失败返回False
 i=1;
 LinkList p;
 p=v->next;
 while((p->data!=e)&&(p->next!=NULL))//p指针指向下一个，直到
    {p=p->next;  i++;}                        //找到或到链表尾为止
 if(p->data!=e)                      //该元素在链表中不存在
     return False;
 else return True;
}

BOOL ListFind_order(LinkList v,char &e,int i)
{//在单链表中查找第i个元素，成功返回True，并用e返回该元素值，
 //失败返回False
 LinkList p;
 int j=0;
 p=v;
 while(p->next&&j<i)  //移动指针，直到找到第i个元素
    {p=p->next;++j;}
 if(j!=i) return False; //查找失败 链表的长度不够，查找位置超过了链表的长度 
 else {e=p->data;       //查找成功，用e取得该元素值
       return True;
      }
}
void ListPrint(LinkList v)   
{//显示链表所有元素
 LinkList q;
 q=v->next;
 printf("链表所有元素:");
 while(q!=NULL)
   {printf("%c ",q->data);q=q->next;}
 printf("\n");
}

实现顺序表的链式存储