顺序表模拟实现以及习题整理

最新推荐文章于 2024-05-20 19:58:16 发布
最新推荐文章于 2024-05-20 19:58:16 发布
阅读量150 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45672975/article/details/108243477
版权

顺序表实现:

#include "seqlist.h"
#include <stdlib.h>
#include <string.h>

//初始化
void seqListInit(seqlist* sl) {
	sl->_array = (DataType*)malloc(4 * sizeof(DataType));
	sl->_capacity = 4;
	sl->_size = 0;
}
//尾插
void seqListPushBack(seqlist* sl, DataType value) {
	/*checkCapacity(sl);
	sl->_array[sl->_size++] = value;*/
	seqListInsert(sl, sl->_size, value);
}
//尾删: 删除顺序表中的最后一个元素
void seqListPopBack(seqlist* sl) {
	//不需要释放空间
	/*if (sl->_size>0) {
		--sl->_size;
		}*/
	seqListErase(sl,sl->_size-1);
}
//头插
void seqListPushFront(seqlist* sl, DataType value) {
	//checkCapacity(sl);
	元素移动需要从后向前移动
	int end = sl->_size;
	//size_t end = sl->_size;
	//while (end > 0) {
	//	sl->_array[end] = sl->_array[end-1];
	//	--end;
	//}
	//sl->_array[0] = value;
	//++sl->_size;
	seqListInsert(sl,0,value);
}
//头删
void seqListPopFront(seqlist* sl) {
	注意元素覆盖的问题
	移动:从前向后移动
	//if (sl->_size) {
	//	size_t start = 1;
	//	//1->sl->_size-1 ---> 0~sl->-size-2
	//	while (start<sl->_size) {
	//		sl->_array[start - 1] = sl->_array[start];
	//		++start;
	//	}
	//	--sl->_size;
	//}
	seqListErase(sl, 0);
}

//在pos位置的前面插入一个数据value
void seqListInsert(seqlist* sl, size_t pos, DataType value) {

	//插入的位置必须合法
	if (pos <= sl->_size) {
		//检查容量是否够
		checkCapacity(sl);
		//移动元素
		size_t end = sl->_size;
		while (end > pos) {
			sl->_array[end] = sl->_array[end-1];
			--end;
		}
		sl->_array[pos] = value;
		++sl->_size;
	}
}
//删除pos位置的元素
void seqListErase(seqlist* sl, size_t pos) {
	if (pos<sl->_size) {
	//删除元素: 从前向后移动
	//移动的位置: pos+1~size-1 --->pos~size-2
		size_t start = pos+1;
		while ( start< sl->_size) {
			sl->_array[start-1] = sl->_array[start];
			++start;
		}
		--sl->_size;
	}
}
//查找
int seqlistFind(seqlist* sl, DataType value) {
	for (int i = 0; i < sl->_size;i++) {
		if (sl->_array[i] == value) {
			return i;
		}
		else {
			return -1;
		}
	}
}

void seqlistPrint(seqlist* sl) {
	for (int i = 0; i < sl->_size; i++) {
		printf("%d ", sl->_array[i]);
	}
	printf("\n");
}
void checkCapacity(seqlist* sl) {
	//增容 1.开更大空间 2.拷贝原有的内容 3.释放原有的空间
	//malloc 申请失败  返回NULL
	if (sl->_size == sl->_capacity) {
		sl->_capacity *= 2;
		1.开更大的空间
		//DataType* newArray = (DataType*)malloc(sl->_capacity*sizeof(DataType));
		2.拷贝原来的内容
		//memcpy(newArray,sl->_array,sl->_size*sizeof (DataType));
		3.释放原来的空间
		//free(sl->_array);
		//sl->_array = newArray;
		sl->_array = (DataType*)realloc(sl->_array, sizeof(DataType)*sl->_capacity);
	}
}

```c
#include <stdio.h>
#pragma once 

//动态顺序表
//typedef int DataType;
#define DataType int 
typedef struct seqlist{
	DataType* _array;
	//元素个数
	DataType _size;
	//容量: 当前可用的空间
	DataType _capacity;
}seqlist;
//顺序表初始化
void seqListInit(seqlist* sl);
//尾插
void seqListPushBack(seqlist* sl,DataType value);
//尾删
void seqListPopBack(seqlist* sl);
//头插
void seqListPushFront(seqlist* sl, DataType value);
//头删
void seqListPopFront(seqlist* sl);
//在pos位置的前面插入一个数据value
void seqListInsert(seqlist* sl,size_t pos,DataType value);
//删除pos位置的元素
void seqListErase(seqlist* sl, size_t pos);
//查找
int seqlistFind(seqlist* sl, DataType value);
//
void seqlistPrint(seqlist* sl);
//增容
void checkCapacity(seqlist* sl);
测试文件
#include "seqlist.h"
#include <stdio.h>
#include <stdlib.h>

//void test1() {
//	seqlist sl;
//	seqListInit(&sl);
//	seqListPushBack(&sl, 1);
//	seqListPushBack(&sl, 2);
//	seqListPushBack(&sl, 3);
//	seqlistPrint(&sl);
//	seqListPopBack(&sl);
//	seqlistPrint(&sl);
//	seqListPopBack(&sl);
//	seqlistPrint(&sl);
//	seqListPopBack(&sl);
//	seqlistPrint(&sl);
//}
void test2() {

	seqlist sl;
	seqListInit(&sl);
	seqListPushBack(&sl, 1);
	seqListPushBack(&sl, 2);
	seqListPushBack(&sl, 3);
	for (int i = 0; i < 10000;i++) {
		seqListPushFront(&sl,i);
	}
	seqlistPrint(&sl);

}
void test3() {
	seqlist sl;
	seqListInit(&sl);
	seqListPushBack(&sl, 1);
	seqListPushBack(&sl, 2);
	seqListPushBack(&sl, 3);
	seqlistPrint(&sl);

	seqListPopFront(&sl);
	seqlistPrint(&sl);
	seqListPopFront(&sl);
	seqlistPrint(&sl);
	seqListPopFront(&sl);
	seqlistPrint(&sl);

}

void test4() {
	seqlist sl;
	seqListInit(&sl);
	seqListPushBack(&sl, 3);
	seqListPushFront(&sl, 2);
	seqListPushFront(&sl, 1);
	seqlistPrint(&sl);
	seqListPushBack(&sl, 4);
	seqlistPrint(&sl);
	seqListPushBack(&sl, 5);
	seqlistPrint(&sl);
	seqListPushBack(&sl, 7);
	seqlistPrint(&sl);
	seqListPushBack(&sl, 9);
	seqlistPrint(&sl);
	seqListPushBack(&sl, 10);
	seqlistPrint(&sl);
	seqListInsert(&sl, 6, 8); //对应的是下标  下标前面的插入
	seqlistPrint(&sl);
	seqListInsert(&sl, 5, 6);
	seqlistPrint(&sl);
}
void test5() {
	seqlist sl;
	seqListInit(&sl);
	seqListPushBack(&sl, 3);
	seqListPushFront(&sl, 2);
	seqListPushFront(&sl, 1);
	seqListPushBack(&sl, 4);
	seqListPushBack(&sl, 5);
	seqlistPrint(&sl);

	seqListPopFront(&sl);
	seqlistPrint(&sl);
	seqListPopFront(&sl);
	seqlistPrint(&sl);

	seqListPopBack(&sl);
	seqlistPrint(&sl);
}

int main() {

	//test1();
	//test2();
	//test3();
	//test4();
	test5();
	system("color A");
    system ("pause");
    return 0;
}

习题整理

1.原地移除数组中的val,要求时间复杂度O(n),空间复杂度为O(1):
方法1: 在原数组的基础之上进行移除操作
#include <stdio.h>
#include <stdlib.h>

int removeNum(int arr[],int size,int value) {
	int i = 0,idx=0;
	for (int i = 0; i < size; i++) {
		if (arr[i] != value) {
			arr[idx] = arr[i];
			++idx;
		}
	}
	return idx;
}

int main () {
	int arr[] = { 1, 2, 4, 7, 6 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int value = 4;
	int ret = removeNum(arr, size, value); //ret 代表返回的数组的长度
	printf("%d\n",ret);
	for (int i = 0; i < ret;i++) {
		printf("%d ",arr[i]);
	}
	printf("\n");
    system("color A");
    system ("pause");
    return 0;
}
方法2:申请一块新的内存空间来进行处理.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int removeNum(int arr[], int size, int value) {
	int* Newarr = (int*)malloc(size*sizeof(int));
	int i = 0, idx = 0;
	for (int i = 0; i < size; i++) {
		if (arr[i] != value) {
			Newarr[idx++] = arr[i];
		}
	}
	memcpy(arr,Newarr,sizeof(int)*idx);
	free(Newarr);
	return idx;
}

int main() {
	int arr[] = { 1, 2, 4, 7, 6 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int value = 4;
	int ret = removeNum(arr, size, value); //ret 代表返回的数组的长度
	printf("数组中的个数: %d\n", ret);
	for (int i = 0; i < ret; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("color A");
	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

2.删除排序数组中的重复项.

方法1:

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

int removeDuplicate(int arr[],int size) {
	int j = 1, i = 0, idx = 0;
	while (j < size) {
		arr[idx++] = arr[i];
		if (arr[i] != arr[j]) {
			++i;
			++j;		
		} else {
			找到下一个不同元素的位置
			while (arr[i] == arr[j] && j < size)  
				++j;
				i = j;
				++j;
		}
	}
	当j跳出数组的时候,最后一个元素肯定不重复,也要给复制过去
	if (i<size) {
		arr[idx++] = arr[i];
	}
	return idx;
}

int main() {
	int arr[] = { 1, 2, 4, 4, 6, 6, 7 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int ret = removeDuplicate(arr, size); //ret 代表返回的数组的长度
	printf("不重复元素的个数为: %d\n", ret);
	for (int i = 0; i < ret; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("color A");
	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

方法2.常规思维 先将第一个元素找到,然后再依次与后面元素进行比较

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

int  removeDuplicate(int nums[], int size) {
	if (size == 0) {
		return 0;
	}
	int temp = nums[0];
	int idx = 1;
	for (int i = 1; i < size; i++){
		if (nums[i] != temp) {
			temp = nums[i];
			nums[idx++] = temp;
		}
	}
	return idx;
}

int main() {
	int nums[] = { 1, 1, 2, 3, 4, 4, 5, 6, 6, 7, 8 };
	int size = sizeof(nums) / sizeof(nums[0]);
	int ret = removeDuplicate(nums, size);

	printf("不重复的元素个数为: %d\n", ret);
	for (int i = 0; i < ret;i++) {
		printf("%d ",nums[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

方法3: 快慢指针

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

int removeDuplicate(int nums[], int size) {

	int s = 0;
	for (int f = 1; f < size; f++) {
		if (nums[s] != nums[f]) {
			nums[++s] = nums[f];
		}
	}
	return s + 1;
}

void Print(int nums[],int ret) {
	for (int i = 0; i < ret; i++) {
		printf("%d ", nums[i]);
	}
	printf("\n");
}

int main() {
	int nums[] = { 1, 1, 2, 3, 4, 4, 5, 6 };
	int size = sizeof(nums) / sizeof(nums[0]);
	int ret=removeDuplicate(nums, size);
	Print(nums, ret);
	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

3.合并两个有序数组

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

void merge(int arr1[],int m, int arr2[],int n) {
	//未申请动态内存时,从后向前进行比较
	int idx = m + n - 1;
	while (m >0 && n >0) {
		if (arr1[m-1] >= arr2[n-1]) {
			arr1[idx--] = arr1[m - 1];
			--m;
		}
		else {
			arr1[idx--] = arr2[n - 1];
			--n;
		}
	}
	if (n>0) {
		memcpy(arr1,arr2,sizeof(int)*n);
	}
	for (int i = 0; i < 12; i++) {
		printf("%d ", arr1[i]);
	}
	printf("\n");
}

int main () {
	int arr1[] = { 1, 3, 3, 5, 7, 7 };
	int arr2[] = { 2, 4, 4, 5, 8, 9 };

	merge(arr1, 6, arr2,  6);
    system("color A");
    system ("pause");
    return 0;
}

运行结果:
在这里插入图片描述

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

void merge(int arr1[],int m, int arr2[],int n) {
	int* newA = (int*)malloc(sizeof(int)*(m + n));
	int idx = 0;
	int n1 = 0;
	int n2 = 0;

	while (n1<m && n2<n ) {
		if (arr1[n1] <= arr2[n2]) {
			newA[idx++] = arr1[n1++];
		}
		else {
			newA[idx++] = arr2[n2++];	
		}
	}
	if (n1<m)
		memcpy(newA+idx, arr1 + n1, sizeof(int)*(m-n1));
	if (n2<n)
		memcpy(newA+idx, arr2 + n2, sizeof(int)*(n-n2));
	memcpy(arr1,newA,sizeof(int)*(m+n));
	free(newA);

}
void Print(int arr1[],int size) {
	for (int i = 0; i < size; i++) {
		printf("%d ", arr1[i]);
	}
	printf("\n");

}

int main () {
	int arr1[] = { 1, 3, 3, 5, 7, 7 };
	int arr2[] = { 2, 4, 4, 5, 8, 9 };
	int size1 = sizeof(arr1) / sizeof(arr1[0]);
	int size2 = sizeof(arr2) / sizeof(arr2[0]);

	merge(arr1, size1, arr2, size2);
	Print(arr1, size1+size2);
    system("color A");
    system ("pause");
    return 0;
}

运行结果:
在这里插入图片描述

基本思路:先将nums2中的元素插入到nums1中; 然后将其进行排序即可
class Solution {
public:
	void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
		for (int i = 0; i < n; i++) {
			nums1[m + i] = nums2[i];
		}
		sort(nums1.begin(), nums1.end());
	}
};

4.旋转数组. 将数组中的元素向右移动k个元素的位置,其中k是一个非负数.

实例1: 输入[1,2,3,4,5,6,7] 和k等于3 输出: [5,6,71,2,3,4]

方法1: 基本思路:

1.先进行旋转一次
2.循环旋转k次

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void RightRotateOne(int arr[],int size) {
	int end = size - 1;
	int start = arr[size-1];
	while (end>0) {
		arr[end] = arr[end - 1];
		--end;
	}
	arr[0] = start;
}
void RightRotateN(int arr[], int k1, int size) {
	for (int i = 1; i <= k1; i++) {
		RightRotateOne(arr, size);
		printf("向右旋转%d次: ",i);
		for (int i = 0; i < size; i++) {
			printf("%d ", arr[i]);
		}
		printf("\n");
	}
}

int main () {
	int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int k = 0;
	printf("请输入向右旋转的次数: ");
	scanf("%d",&k);
	RightRotateN(arr,k,size);

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

运行结果:
在这里插入图片描述

方法2: 基本思路:

1.先根据k分成前后两部分的旋转
2.然后在进行数组整体的旋转

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

void reverseOne(int* arr,int left,int right) {
	while (left<right) {
		//int temp = arr[right];
		//arr[right] = arr[left];
		//arr[left] = temp;
		swap(arr[left], arr[right])
		++left;
		--right;
	}
}

void reverseN(int arr[],int size,int k) {
	reverseOne(arr, 0, size - 1 - k); //前半部分旋转
	reverseOne(arr, size - k,size-1); //后半部分旋转
	reverseOne(arr, 0, size - 1); //整体旋转
}
void Print(int arr[], int size) {
	for (int i = 0; i < size; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
	int size = sizeof(arr) / sizeof(arr[0]);
	int k = 3;
	reverseN(arr,size,k);
	Print(arr,size);
	system("color A");
	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

眼眸印着温柔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法（C++）之一——顺序表（SeqList）
SQYBI @ CSDN
02-08 1746
《数据结构与算法（C++）》，窦延平 张同珍 姜丽红 陈玉泉，上海交通大学出版社。上海交通大学算法与数据结构课程教材。本系列文章为书中数据结构与算法的具体实现。顺序表，通过下标访问元素，插入操作复杂度较高。Next和Prev因为没有实质性作用，所以没有实现。 写这个类也是遇到了不少问题。最大的一个问题是，刚开始我是把声明和定义分开在.h和.cpp文件中写的，但是写完之后测试
C语言实现动态顺序表的实现代码
08-29
主要介绍了C语言实现动态顺序表的实现代码的相关资料,动态顺序表在内存中开辟一块空间，可以随我们数据数量的增多来扩容，需要的朋友可以参考下
C/C++_顺序表
Geosen_Jira的博客
10-29 108
没错，我也开始学数据结构了，感觉我们学校开设的好晚欸，别人都学完了，都开始考研了，我们才刚刚开始...
C语言中数据结构——顺序表
一怀明月的博客
04-16 641
C语言中数据结构——顺序表详解
线性表的顺序表示---练习题（算法设计题
1900的博客
05-27 3893
存储结构： 静态分配 #define MaxSize 30 typedef struct{ ElemType data[MaxSize]; int Lenth; }SqList; 动态分配 #define InitSize 50 typedef struct{ ElemType *data; int MaxSize,Lenth; }SeqList; 题目： 1、从顺序表中删除最小值元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若...
数据结构-2.2线性表的顺序结构存储及其运算实现
weixin_51671868的博客
09-14 627
顺序表
数据结构复习题（包含答案）
qq_53869058的博客
04-20 7162
c语言数据结构期末考试题（包含答案）
线性表顺序表相关习题及详解 ——数据结构
Amour
10-11 9434
重新系统的过一遍数据结构现在先回顾下它的定义#define MaxSize 50 //定义线性表的最大长度 typedef struct{ ElemType data[MaxSize]; //顺序表的元素 int length; //顺序表的当前长度 }SqList; //
C++代码复习（三）——SeqList顺序表内数据的指针方式实现
qq_43210248的博客
10-07 365
代码
模拟通讯录-数据结构（顺序表实现基本功能）.doc
04-25
模拟通讯录，设计相关数据结构，用菜单选择方式实现：通讯录的建立、通讯联系人的插入、删除、修改、查找等功能。
图书管理顺序表实现.txt
03-12
图书管理c语言顺序表实现
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
数据结构顺序表 C语言代码实现以及realloc的使用
顺序表的定义、初始化、及插入、删除、查询操作，将算法转化成具体的代码
成长的足迹
10-01 1万+
#include using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 int OK=1; int OVERFLOW=0; int ERROR=0; /*线性表的定义*/ typedef struct { char *elem; int length;//当前长度 int listsize;//线性表的长度 }SqList; /*线性表的初始化*/ int
数据结构填空题
qq_40907977的博客
08-07 5万+
1、 2、 3、 4、 5、 6、 7、 8、 9、 10、 11、 12、 13、 14、 15、 16、 17、 18、 19、 20、 21、 22、 23、 24、 25、 26、 27、 28、 29、 30、 31、 32、 33、 34、 35、 36、 37、 38、 39、 40、 41、 42、 43、 44、 45、 46、 47、 48、 49、 50、 51、 52、 53、 54、 55、 56、 57、 58、 59、 60、 61、 62、 63、 64、 65、 66、 6
实验题一（实现顺序表各种基本运算的算法）
qq_42403069的博客
11-05 1万+
目的：领会顺序表存储结构和掌握顺序表中各种基本运算算法设计。 内容：编写一个.cpp的程序，实现顺序表的各种基本运算和整体建表算法（假设顺序表的元素类型为 Elemtype char）,并在此基础上设计一个主程序，完成如下功能： (1)初始化顺序表L。 (2)依次插入a,b,c,d,e元素。 (3)输出顺序表L。 (4)输出顺序表L的长度。 (5)判断顺序表L是否为空。 (6)输出顺序表L的第3个...
1.1顺序表(SeqList)的实现
engreal的博客
09-19 1393
用C语言实现的顺序表
数据结构习题及解析四
08-19 1162
一、选择题1、非空循环链表head 的尾结点 p 满足下列( )条件。 A.head->next==p B.head==p C.p->next==head D.p->next==NULL解析：本题考点是非空循环链表的特性。因为是非空循环链表，所以尾结点的下一个结点应该是头结点。因此，本题参考答案是C。2、设栈s的类型为sqstack ，判定栈空的条...
【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）
热门推荐
codewinter的博客
08-18 6万+
文章目录（1）线性表（2）顺序表1）什么是顺序表2）顺序表的定义2）顺序表的接口实现1、初始化顺序表2、销毁（释放）顺序表3、检查顺序表容量是否满了，好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、修改指定下标位置的数据 （1）线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
c 语言 ---- 结构体
最新发布
qq_73270720的博客
05-20 150
/1.先声明再定义int x;int y;//2.声明的同时定义int x;int y;}p1,p2;typedef定义别名关键字typedef用于为系统固有的或者程序员自定义的数据类型定义一个别名。数据类型的别名通常使用大写字母。这样就为int定义了一个新的名字INTEGERint与INTEGER是一个意思，是完全等价的。所以，我们当然也可以使用typedef来为结构体定义一个别名，让我们使用更加方便。int age;}STU;
顺序表代码讲解以及实现
03-13
顺序表的实现可以使用数组来完成。下面是一个简单的顺序表的代码实现： ``` #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 用数组存储顺序表的元素 int length; // 顺序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值