C语言：静态顺序表的实现和相关操作

最新推荐文章于 2023-09-21 19:57:03 发布
最新推荐文章于 2023-09-21 19:57:03 发布
阅读量704 收藏
点赞数
分类专栏： C语言 文章标签： C语言 顺序表 静态 排序 二分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TwinkleCapricorns/article/details/53452749
版权

静态顺序表：一段地址连续的存储单元依次存储数据元素的线性结构


头文件 SeqList.h

#pragma once

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

#define MAX_SIZE 100

typedef int DataType;

typedef struct SeqList
{
	DataType array[MAX_SIZE];   //存储数据的数组
	size_t size;				//有效数据的个数
}SeqList;

typedef struct SeqList SeqLsit;

//初始化、删除  
void InitSeqList(SeqList *seq);
void DestorySeqList(SeqList* seq);
//尾部插入、删除   头部插入、删除  
void PushBack(SeqList* seq, DataType x);
void PopBack(SeqList* seq);
void PushFront(SeqList* seq, DataType x);
void PopFront(SeqList* seq);
//打印顺序表  
void PrintSeqList(SeqList* seq);
//插入、找到、删除指定位置、删除一个2、删除许多2  
void Insert(SeqList* seq, size_t pos, DataType x);
void Find(SeqList* seq, DataType x);
void Erase(SeqList* seq, size_t pos);
void Remove(SeqList* seq, DataType x);
void RemoveAll(SeqList* seq, DataType x);
//交换两个数  
void Swap(int* x, int* y);
//冒泡、选择、插入排序        二分查找  
void BubbleSort(SeqList* seq);
void SelectSort(SeqList* seq);
void InsertSort(SeqList* seq);

int BinarySearch_One(SeqList* seq, DataType x);
int BinarySearch_Two(SeqList* seq, DataType x);
int BinarySearch_R(SeqList* seq, DataType x);







































#define _CRT_SECURE_NO_WARNINGS 1  

#include "SeqList.h"  

//在顺序表pos位置插入元素  
void Insert(SeqList* seq, size_t pos, DataType x)
{
	assert(seq);
	if (pos >= MAX_SIZE&&pos > seq->size)
	{
		printf("输入的位置不合法");
		return;
	}
	if (seq->size >= MAX_SIZE)
	{
		printf("该顺序为满");
	}
	else
	{
		for (int i = seq->size; i > pos-1; i--)
		{
			seq->array[i] = seq->array[i - 1];
		}
		seq->array[pos - 1] = x;
	}
	seq->size++;
}
//在顺序表中查找某个元素  
void Find(SeqList* seq, DataType x)
{
	assert(seq);
	for (int i = seq->size - 1; i >= 0; i--)
	{
		if (seq->array[i] == x)
		{
			printf("找到这个元素\n");
			return;
		}
	}
	printf("没有找到这个元素");
}
//删除顺序表pos位置上的元素  
void Erase(SeqList* seq, size_t pos)
{
	assert(seq);
	assert(pos < seq->size);

	for (int i = pos - 1; i < seq->size; i++)
	{
		seq->array[i] = seq->array[i + 1];
	}

	seq->size--;

}
//在顺序表中删除x元素  
void Remove(SeqList* seq, DataType x)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("顺序表为空");
	}
	for (int i = seq->size - 1; i >= 0; i--)
	{
		if (seq->array[i] == x)
		{
			Erase(seq, i+1);
		}
	}
	printf("没有找到这个元素");
}
//在顺序表中删除所有为x的元素  
void RemoveAll(SeqList* seq, DataType x)
{
	assert(seq);
	
		size_t i = 0, j = 0;
		size_t count = 0;
		while (i < seq->size)
		{
			if (seq->array[i] == x)
			{
				++i;
				count++;
			}
			else
			{
				seq->array[j] = seq->array[i];
				++i;
				++j;
			}
		}
	
		seq->size -= count;
}
//冒泡排序  
void BubbleSort(SeqList* seq)
{
	int tmp = 0;
	int count = 0;
	for (int i = 0; i < seq->size-1; i++)
	{
		int Flag = 0;
		count++;
		for (int j = 0; j < seq->size - count-1; j++)
		{
			if (seq->array[j]>seq->array[j + 1])
			{
				Swap(&seq->array[j], &seq->array[j + 1]);
				Flag = 1;
			}
			else
			{
			}
		}
		if (Flag == 0)
		{
			return;
		}
	}
}
//选择排序  
void SelectSort(SeqList* seq)
{
	assert(seq);

	// []
	size_t begin = 0, end = seq->size-1;
	size_t minIndex, maxIndex;
	while (begin < end)
	{
		minIndex = maxIndex = begin;
		for (size_t i = begin; i <= end; ++i)
		{
			if (seq->array[i] > seq->array[maxIndex])
			{
				maxIndex = i;
			}

			if (seq->array[i] < seq->array[minIndex])
			{
				minIndex = i;
			}
		}

		Swap(&(seq->array[begin]), &(seq->array[minIndex]));
		if (maxIndex == begin)
			maxIndex = minIndex;

		Swap(&(seq->array[end]), &(seq->array[maxIndex]));
		++begin;
		--end;
	}
}
//插入排序
void InsertSort(SeqList* seq)
{
	assert(seq);
	for (int i = 0; i < seq->size - 1; i++)
	{
		int end = i;
		int tmp = seq->array[end + 1];
		while (end >= 0 && seq->array[end] > tmp)
		{
			seq->array[end + 1] = seq->array[end];
			end--;
		}
		seq->array[end + 1] = tmp;
	}
}
//二分查找  
int BinarySearch_One(SeqList* seq, DataType x)
{
	assert(seq);

	int begin = 0;
	int end = seq->size-1;
	while (begin <= end)
	{
		//int mid = (begin+end)>>1;
		int mid = begin+(end-begin)>>1;
		if (seq->array[mid] < x)
		{
			begin = mid+1;
		}
		else if (seq->array[mid] > x)
		{
			end = mid-1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}
//二分查找
int BinarySearch_Two(SeqList* seq, DataType x)
{
		assert(seq);
		int begin = 0;
		int end = seq->size;
		while (begin < end)
		{
			//int mid = (begin+end)>>1;
			int mid = begin+((end-begin)>>1);
			if (seq->array[mid] < x)
			{
				begin = mid+1;
			}
			else if (seq->array[mid] > x)
			{
				end = mid;
			}
			else
			{
				return mid;
			}
		}
		return -1;
}
//二分查找递归方法
int BinarySearch_R(SeqList* seq, DataType x, int begin, int end)
{
	assert(seq);
	if (begin > end)
		return -1;

	int mid = begin + ((end-begin)>>1);
	if (seq->array[mid] < x)
		return BinarySearch_R(seq, x, mid+1, end);
	else if (seq->array[mid] > x)
		return BinarySearch_R(seq, x, begin, mid-1);
	else
		return mid;
}
	
//两个数的交换
void Swap(int* x, int* y)
{
	int tmp = 0;
	tmp = *x;
	*x = *y;
	*y = tmp;
}
//打印顺序表  
void PrintSeqList(SeqList* seq)
{
	assert(seq);
	for (size_t i = 0; i < seq->size; ++i)
	{
		printf("%d ", seq->array[i]);
	}
	printf("\n");

}
//初始化顺序表  
void InitSeqList(SeqList *seq)
{
	memset(seq->array, 0, MAX_SIZE*sizeof(DataType));
	seq->size = 0;
}
//在顺序表的尾部插入元素  
void PushBack(SeqList* seq, DataType x)
{
	assert(seq);
	if (seq->size > MAX_SIZE)
	{
		printf("该顺序表已满");
		return;
	}

	seq->array[seq->size] = x;
	seq->size++;
}
//在顺序表的尾部删除元素  
void PopBack(SeqList* seq)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("该顺序表为空");
		return;
	}
	seq->size--;
}
//在顺序表头部插入元素  
void PushFront(SeqList* seq, DataType x)
{
	assert(seq);
	if (seq->size > MAX_SIZE)
	{
		printf("该顺序表已满");
		return;
	}
	else
	{
		for (int i = seq->size - 1; i >= 0; i--)
		{
			seq->array[i + 1] = seq->array[i];
		}
		seq->array[0] = x;
	}
	seq->size++;
}
//在顺序表的头部删除元素  
void PopFront(SeqList* seq)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("该顺序表为空");
		return;
	}

	else
	{
		for (int i = 0; i <= seq->size - 1; i++)
		{
			seq->array[i] = seq->array[i + 1];
		}
	}
	seq->size--;
}












#define _CRT_SECURE_NO_WARNINGS 1  

#include "SeqList.h"  

void Test4()
{
	SeqList data;

	InitSeqList(&data);

	PushBack(&data, 11);
	PushBack(&data, 22);
	PushBack(&data, 33);
	PushBack(&data, 44);
	PushBack(&data, 55);
	PushBack(&data, 66);
	PushBack(&data, 77);
	PushBack(&data, 88);
	PushBack(&data, 99);

	printf("%d \n", BinarySearch(&data, 1));

}

void Test3()
{
	SeqList data;

	InitSeqList(&data);

	PushBack(&data, 11);
	PushBack(&data, 77);
	PushBack(&data, 22);
	PushBack(&data, 33);
	PushBack(&data, 44);
	PushBack(&data, 66);
	PushBack(&data, 99);
	PushBack(&data, 55);
	PushBack(&data, 88);

	//PushBack(&data, 10);
	//PushBack(&data, 9);
	//PushBack(&data, 8);
	//PushBack(&data, 7);
	//PushBack(&data, 6);
	//PushBack(&data, 5);
	//PushBack(&data, 4);
	//PushBack(&data, 3);
	//PushBack(&data, 2);
	//PushBack(&data, 1);

	PrintSeqList(&data);

	//SelectSort(&data);  

	//BubbleSort(&data);  

	InsertSort(&data);  

	//printf("%d \n", BinarySearch(&data, 66));

	PrintSeqList(&data);  
}

void Test2()
{
	SeqList data;

	InitSeqList(&data);

	PushBack(&data, 1);
	PushBack(&data, 2);
	PushBack(&data, 3);
	PushBack(&data, 2);
	PushBack(&data, 5);
	PushBack(&data, 7);
	PushBack(&data, 9);
	PushBack(&data, 2);
	PushBack(&data, 10);

	printf("before-> ");
	PrintSeqList(&data);

	RemoveAll(&data, 2);

	printf("after-> ");
	PrintSeqList(&data);

}

void Test1()
{
	SeqList data;

	InitSeqList(&data);

	PushBack(&data, 1);
	PushBack(&data, 2);
	PushBack(&data, 3);
	PushBack(&data, 2);
	PushBack(&data, 5);
	PushBack(&data, 7);
	PushBack(&data, 9);
	PushBack(&data, 2);
	PushBack(&data, 10);
	//Insert(&data, 2, 2);  

	Find(&data, 2);  

	//Erase(&data, 2);  

	//Remove(&data,2);  

	PrintSeqList(&data);
}

void Test()
{
	SeqList data;

	InitSeqList(&data);

	PushBack(&data, 3);
	PushBack(&data, 4);
	PushBack(&data, 5);

	PushFront(&data, 2);
	PushFront(&data, 1);
	PushFront(&data, 0);

	PrintSeqList(&data);
}

int main()
{

	//  Test();  
	//  Test1();  
	 /* Test2();  */
	  Test3();  
	//Test4();

	system("pause");
	return 0;
}










                

        

        

    

  


    

      

        

            

              
                
                  TwinkleCapricorns
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
顺序表的定义及其实现

				
			

			

				

					fallingskies
				

				

					03-04
					
					817
					
				

			

		

		

			
				
#include<stdio.h>
#define MaxSize 10      //定义最大长度

typedef struct{
	int data[MaxSize];  //使用数组存放数据元素
	int length;         //当前长度
}SeqList;

//基本操作--初始化
void InitList(SeqList &L){
	for(int i...

			
		

	



                

              
                



	

		

			

				
					
静态分配内存的顺序表的定义及基本操作（C语言版） 超详细！！

				
			

			

				

					qq_42890853的博客
				

				

					06-16
					
					587
					
				

			

		

		

			
				
#include<stdio.h>
#define maxsize 100

struct sqlist
{//采用固定长度的静态顺序表
    int length;
    int data[maxsize];
};


//struct sqlist list;
////这样就定义好了一个顺序表,名字为list
//struct sqlist *plist;
////这样就定义好了一个可以指向顺序表的指针,名字为plist


//顺序表的初始化
void initialize_list(

			
		

	



                


  
              

                


	

		

			

				
					
静态顺序表的实现及相关操作源代码（插入，删除，排序，逆置，超详细）

				
			

			

				

					Wmll1234567的博客
				

				

					01-23
					
					464
					
				

			

		

		

			
				
导读：今晚先上传所有的源代码，日后进行详细解读


//2018/1/14  22:11
//顺序表(借用一个一维数组来表示,静态顺序表) 
#include
#define Maxsize 100
typedef struct
{
	int data[Maxsize];
	int  length;
}Seqlist;

Seqlist * creat(Seqlist * L);      

			
		

	





	

		

			

				
					
静态数据成员和静态成员函数

				
			

			

				

					Qiana_wq的博客
				

				

					08-26
					
					3万+
					
				

			

		

		

			
				
转载自：https://blog.csdn.net/computer_liuyun/article/details/29235111

c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西，好像也是找工作公司面试中常常问到的东西。我自己也深有体会，在学习c++的过程中，总感觉static很烦人，但是又是一个必须懂的东西，所以今天就对静态数据成员和静态成员函数坐下小结哈！

一...

			
		

	



		

			
		



	

		

			

				
					
写一个工具类，类中定义静态方法，实现数组的升序排序（选择和冒泡分别写一个类）

				
			

			

				

					Ww1554487900的博客
				

				

					07-24
					
					2749
					
				

			

		

		

			
				
Java学习到了静态方法，第一次发文章，望大家多多指点  (*^_^*)

要解答此题，首先，我们要了解到题目里所要用到的知识内容

1、静态方法：


先于对象的方法，不依赖与对象，可以通过类名直接调用。

public class Person{
      public static void fun(){
        System.out.println("fun");
      }...

			
		

	





	

		

			

				
					
数据结构C语言——静态顺序表的实现

				
			

			

				

					m0_59086544的博客
				

				

					06-17
					
					504
					
				

			

		

		

			
				
本文章主要是介绍关于数据结构中用C语言来实现顺序表的一些基本操作。

			
		

	





	

		

			

				
					
使用C语言实现静态顺序表

				
			

			

				

					Keep_Trying_Go的博客
				

				

					08-06
					
					673
					
				

			

		

		

			
				
使用C语言实现静态顺序表

			
		

	





	

		

			

				
					
C语言：顺序表的实现

				
			

			

				

					aiyubaobei的博客
				

				

					11-06
					
					829
					
				

			

		

		

			
				
标题C语言实现顺序表
线性表的定义
线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串
线性表在逻辑上是线性结构，也就是说是一条直线。但在物理结构上线性表并不一定是连续的空间，线性表在物理上存储时，通常释疑数组和链式结构的形式存储。


顺序表的定义
顺序表时用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。可分为静态顺序表和动态顺序表
1、静态顺序表：使用定长数组存储元

			
		

	





	

		

			

				
					
顺序表的C语言实现(静态/动态)

				
			

			

				

					Paradox_33的博客
				

				

					09-21
					
					159
					
				

			

		

		

			
				
顺序表的C语言实现(静态/动态)

			
		

	





	

		

			

				
					
C语言实现静态顺序表

				
			

			

				

					R_T_P_A_D的博客
				

				

					11-17
					
					293
					
				

			

		

		

			
				
实现顺序表分为以下几步：

1.先写出封装顺序表结构的结构体；

2.初始化顺序表；

3.增删查改；

4.顺序表的逆置等。


#define MAX_SIZE 100
typedef int DataType;

typedef struct SeqList
{
	DataType data[MAX_SIZE];
	DataType length;
}SeqList;
//顺序表的初始化就是...

			
		

	





	

		

			

				
					
C语言实现动态顺序表的实现代码

				
			

			

				

					12-31
				

			

		

		

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

			
		

	





	

		

			

				
					
C语言：顺序栈的实现代码

					
最新发布

				
			

			

				

					04-11
				

			

		

		

			
				
以下是根据给定文件中实现代码总结的C语言顺序栈的相关知识点：  1. 栈的定义与数据结构：栈是一种特殊的线性表，只能在表的一端进行插入和删除操作。在本代码中，栈是由结构体SqStack定义的，其中包含一个数组data...

			
		

	





	

		

			

				
					
C语言：从键盘输入一个数n，求n的阶乘（n!）

					
热门推荐

				
			

			

				

					TwinkleCapricorns的博客
				

				

					10-16
					
					6万+
					
				

			

		

		

			
				
使用while循环控制语句求n!；
#include
#include

int main()
{
	int i = 2, n;
	float fac = 1;
	printf("请输入一个大于0的整数：>");
	scanf("%d", &n);
	if (n == 0 || n == 1)                   //判断输入的整数为1或0直接输出改阶乘为1；
	{
		prin

			
		

	





	

		

			

				
					
C语言：统计各种字符的个数

				
			

			

				

					TwinkleCapricorns的博客
				

				

					10-21
					
					6万+
					
				

			

		

		

			
				
要求输入一组字符，然后分别统计出其中英文字母、数字、空格以及其他字符的个数。#include
#include

int main()
{
	char c;
	int letters = 0;
	int space = 0;
	int digit = 0;
	int others = 0;
	printf("please input a string:>");
	while ((c = getch

			
		

	





	

		

			

				
					
C语言：三个数由小到大排序

				
			

			

				

					TwinkleCapricorns的博客
				

				

					09-26
					
					2万+
					
				

			

		

		

			
				
任意输入3个整数，编程实现对3个整数进行由小到大排序，并将排序后的结果显示在屏幕上。#include
#include

int main()
{
	int a, b, c, t;                      //定义4个基本整型变量a,b,c,t;
	printf("Please input a,b,c:");
	scanf("%d%d%d", &a, &b, &c);
	//如果

			
		

	





	

		

			

				
					
C语言：判断三角形的类型

				
			

			

				

					TwinkleCapricorns的博客
				

				

					09-26
					
					2万+
					
				

			

		

		

			
				
根据输入的三角形的三边判断三角形的类型，并输出其面积和类型。
#include
#include
#include
int main()
{
	float a, b, c;
	float s, area;
	printf("please input three line:\n");
	scanf("%f%f%f", &a, &b, &c);
	//判断是否满足三角形条件：两边之和是否大于第三边；

			
		

	





	

		

			

				
					
C语言：打印二元一次方程的根

				
			

			

				

					TwinkleCapricorns的博客
				

				

					10-14
					
					3350
					
				

			

		

		

			
				
打印二元一次方程的根。通过对a和判别式的比较，输出二元一次方程的根。

#include
#include
#include

#define EXP 0.000000001    //宏定义EXP；

//判断：一个浮点数与0判断时候需要判断它们是否介于EXP与-EXP之间就行；

int main()
{
	double a = 0.0, b = 0.0, c = 0.0;
	double

			
		

	





	

		

			

				
					
C语言：重写strcpy函数,拷贝字符串的内容

				
			

			

				

					TwinkleCapricorns的博客
				

				

					10-30
					
					3003
					
				

			

		

		

			
				
strcpy函数是用来拷贝字符串的函数，str1[]中的字符拷贝到str2[]中。
重写strcpy就是再不调用头文件#include的strcpy函数，

			
		

	





	

		

			

				
					
C语言详解：静态顺序表实现与操作实例

				
			

			

				

					
				

			

		

		

			
				
本文档详细介绍了如何在C语言中实现静态顺序表的实例。静态顺序表，也称为固定大小顺序表，是一种线性数据结构，它在内存中预先分配一段连续的空间来存储数据元素，且其大小在编译时就已经确定。这里的关键知识点...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值