（C语言）自拟顺序表的各种操作

最新推荐文章于 2024-01-20 18:51:44 发布

snow_5288

最新推荐文章于 2024-01-20 18:51:44 发布

阅读量627

点赞数 1

分类专栏： C语言数据结构小项目 C语言之旅 C->C++过渡

本文链接：https://blog.csdn.net/snow_5288/article/details/51520287

版权

C语言同时被 3 个专栏收录

51 篇文章 3 订阅

订阅专栏

C语言之旅

46 篇文章 7 订阅

订阅专栏

数据结构

29 篇文章 1 订阅

订阅专栏

头文件：

#define _CRT_SECURE_NO_WARNINGS 1
#ifndef _SEQLIST_H__
#define _SEQLIST_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>


#define MAX 100
typedef int TYPE;
typedef struct Seqlist
{
   TYPE data[MAX];//顺序表的最大容量
   int sz;//当前顺序表的容量
}Seqlist,*pSeqlist;

enum OP
{
	EXIT,
    PRINT,
	PUSH_BACK,
	POP_BACK,
	PUSH_FRONT,
	POP_FRONT,
	INSERT_POS,
	REMMOVE_POS,
	REMMOVE_ALL,
	SORT,
	BIN_SEARCH
};

void menu();//打印菜单
void init_seqlist(pSeqlist seq);//初始化顺序表
void print_seqlist(pSeqlist seq);//打印顺序表
void push_back(pSeqlist seq,TYPE x);//删除顺序表的尾部元素
void pop_back(pSeqlist seq);//在顺序表的尾部插入一个元素
void push_front(pSeqlist seq,TYPE x);//删除顺序表的首部元素
void pop_front(pSeqlist seq);//在顺序表的首部插入一个元素
void insert_pos(pSeqlist seq,TYPE pos,TYPE x);//在特定位置插入元素x
void remmove_pos(pSeqlist seq, TYPE x);//删除顺序表中的特定元素x
void remmove_all(pSeqlist seq,TYPE x);//删除所有值为x的元素
void sort(pSeqlist seq);//排序顺序表（可通过冒泡排序，快速排序，选择排序等多种排序方法）
int binary_search(pSeqlist seq,TYPE x);//二分查找顺序表中特定元素x


#endif//_SEQLIST_H__

主函数部分：

#include"seq.h"

int main()
{
	TYPE x=0;
	int input=1;
	int sz=0;
	int pos=0;
	int ret=0;
	Seqlist seq;
	init_seqlist(&seq);
	while(input)
	{
		menu();
		printf("请输入一个你要进行的操作:");
		scanf("%d",&input);
		switch(input)
		{
		case PRINT:
			print_seqlist(&seq);
			break;
		case PUSH_BACK:
			printf("一个你要添加的元素:");
			scanf("%d",&x);
			push_back(&seq,x);
			break;
		case POP_BACK:
			pop_back(&seq);
			break;
		case PUSH_FRONT:
			printf("一个你要添加的元素:");
			scanf("%d",&x);
			push_front(&seq,x);
			break;
		case POP_FRONT:
			pop_front(&seq);
			break;
		case INSERT_POS:
			printf("请输入你要添加的位置：");
			scanf("%d",&pos);
			printf("一个你要添加的元素:");
			scanf("%d",&x);
            insert_pos(&seq,pos,x);
			break;
		case REMMOVE_POS:
			printf("请输入你要删除的位置：");
			scanf("%d",&pos);
			remmove_pos(&seq,pos);
			break;
		case REMMOVE_ALL:
			printf("一个你要删除的元素:");
			scanf("%d",&x);
			remmove_all(&seq,x);
			break;
		case SORT:
			sort(&seq);
			break;
		case BIN_SEARCH:
			printf("一个你要查找的元素:");
			scanf("%d",&x);
			ret=binary_search(&seq,x);
			printf("你要查找的数为：%d\n",ret);
			break;
		case EXIT:
			break;
		}

	}
	system("pause");
	return 0;
}

函数实现部分：

#define _CRT_SECURE_NO_WARNINGS 1
#include"seq.h"
void menu()
{
     
	 printf("********************\n");
	 printf("***1.print_seqlist**\n");
	 printf("***2.push_back******\n");
	 printf("***3.pop_back*******\n");
	 printf("***4.push_front*****\n");
	 printf("***5.pop_front******\n");
	 printf("***6.insert_pos*****\n");
	 printf("***7.remmove_pos****\n");
	 printf("***8.remmove_all****\n");
	 printf("***9.sort***********\n");
	 printf("**10.binary_search**\n");
	 printf("**0.exit***********\n");


}
void init_seqlist(pSeqlist seq)//初始化顺序表
{
	seq->sz=0;
	memset(seq->data,0,MAX*sizeof(TYPE));
}
void print_seqlist(pSeqlist seq)//打印顺序表
{
	int i=0;
	for(;i<seq->sz;i++)
	{
		printf("%d ",seq->data[i]);
	}
	printf("\n");
}
void push_back(pSeqlist seq,TYPE x)//顺序表的尾部插入元素x
{
	if(seq->sz == MAX)
	{
		printf("该顺序表已满\n");
		return ;
	}
	else
	{
		seq->data[seq->sz]=x;
		seq->sz++;
	}
}
void pop_back(pSeqlist seq)//在顺序表的尾部一个删除元素
{
	if(seq->sz == 0)
	{
		printf("顺序表已空\n");
		return ;
	}
	else
	{
		seq->sz--;
	}
}
void push_front(pSeqlist seq,TYPE x)//顺序表的首部插入元素x
{
	if(seq->sz==MAX)
	{
	    printf("顺序表已满!\n");
		return;
	}
	else
	{
		int i=0;
		for(i=0; i<seq->sz; i++)
		seq->data[seq->sz+i]=seq->data[seq->sz-1+i];
	}
	seq->data[0]=x;
	seq->sz++;
}
void pop_front(pSeqlist seq)//在顺序表的首部删除一个元素
{
	if(seq->sz==0)
	{
	   printf("顺序表已空！\n");
	   return;
	}
	else
	{
	    int i=0;
		for(i=0; i<seq->sz; i++)
		seq->data[i]=seq->data[i+1];
		seq->sz--;

	}
	
}
void insert_pos(pSeqlist seq,TYPE pos,TYPE x)//在特定位置插入元素x
{
	if(seq->sz==MAX)
	{
	    printf("顺序表已满！\n");
		return ;
	}
	else
	{
			int i=0;
			for(i=seq->sz-1; i>=pos; i--)
			{
				seq->data[i+1]=seq->data[i];seq->sz++;
			}
			seq->data[pos]=x;
			seq->sz++;	
	}
}
void remmove_pos(pSeqlist seq, TYPE x)//删除顺序表中的特定元素x
{
	if(seq->sz==0)
	{
	     printf("顺序表已空！\n");
	}
	else
	{ 
	   int i=0;
	   for(i=0; i<seq->sz; i++)
	   {
		   if(seq->data[i]==x)
		   {
			   seq->data[i]=seq->data[i+1];
		   }
	   }
	   seq->sz--;
	}
}
void remmove_all(pSeqlist seq,TYPE x)//删除所有值为x的元素
{
	if(seq->sz==0)
	{
	     printf("顺序表已空！\n");
	}
	else
	{
	   int count=0;
	   int i=0;
	   for(i=0; i<seq->sz; i++)
	   {
		   if(seq->data[i]==x)
		   {
			   count++;
			   seq->data[i]=seq->data[i+1];
		   }
	   }
	   seq->sz=seq->sz-count;
	}
}
void sort(pSeqlist seq)//排序顺序表（可通过冒泡排序，快速排序，选择排序等多种排序方法）
{
	if(seq->sz==0)
	{
	    printf("顺序表为空！\n");
	}
	else
	{
	    int i=0;
		int j=0;
		
		for(i=0; i<seq->sz; i++)
		{
		    for(j=0; j<seq->sz-i; j++)
			{
				if(seq->data[j]>seq->data[j+1])
				{
				   TYPE tmp=0;
				   tmp=seq->data[j];
				   seq->data[j]=seq->data[j+1];
				   seq->data[j+1]=tmp;
				}
			}
		}
		printf("排序成功！\n");
	}
}
int binary_search(pSeqlist seq,TYPE x)//二分查找顺序表中特定元素x
{
	if(seq->sz==0)
	{
	    printf("顺序表为空！\n");
	}
	else
	{
		
	    int left=0;
		int right=seq->sz-1;
		int mid=(right-left)/2+left;
		Seqlist pseq;
		sort(&pseq);//勿忘二分查找的前提必须为有序数组
		while(left<right)
		{
			if(seq->data[x]<seq->data[mid])
			{
			    right=mid-1;
			}
			else if(seq->data[x]>seq->data[mid])
			{
			    left=mid+1;
			}
			else
			{
				return seq->data[mid];
			}
			left--;
			right++;
		}
  return  seq->data[mid];
  printf("查找成功！\n");
	}
}

有问题及时call我哦！

再一遍

头文件：

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
//#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define MAX 10
typedef int Datatype;

typedef struct SeqList
{
	Datatype arr[MAX];
	int size;
}SeqList,*pseq;

void init_seqlist(pseq seq);
void print_seqlist(pseq seq);
void pushback(pseq seq,Datatype x);
void popback(pseq seq);
void pushfront(pseq seq,Datatype x);
void popfront(pseq seq);
void insert(pseq seq,int pos,Datatype x);
void erase(pseq seq,int pos);
int find(pseq seq,Datatype x);
void remmove(pseq seq,Datatype x);
void remmove_all(pseq seq,Datatype x);
void empty(pseq seq);


#endif //__SEQLIST_H__

测试代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"

void menu()
{
	printf("0.exit*************1.print_SeqList*****\n");
	printf("2.pushback*********3.pophback**********\n");
	printf("4.pushfront********5.popfront**********\n");
	printf("6.insert***********7.erase*************\n");
	printf("8.find*************9.remmove***********\n");
	printf("10.remmove_all*****11.empty************\n");
}
int main()
{
   int input = 1;
   SeqList seqlist;
   init_seqlist(&seqlist);
   while(1)
   {
	   menu();
	   printf("请输入你要操作的菜单选项：");
       scanf("%d",&input);
	   switch(input)
	   {
	   case 1:
		   print_seqlist(&seqlist);
		   break;
	   case 2:
		   {
			   Datatype x = 0;
			   printf("请输入你要插入的元素:");
			   scanf("%d",&x);
			   pushback(&seqlist,x);
		   }
		   break;
	   case 3:
		   popback(&seqlist);
		   break;
	   case 4:
			{
				Datatype x = 0;
				printf("请输入你要插入的元素:");
				scanf("%d",&x);
				pushfront(&seqlist,x);
			}
		   break;
	   case 5:
		   popfront(&seqlist);
		   break;
	   case 6:
		   {
			   Datatype x = 0;
			   int pos = 0;
			   printf("请输入你要插入的元素:");
			   scanf("%d",&x);
			   printf("请输入你要插入的位置:");
			   scanf("%d",&pos);
			   insert(&seqlist,pos,x);
		   }
		   break;
	   case 7:
		   {
			   int pos = 0;
			   printf("请输入你要擦除插入的位置:");
			   scanf("%d",&pos);
			   erase(&seqlist,pos);
		   }
		   break;
	   case 8:
		   {
			   int ret = 0;
			   Datatype x = 0;
			   printf("请输入你要查找的元素:");
			   scanf("%d",&x);
			   ret=find(&seqlist,x);
			   if(ret!=-1)
				   printf("你要查找的元素第一次出现的下标为:%d\n",ret);
			   else
				   printf("你要查找的元素不存在\n");
		   }
		   break;
	   case 9:
		   {
			   Datatype x = 0;
			   printf("请输入你要删除的元素:");
			   scanf("%d",&x);
			   remmove(&seqlist,x);
		   }
		   break;
	   case 10:
		   {
			   Datatype x = 0;
			   printf("请输入你要删除的元素:");
			   scanf("%d",&x);
			   remmove_all(&seqlist,x);
		   }
		   break;
	   case 11:
		   empty(&seqlist);
		   break;
	   case 0:
		   exit(0);
		   break;
	   default:
		   printf("参数错误，请重新输入\n");
		   break;
	   }
   }
  
   system("pause");
   return 0;
}

函数实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"

void init_seqlist(pseq seq)
{
   assert(seq);
   memset(seq->arr,0,sizeof(seq->arr));
   seq->size = 0;
}
void print_seqlist(pseq seq)
{
    int i = 0;
	assert(seq && seq->size<=MAX);
	for(i=0; i<seq->size; i++)
	{
		printf("%d->",seq->arr[i]);
	}
	printf("end\n");
}
void pushback(pseq seq,Datatype x)
{
	assert(seq && seq->size<MAX);
	if(seq->size>=MAX)
		printf("顺序表已满\n");
	else
	{
	    seq->arr[seq->size++] = x;
	    printf("插入成功\n");
	}
}
void popback(pseq seq)
{
	assert(seq && seq->size<=MAX);
	if(seq->size==0)
		printf("顺序表已空\n");
	else
	{
		//方法1：
	    seq->size--;//将最后一个元素删除即可

		方法2:调用擦除函数实现
		//erase(seq,seq->size-1);
	    printf("删除成功\n");
	}
}
void pushfront(pseq seq,Datatype x)
{
	assert(seq && seq->size<MAX);
	if(seq->size >= MAX)
		printf("顺序表已满\n");
	else
	{
	 //   //方法1(如果顺序表的元素与顺序无关)
		//seq->arr[seq->size]=seq->arr[0];//将首元素保存到最后位置
		//seq->arr[0]=x;
		//seq->size++;

		方法2:调用插入函数
		//insert(seq,0,x);

		方法3:
		//int i = 0;
		//for(i=seq->size; i>0; i--)//移动元素
		//{ 
		//	seq->arr[i] = seq->arr[i-1];
		//}
		//seq->arr[0] = x;//插入元素
		//seq->size++;

		//方法4:
		int i = 0;
		for(i=seq->size-1; i>=0; i--)//移动元素
		{ 
			seq->arr[i+1] = seq->arr[i];
		}
		seq->arr[0] = x;//插入元素
		seq->size++;
	}   
	printf("插入成功\n");
}
void popfront(pseq seq)
{
	assert(seq && seq->size<MAX);
	if(seq->size == 0)
		printf("顺序表已空\n");
	else
	{
		//   //方法1(如果顺序表的元素与顺序无关)
		//seq->arr[0]=seq->arr[seq->size-1];//将首元素保存到最后
		//seq->size--;

		方法2：直接调用擦除函数
		//erase(seq,0);

		方法3:
		//int i = 0;
		//for(i=0; i<seq->size-1; i++)//移动元素
		//{ 
		//	seq->arr[i] = seq->arr[i+1];
		//}
		//seq->size--;

		//方法4:
		int i = 0;
		for(i = 1; i<seq->size; i++)//移动元素
		{ 
			seq->arr[i-1] = seq->arr[i];
		}
		seq->size--;
	}   
	printf("删除成功\n");
}
void insert(pseq seq,int pos,Datatype x)
{
	assert(seq && seq->size<MAX);
	if(seq->size>=MAX)
		printf("顺序表已满\n");
	else
	{
		方法1:
	 //   int i = 0;
		//for(i=seq->size; i>pos; i--)
		//{
		//	seq->arr[i] = seq->arr[i-1];
		//}
		//seq->arr[pos] = x;
		//seq->size++;

		//方法2:
	    int i = 0;
		for(i=seq->size-1; i>=pos; i--)
		{
			seq->arr[i+1] = seq->arr[i];
		}
		seq->arr[pos] = x;
		seq->size++;
	}
	printf("插入成功\n");
}
void erase(pseq seq,int pos)
{
	assert(seq && seq->size<=MAX);
	if(seq->size==0)
		printf("顺序表已空\n");
	else
	{
	    int i = 0;
		for(i=pos; i<seq->size-1; i++)
		{
			seq->arr[i] = seq->arr[i+1];
		}
		seq->size--;
		printf("擦除成功\n");
	}
}
int find(pseq seq,Datatype x)
{
	int i = 0;
	assert(seq && seq->size<=MAX);
	for(i=0; i<seq->size; i++)
	{
		if(seq->arr[i] == x)
			return i;//返回首次出现位置的下标
	}
	return -1;
}
void remmove(pseq seq,Datatype x)
{
	assert(seq && seq->size<=MAX);
	if(seq->size==0)
		printf("顺序表已空\n");
	else
	{
		int i = 0;
	    for(i=0; i<seq->size; i++)
		{
			if(seq->arr[i]==x)
			{
				int j = 0;
				for(j=i; j<seq->size; j++)//移动元素
				{
					seq->arr[j]=seq->arr[j+1];
				}
			}
		}
		seq->size--;
		printf("删除成功\n");
	}

}
void remmove_all(pseq seq,Datatype x)
{
	assert(seq && seq->size<=MAX);
	if(seq->size==0)
		printf("顺序表已空\n");
	else
	{
	 //   //方法1:找一个删一个
		//int i = 0;
		//int count = 0;
		//for(i=0; i<seq->size; ++i)
		//{
		//	if(seq->arr[i] == x)
		//	{
		//		int j = 0;
		//		for(j=i; j<seq->size; j++)//移动元素
		//		{
		//			seq->arr[j]=seq->arr[j+1];
		//		}
		//		seq->size--;
		//	}
		//}

		//方法2：
		int i = 0;
		int count = 0;
		assert(seq && seq->size<MAX);
		for(i=0; i<seq->size; i++)
		{
			seq->arr[i-count]=seq->arr[i];
			if(seq->arr[i] == x)
				count++;
		}
		seq->size-=count;
	}
		printf("删除成功\n");
}
void empty(pseq seq)
{
	assert(seq && seq->size<MAX);
	seq->size=0;
	printf("清空成功\n");
}