循序表结构体演示

循序表写通讯录

函数的声明和定义

• 先创建一个结构体

• 声明定义里面有#define Sldatastyle int，方便定义不同的类型

• 用typedef 将结构体重新命名为SL，方便后面的书写

• 同时用#define定义的容量

  #pragma once
  //容量
  #define CAPACITY_CY 3
  #define SLdatstyle int
  #include<stdio.h>
  #include<stdlib.h>
  #include<assert.h>
  typedef struct stu {
      int sz;
  	SLdatstyle* data;
  	SLdatstyle capacity;
  }SL;
  void SLinit(SL* ps);
  void SLinsert(SL* ps, SLdatstyle pos, SLdatstyle x);
  void SLpushfront(SL* ps, SLdatstyle x);
  void SLprint(SL* ps);
  void SLpopblack(SL* ps);
  void SLpushback(SL* ps, SLdatstyle x);
  void SLpopfront(SL* ps);
  void erase(SL* ps,SLdatstyle x);
  
  

函数的实现

• 首先初始化一下
• 给ps->data开辟一块空间
• 初始化容量ps->capacity的空间是Capacity_cy

void SLinit(SL* ps) {
	assert(ps);
	ps->data = (SLdatstyle*)malloc(sizeof(SLdatstyle) * CAPACITY_CY);
	if (ps->data == NULL) {
		perror("malloc");
		return;
	}
	ps->capacity = CAPACITY_CY;
	ps->sz = 0;
}

• 打印函数的实现

void SLprint(SL* ps) {
	SLdatstyle i = 0;
	for (i = 0; i < ps->sz; i++) {
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

有两种实现头部和尾部的插入

第一种头部的插入

void SLpushfront(SL* ps, SLdatstyle x) {
	assert(ps);
	check_capcity(ps);
	int end = ps->sz - 1;
	//检查扩容
	while (end >= 0) {
		ps->data[end + 1] = ps->data[end];
		--end;
	}
	ps->data[0] = x;
	ps->sz++;
}

先实现一下插入函数

void SLinsert(SL* ps, SLdatstyle pos, SLdatstyle x) {
	assert(pos >= 0 && pos <= ps->sz);
	//如果从前向后覆盖,会导致数据被覆盖
	//代表最后一个元素
	int end = ps->sz - 1;
	//这边要扩容
	check_capcity(ps);
	while (end >= pos) {
		//用前面一个元素替代后面一个元素
		//当到达pos的时候,往后面移动一位
		ps->data[end + 1] = ps->data[end];
		//寻找下一个元素
		--end;
	}
	ps->data[pos] = x;
	ps->sz++;
}

第二种可以直接使用,但是需要实现插入函数，插入函数实现后,可以直接使用插入函数在头部进行插入

void SLpushfront(SL* ps, SLdatstyle x) {
	assert(ps);
	SLinsert(ps, 0, x);
	}

在尾部插入数据一样,有两种方式

第一种

void SLpushback(SL* ps, SLdatstyle x) {
	assert(ps);
	check_capcity(ps);
	//新开辟的一块空间插入
	/*ps->data[ps->sz] = x;
	ps->sz++;*/
	//新的插入方式
	}

第二种方式

void SLpushback(SL* ps, SLdatstyle x) {
	assert(ps);
	check_capcity(ps);
	SLinsert(ps, ps->sz, x);
	}
	

删除和插入一样

我们先实现删除函数

void erase(SL* ps,SLdatstyle pos) {
	assert(ps);
	int end = pos - 1;
	while (ps->sz > end) {
		ps->data[end] = ps->data[end + 1];
		end++;
	}
	ps->sz--;
}

第一种直接头部删除

void SLpopfront(SL* ps) {
	assert(ps);
	int end = 1;
	/*while (end <ps->sz) {
		ps->data[end - 1] = ps->data[end];
		++end;
	}
	ps->sz--;*/
	
}

第二种运用实现的函数在头部删除

void SLpopfront(SL* ps) {
	assert(ps);
	int end = 1;
		erase(ps, 0);
}

尾部的删除

第一种直接删除

void SLpopblack(SL* ps) {
	assert(ps);
	/*ps->data[ps->sz - 1] = 0;
	ps->sz--;*/
	}

第二种运用实现的函数

void SLpopblack(SL* ps) {
	assert(ps);
	erase(ps, ps->sz - 1);
}

函数的调试

#define _CRT_SECURE_NO_WARNINGS 1
#include "sqlist.h"
void testqulist() {
	SL s;
	//得先初始化
	SLinit(&s);
	
	SLpushfront(&s,1);
	SLpushfront(&s,2);
	SLpushfront(&s,3);
	
	SLpushfront(&s, 4);
	SLprint(&s);
	SLpopfront(&s);
	//erase(&s, 2);
	//SLpopblack(&s);
	//SLprint(&s);
	SLprint(&s);
}
int main() {
	testqulist();
}

函数的代码演示

函数声明

#pragma once
/量
#define CAPACITY_CY 3
#define SLdatstyle int
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef struct stu {
    int sz;
	SLdatstyle* data;
	SLdatstyle capacity;
}SL;
void SLinit(SL* ps);
void SLinsert(SL* ps, SLdatstyle pos, SLdatstyle x);
void SLpushfront(SL* ps, SLdatstyle x);
void SLprint(SL* ps);
void SLpopblack(SL* ps);
void SLpushback(SL* ps, SLdatstyle x);
void SLpopfront(SL* ps);
void erase(SL* ps,SLdatstyle x);

``

函数的实现

#define _CRT_SECURE_NO_WARNINGS 1
#include "sqlist.h"
//先初始化
void SLprint(SL* ps) {
	SLdatstyle i = 0;
	for (i = 0; i < ps->sz; i++) {
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}
void SLinit(SL* ps) {
	assert(ps);
	ps->data = (SLdatstyle*)malloc(sizeof(SLdatstyle) * CAPACITY_CY);
	if (ps->data == NULL) {
		perror("malloc");
		return;
	}
	ps->capacity = CAPACITY_CY;
	ps->sz = 0;
}
//实现扩容
void check_capcity(SL* ps) {
	assert(ps);
	if (ps->sz == ps->capacity) {
		SL* ptr = (SLdatstyle*)malloc(sizeof(SLdatstyle) * CAPACITY_CY*2);
		if (ptr == NULL) {
			perror("malloc");
			return;
		}
		ps->data = ptr;
	}
	ps->capacity = 2 * CAPACITY_CY;
}
//再实现插入数值
//实现头部的插入数值,有两种方式
//第一种方式
//头部插入一次的时间复杂度是O(N);
//时间复杂度是O(1);
void SLpushfront(SL* ps, SLdatstyle x) {
	assert(ps);
//	check_capcity(ps);
//	int end = ps->sz - 1;
//	//检查扩容
//	while (end >= 0) {
//		ps->data[end + 1] = ps->data[end];
//		--end;
//	}
//	ps->data[0] = x;
//	ps->sz++;
	SLinsert(ps, 0, x);
}
//删除尾部,
void SLpopblack(SL* ps) {
	assert(ps);
	/*ps->data[ps->sz - 1] = 0;
	ps->sz--;*/
	erase(ps, ps->sz - 1);
}
void erase(SL* ps,SLdatstyle pos) {
	assert(ps);
	int end = pos - 1;
	while (ps->sz > end) {
		ps->data[end] = ps->data[end + 1];
		end++;
	}
	ps->sz--;
}
void SLinsert(SL* ps, SLdatstyle pos, SLdatstyle x) {
	assert(pos >= 0 && pos <= ps->sz);
	//如果从前向后覆盖,会导致数据被覆盖
	//代表最后一个元素
	int end = ps->sz - 1;
	//这边要扩容
	check_capcity(ps);
	while (end >= pos) {
		//用前面一个元素替代后面一个元素
		//当到达pos的时候,往后面移动一位
		ps->data[end + 1] = ps->data[end];
		//寻找下一个元素
		--end;
	}
	ps->data[pos] = x;
	ps->sz++;
}
//尾部插入
void SLpushback(SL* ps, SLdatstyle x) {
	assert(ps);
	check_capcity(ps);
	//新开辟的一块空间插入
	/*ps->data[ps->sz] = x;
	ps->sz++;*/
	//新的插入方式
	SLinsert(ps, ps->sz, x);
}
//头部删除
void SLpopfront(SL* ps) {
	assert(ps);
	int end = 1;
	/*while (end <ps->sz) {
		ps->data[end - 1] = ps->data[end];
		++end;
	}
	ps->sz--;*/
	erase(ps, 0);
}

函数的调用演示

#define _CRT_SECURE_NO_WARNINGS 1
#include "sqlist.h"
void testqulist() {
	SL s;
	//得先初始化
	SLinit(&s);
	
	SLpushfront(&s,1);
	SLpushfront(&s,2);
	SLpushfront(&s,3);
	
	SLpushfront(&s, 4);
	SLprint(&s);
	SLpopfront(&s);
	//erase(&s, 2);
	//SLpopblack(&s);
	//SLprint(&s);
	SLprint(&s);
}
int main() {
	testqulist();
}