C语言_顺序表操作

最新推荐文章于 2023-10-06 17:51:33 发布
最新推荐文章于 2023-10-06 17:51:33 发布
阅读量383 收藏 3
点赞数
分类专栏： c语言 C语言_数据结构 C语言_学习篇 数据结构_学习篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A__B__C__/article/details/80735428
版权

####本片博客主要包含顺序表以下几个操作：

1、 初始化顺序表
2、 尾部插入
3、 尾部删除
4、头部插入
5、头部删除
6、 指定位置插入
7、 指定位置删除
8、 删除指定元素（第一次出现的那一个）
9、 删除所有指定元素 （三种方法）
10、查找指定元素 ，返回其下标，没有那个元素就返回 -1
11、返回顺序表大小
12、判断顺序表是否为空
13、冒泡排序
14、选择排序
15、选择排序的优化
16、二分查找（非递归写法）
17、二分查找 （递归写法）
18、打印顺序表内容

1、头文件 SequList.h

#ifndef __SeqLIst_h__
#define __SeqLIst_h__

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

#define MAX 10 
typedef int DataType;


typedef struct SeqList
{
	DataType data[MAX];
	int sz;
}SeqList;
//显示内容
void show(SeqList *pList);

//初始化
void SeqListInit (SeqList *pList);
//尾部插入 
void SeqListPushBack (SeqList *pList, DataType d);
//尾部删除
void SeqListPopBack (SeqList *pList);

//头部插入 
void SeqListPushFront (SeqList *pList, DataType d);
//头部删除 
void SeqListPopFront (SeqList *pList);
//指定位置插入 
void SeqLIstInsert (SeqList *pList, int pos, DataType d);
//删除指定位置元素 
void SeqLIstErase (SeqList *pList, int pos);
//删除指定元素 
void SeqListRemove(SeqList *pList, DataType d);
//删除所有的指定元素 (方法一)
void SeqListRemoveAll_1(SeqList *pList, DataType d);
//删除所有的指定元素 (方法二)
void SeqListRemoveAll_2(SeqList *pList, DataType d);
//删除所有的指定元素 （方法三）
void SeqListRemoveAll_3(SeqList *pList, DataType d);
//查找指定元素 
int SeqListFind (SeqList *pList, DataType d);
//返回顺序表大小
int SeqListsz (SeqList *pList);
//判断顺序表是否为空 
int Empty(SeqList *pList); 
//冒泡排序 
void BubbleSort (SeqList *pList);
//选择排序
void SelectSort (SeqList *pList);
//选择排序的优化 
void  SelectSort_OP (SeqList *pList);
//二分查找 
int BinarySearch (SeqList *pList, DataType d);
//二分查找递归写法 
int BinarySearch_R(SeqList *pList, int left, int right, DataType d);

#endif

2、主要函数 代码 main.c

#include "SeqList.h"

void show(SeqList *pList)
{
	int i = 0;
	assert (pList != NULL);
	printf ("顺序表内容：\n");
	for (i=0; i<pList->sz; i++)
	{
		printf ("%d ", pList->data[i]);
	}
	printf ("\n");
}

void SeqListInit (SeqList *pList)
{
	assert (pList != NULL);
	memset (pList->data, 0, sizeof (DataType)*MAX);
	pList->sz = 0;
	printf ("初始化成功！！\n");
}

void SeqListPushBack (SeqList *pList, DataType d)
{
	assert (pList != NULL);
	if (pList->sz == MAX)
	{
		printf ("顺序表已满，无法插入！\n");
		return ;
	}
	pList->data[pList->sz] = d;
	pList->sz ++;
	printf ("插入成功\n");
}

void SeqListPopBack (SeqList *pList)
{
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！\n");
		return ;
	}
	pList->sz --;
	printf ("删除成功\n");
	show (pList);
}

void SeqListPushFront (SeqList *pList, DataType d)
{
	int i = 0;
	assert (pList != NULL);
	if (pList->sz == MAX)
	{
		printf ("顺序表已满，无法插入！\n");
		return ;
	}
	for (i=pList->sz; i>0; i--)
	{
		pList->data[i] = pList->data[i-1];
	}
	pList->data[0] = d;
	pList->sz++;
	printf ("插入成功\n");
	show (pList);
	
}

void SeqListPopFront (SeqList *pList)
{
	int i = 0;
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！\n");
		return ;
	}
	for (i=0; i<pList->sz; i++)
	{
		pList->data[i] = pList->data[i+1];
	}
	pList->sz --;
	printf ("删除成功\n");
	show (pList);
}

void SeqLIstInsert (SeqList *pList, int pos, DataType d)
{
	int i = 0;
	assert (pList != NULL && pos>0 && pos<pList->sz);
	if (pList->sz == MAX)
	{
		printf ("顺序表已满，无法插入！\n");
		return ;
	}
	for (i=pList->sz; i>=pos; i--)
	{
		pList->data[i] = pList->data[i-1];
	}
	pList->data[pos-1] = d;
	pList->sz ++;
	printf ("插入成功");
	show (pList);
}

void SeqLIstErase (SeqList *pList, int pos)
{
	int i = 0;
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！\n");
		return ;
	}
	for (i=pos-1; i<pList->sz-1;i++)
	{
		pList->data[i] = pList->data[i+1];
	}
	pList->sz --;
	printf ("删除成功\n");
	show(pList);
}

void SeqListRemove(SeqList *pList, DataType data)//删除指定元素
{
	int i = 0;
	assert (pList != NULL);
	if (pList ->sz == 0)
	{
		printf ("顺序表为空，无法删除！！！\n");
		return;
	}
	for (i=0; i<pList->sz; i++)
	{
		if (pList ->data [i] == data)
		{
			for (; i<pList->sz -1; i++)
			{
				pList->data[i] = pList->data[i+1];
			}
			pList->sz --;
			printf ("删除指定元素成功！！！\n");
			return;
		}
	}
	printf ("没有该元素，无法删除！！！\n");
}

void SeqListRemoveAll_1(SeqList *pList, DataType data)//删除所有指定元素（方法一）
{
	int i = 0, j = 0;
	int tmp = pList->sz ;
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！！！\n");
		return;
	}
	for (i=0; i<pList->sz; i++)
	{
		if(pList->data[i] == data)
		{
			for (j=i; j<pList->sz-1; j++)
			{
				pList->data[j] = pList->data[j+1];
			}
			pList->sz --;
			i--;
		}
	}
	if (tmp == pList->sz)
	{
		printf ("没有该元素，无法删除！！！\n");
	}
	else
	{
		printf ("所有指定元素(方法一)删除成功！！！\n");
	}
	show (pList);
}

void SeqListRemoveAll_2(SeqList *pList, DataType data)//删除所有指定元素（方法二）
{
	int i = 0, j = 0;
	DataType p[MAX] = {0};
	if (p == NULL)
	{
		perror ("malloc:");
		return;
	}
	
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！！!\n");
		return;
	}
	for (i=0; i<pList->sz; i++)
	{
		if (pList->data[i] != data)
		{
			p[j] = pList->data [i];
			j++;
			
		}
	}
	memcpy (pList->data,p, sizeof(p));
	pList->sz = j;
	printf("删除指定元素（方法二）成功！！！\n");
	show(pList);
}

void SeqListRemoveAll_3(SeqList *pList, DataType d)
{
	int i = 0, j = 0;
	assert (pList != NULL);
	if (pList->sz == 0)
	{
		printf ("顺序表为空，无法删除！\n");
		return ;
	}
	for (i=0; i<pList->sz; i++)
	{
		if (pList->data[i] != d)
		{
			pList->data[j] = pList->data[i];
			j++;
		}
	}
	pList->sz = j;
	printf ("删除成功\n");
	show (pList);
}

int SeqListFind (SeqList *pList, DataType d)//找到返回下标，找不到返回-1
{
	int i = 0, j = 0;
	assert (pList != NULL);
	for (i=0; i<pList->sz; i++)
	{
		if (pList->data[i] == d)
		{
			printf ("找到了，");
			return i;
		}
	}
	printf("找不到\n");
	return -1;
}

int SeqListsz (SeqList *pList)
{
	return pList->sz;
}

int Empty(SeqList *pList)//为空返回1，不为空返回0
{
	return (pList->sz == 0);//如果pList->sz == 0 ，顺序表为空 返回1 如果pList->sz ！= 0 顺序表不为空，返回零
}


void swap (int *p, int *q)
{
	int tmp = *p;
	*p = *q;
	*q = tmp;
}

void BubbleSort (SeqList *pList)
{
	int i = 0, j = 0;
	int state = 0;
	assert (pList != NULL);
	for (i=0; i<pList->sz-1; i++)
	{
		state = 0;
		for (j=0; j<pList->sz-1-i; j++)
		{
			if (pList->data[j] > pList->data[j+1])
			{
				swap (pList->data+j, pList->data+j+1);
				state = 1;
			}
		}
		if (state == 0)
		{
			break;
		}
	}
	printf ("冒泡排序成功\n");
	show (pList);
}

void SelectSort (SeqList *pList)
{
	int i = 0, j = 0;
	int maxPos = 0;
	assert (pList != NULL);
	for (i=0; i<pList->sz-1; i++)
	{
		maxPos = 0;
		for (j=1; j<=pList->sz-1-i; j++)
		{
			if (pList->data[j] > pList->data[maxPos])
			{
				maxPos = j;
			}
		}
		swap (pList->data+pList->sz-1-i, pList->data+maxPos);
	}
	printf ("选择排序成功\n");
	show (pList);
}

void  SelectSort_OP (SeqList *pList)
{
	int left = 0, right = pList->sz-1;
	assert (pList != NULL);
	while (left < right)
	{
		int minPos = left;
		int maxPos = left;
		int i = 0;
		for (i=left+1; i<=right; i++)
		{
			if (pList->data[i] > pList->data[maxPos])
			{
				maxPos = i;
			}
			if (pList->data[i] < pList->data[minPos])
			{
				minPos = i;
			}
		}
		if (maxPos != right)
		{
			swap (pList->data+maxPos, pList->data+right);
		}
		if (minPos == right)
		{
			minPos = maxPos;
		}
		if (minPos != left)
		{
			swap (pList->data+minPos, pList->data+left);
		}
		left ++;
		right --;
	}
	printf ("选择排序成功\n");
	show (pList);
}

int BinarySearch (SeqList *pList, DataType d)//找到返回下标，找不到返回-1
{
	int left = 0, right = pList->sz-1;
	int mid = (left+right)/2;
	assert (pList != NULL);
	while (left < right)
	{
		if (pList->data[mid] > d)
		{
			right = mid - 1;
		}
		if (pList->data[mid] < d)
		{
			left = left + 1;
		}
		if (pList->data[mid] == d)
		{
			printf ("找到了，");
			return mid;
		}
	}
	printf ("找不到该元素！\n");
	return -1;
}

int BinarySearch_R(SeqList *pList, int left, int right, DataType d)
{
	int mid = (right + left)/2;
	assert (pList != NULL);
	if (pList->data [mid] > d)
	{
		return BinarySearch_R (pList, left, mid-1, d);
	}
	else if (pList->data [mid] < d)
	{
		return BinarySearch_R (pList, mid+1, right, d);
	}
	else
	{
		return mid;
	}
	if (left > right)
	{
		return -1;
	}
}

3、测试功能代码 test.c

#include "SeqList.h"

void test_SeqListPushBack ()
{
	SeqList pList;
	printf ("测试尾插:\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	printf ("\n");
}

void test_SeqListPopBack ()
{
	SeqList pList;
	printf ("测试尾删\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqListPopBack (&pList);
	printf ("\n");

}

void test_PushFront()
{
	SeqList pList;
	printf ("测试头插：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqListPushFront(&pList, 10);
	SeqListPushFront(&pList, 11);
	printf ("\n");
}
void teat_SeqListPopFront()
{
	SeqList pList;
	printf ("测试头删:\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqListPopFront(&pList);
	SeqListPopFront(&pList);
	printf ("\n");

}
void teat_SeqLIstInsert ()
{
	SeqList pList;
	printf ("指定位置插入：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqLIstInsert (&pList, 2, 100);
	printf ("\n");
}

void test_SeqLIstErase()
{
	SeqList pList;
	SeqListInit (&pList);
	printf ("指定位置删除\n");
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqLIstErase(&pList, 2);
	printf ("\n");
}
void test_SeqListRemove()
{
	SeqList pList;
	printf ("删除指定元素（第一次出现）：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	SeqListRemove(&pList,3);
	printf ("\n");
}
void test_SeqListRemoveAll()
{
	SeqList pList;
	printf ("删除指定元素（所有）：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 5);
	SeqListPushBack(&pList, 5);
	show(&pList);
	SeqListRemoveAll_1(&pList, 5);
	SeqListRemoveAll_2(&pList, 4);
	SeqListRemoveAll_3(&pList, 3);
	printf ("\n");
}
void test_SeqListFind ()
{
	int ret = 0;
	SeqList pList;
	printf ("查找元素：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	show(&pList);
	ret = SeqListFind (&pList, 3);
	if (ret != -1)
	{
		printf ("下标是：%d\n", ret);
	}
	ret = SeqListFind (&pList, 13);
	if (ret != -1)
	{
		printf ("下标是：%d\n", ret);
	}
	printf ("\n");
}
void test_SeqListsz()
{
	SeqList pList;
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	printf ("顺序表长度是：%d\n", SeqListsz (&pList));
	printf ("\n");
}

void test_Bubblesort ()
{
	SeqList pList;
	printf ("冒泡排序：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 1);
	show(&pList);
	BubbleSort (&pList);
	printf ("\n");
}
void test_SelectSort()
{
	SeqList pList;
	printf ("选择排序：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 5);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 0);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 1);
	show(&pList);
	SelectSort(&pList);
	printf ("\n");
}

void test_SelectSort_OP()
{
	SeqList pList;
	printf ("选择排序优化：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 5);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 0);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 1);
	show(&pList);
	SelectSort_OP(&pList);
	printf ("\n");
}
void test_BinarySearch ()
{
	int ret = 0;
	SeqList pList;
	printf ("二分查找(非递归)：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 5);
	SeqListPushBack(&pList, 6);
	show (&pList);
	ret = BinarySearch (&pList, 3);
	if (ret != -1)
	{
		printf ("下标是：%d\n", ret);
	}
	printf ("\n");
}

void test_BinarySearch_R()
{
	int ret = 0;
	SeqList pList;
	printf ("二分查找（递归）：\n");
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	SeqListPushBack(&pList, 3);
	SeqListPushBack(&pList, 4);
	SeqListPushBack(&pList, 5);
	SeqListPushBack(&pList, 6);
	show (&pList);
	ret = BinarySearch_R (&pList, 0, pList.sz-1, 3);
	if (ret != -1)
	{
		printf ("下标是：%d\n", ret);
	}
	printf ("\n");
}

void test_Empty()
{
	int ret = 0;
	SeqList pList;
	SeqListInit (&pList);
	SeqListPushBack(&pList, 1);
	SeqListPushBack(&pList, 2);
	ret = Empty (&pList);
	if (!ret)
	{
		printf ("顺序表非空\n");
	}
	else 
	{
		printf ("顺序表为空\n");
	}
	SeqListPopFront(&pList);
	SeqListPopFront(&pList);
	ret = Empty (&pList);
	if (!ret)
	{
		printf ("顺序表非空\n");
	}
	else 
	{
		printf ("顺序表为空\n");
	}


}

int main()
{

	test_SeqListPushBack ();
	test_SeqListPopBack ();
	test_PushFront();
	teat_SeqListPopFront();
	teat_SeqLIstInsert ();
	test_SeqLIstErase();
	test_SeqListRemove();
	test_SeqListRemoveAll();
	test_SeqListFind ();
	test_SeqListsz();
	test_Bubblesort ();
	test_SelectSort();
	test_SelectSort_OP();
	test_BinarySearch ();
	test_BinarySearch_R();
	test_Empty();
	system ("pause");
	return 0;
}
A__B__C__
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现顺序表
weixin_43219708的博客
12-30 183
顺序表是用用一段物理地址连续的存储单元一次存储数据元素的线性结构，一般情况下采用数组存储 顺序表分为：静态顺序表（使用地工厂数组存储），动态顺序表（使用动态开辟的数组存储） 下面实现的是动态顺序表： C语言中没有这种结构，所以把它们封装成一个结构体，里面有不同类型的元素（数组、有效元素个数、数组总容量），便于管理 typedef int DataType;//给类型取别名 数组元素类型就很好变...
C语言写顺序表
qq_45975614的博客
12-28 273
1. 顺序表的结构 （1） 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 2. 顺序表的特点 （1）空间连续。 （2）支持随机访问。 （3）尾插尾删操作时间复杂度都是O（1）。 （4）其他位置（除过尾部）插入删除都是0（n）。 （5）空间利用率高，不容易造成内存碎片。 （6）适合访问存储。 （7）增容代价大，增容一般是呈2倍增长，势必会有一定的空间浪费。 （8）增容需要申请新空间，拷贝数据，释放旧空间，会有不小的消耗。 3.顺序表的实现
利用顺序表求集合的并集
06-24
int main(){ list a; list b; list c; int x=100,y=100,i=1,j=1; int k=1; cout<<"请输入A集合中的数，以数字0结束："<>x; if(x==0) break; a.insert(i,x); i++; cout<<x<<" "; } cout<<endl; cout<<"请输入B集合中的数，以数字0结束："<>y; if(y==0) break; b.insert(j,y); j++; cout<<y<<" "; } cout<<endl; i=1;j=1; while(i<a.length()+1&&jy){ j++; } else if(x=y){ c.insert(k,x); i++; j++; k++; } else{ c.insert(k,x); k++; i++; } } k=1; cout<<"A交B={"; while(k<c.length()+1){ c.get_element(k,x); k++; cout<<x; } cout<<"}"<<endl; return 0; }
c语言数据结构与算法实验：顺序表存储学生信息
普通大学的普通学生的一些学习记录博客
03-20 1338
本文作者同为大一新生，写这篇文章的目的是记录自己的学习经历，以及帮助一些稍有困难的同学理解数据结构，能力有限，如有错误请指出。本文基于严蔚敏老师的《数据结构与算法（c语言版 第二版）》创作。（建议学习的时候搭配着书看）学习前提：1.本文需要有一定的顺序表基础，如果对顺序表不太了解，建议对顺序表的结构稍加学习之后再来看。2.你需要明确知道实际参数和形式参数之间的关系如果不知道可以看作者的这篇文。
顺序表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
新建文件夹_C语言_顺序表_
10-02
本文将深入探讨“顺序表”的概念、实现方式以及在C语言中的操作，包括顺序表的建立、删除和插入等步骤。 顺序表是一种线性数据结构，它的特点是元素在内存中按照它们的逻辑顺序进行连续存储。每个元素都有一个固定...
c语言实现顺序表的基本操作
01-20
数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
C语言实现顺序表基本操作汇总
09-04
【C语言实现顺序表基本操作汇总】 顺序表是一种在计算机科学中常见的数据结构，它将一组元素存储在一块连续的内存区域中。这种结构允许快速访问元素，因为可以通过索引来直接定位元素。本文将深入讨论如何使用C语言...
【数据结构】顺序表（C语言）
weixin_44358957的博客
03-06 1633
数据结构，顺序表（C语言，带注释）
顺序表--C语言版（从0开始，超详细解析 ，小白一听就懂！！！）
weixin_45031801的博客
11-17 5823
⭕ 接口7：头删（SLPopFront） ⭕ 接口12：打印函数（SLPrint）以下就是我对数据结构---顺序表的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对数据结构-------单链表的理解，请持续关注我哦！！！！！
【数据结构】第一站：C语言--顺序表（附完整源码和注释）
poplar的博客
04-14 3408
顺序表是数据结构学习所接触的第一个数据存储结构，对顺序表的结构有清楚的了解，将对后面的学习大有帮助。（本文章默认读者c语言有一定了解）还需要注意的是：数据结构的学习，我们亲自画图（理解逻辑的过程）十分重要，如果顺序表不好好画图，相信链表的实现时会让你头疼一阵。
C语言---顺序表（详解）---数据结构
weixin_57535054的博客
02-03 3866
我们直接切入主题 1.首先这次写的顺序表的动态的，因为静态的弊端较多。 2.顺序表的功能函数有：初始化 丶申请动态内存 顺序表的头部，尾部的插入和删除 丶在特定位置的插入和删除 丶打印顺序表 丶释放动态内存 需要用到的头文件 我们先给 类型 重命名 原因是：以后还需要用到顺序表时，插入的不一定是你当前使用的类型，如果要改还需要一个个改，非常麻烦，为了以后方便，我们需要改类型时，直接给 类型重命名 这里改，就可以了，更加节省时间。 创建一个结构体里面包含 1指向动态开辟数组的指针。*a.
【C语言】详解顺序表
最新发布
m0_58303983的博客
10-06 712
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。线性表的插入是指在表的第i个位置上（因为C语言的下标是从0开始的，所以插入位置下标为i-1)插入一个值为x的元素，插入后使原表长增加1，称为表长度为n+1的表。1.将要删除的元素赋值给指针x所指的变量。
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6587
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
顺序表-c语言实现
m0_46343224的博客
11-02 1218
c语言实现的顺序表，通俗易懂，相信你能舒服的看懂，有问题可以私信我。
C语言实现顺序表（数据结构）
芊樱烛渊的博客
04-22 9836
以下是我们需要实现的顺序表的功能。 以下是写在SeqList.h中的内容，我们将全部需要声明的内容放在此处 pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef int SLDateType; typedef struct SeqList { SLDateType* a; size_t size;// 当前存储的数据个数 size_t c
顺序表C语言版
iwkxi的博客
03-18 3493
文章目录1.线性表2.顺序表2.1概念及结构2.2接口实现2.2.1 SeqList.h2.2.2 SeqList.c2.2.2.1 初始化顺序表 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一
C语言实现顺序表操作：创建与显示
在给出的代码示例中，我们看到一个简单的C语言实现，用于创建和输出顺序表。 首先，代码定义了一个结构体`SqList`，它包含了顺序表的基本属性：元素指针`elem`、当前长度`length`和表的大小`listsize`。`LIST_INIT_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值