数据结构学习——顺序表

PART ONE —— 实现顺序表

/*main.c*/
#include "main.h"
int main()
{
	char ch;
	welcome();
	while (1)
	{
		printf("1.添加数据\n");
		printf("2.删除数据\n");
		printf("3.遍历顺序表\n");
		printf("4.查看数据表属性\n");
		printf("5.插入数据\n");
		printf("选择你的操作(q 退出)： ");
		ch = getch();

		switch (ch)
		{
			case '1':
				int val;	

				printf("\n请输入你要添加的数据：");
				scanf("%d", &val);
				add_data(user, val);
				printf("\n");

				break;
			case '2':
				int index;

				printf("\n请输入你要删除的数据：");
				scanf("%d", &val);
				index = delete_data(user, val);
				printf("\n已删除数据%d, 它是第%d个元素。", val, index + 1);
				printf("\n");
				break;
			case '3':
	
				browe(user);
				printf("\n");
				break;
			case '4':
			{
		
				int * len = (int *)malloc(sizeof(int));
				int * left = (int *)malloc(sizeof(int));
				if (status_List(user, len, left))
				{
					printf("\n当前表的长度为%d, 还剩下%d个空间。", *len, *left);
				}
				printf("\n");
				break;
			}
			case '5':
			
				printf("\n请分别输入你要插入的数据和位置（先数据后位置，用空格隔开）：");
				scanf("%d %d", &val, &index);
				if (insert_data(user, val, index))
				{
					printf("\n插入成功。");
				}
				printf("\n");
				break;
			case 'q':
				system("cls");
				printf("退出系统。");
				exit(0);
			default:
				system("cls");
				printf("\n");
				break;
		}
	}
	return 0;
}

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


#define LISTSIZE 10		//每创建一个顺序表的初始大小都为20

//顺序表定义
typedef struct {
	int * data;
	int length;
	int listsize;
}SqList;


SqList * user = NULL;

/**********函数定义**************/



//初始化顺序表
SqList * Initlist(void)
{
	SqList * List_head = (SqList *)malloc(sizeof(SqList));
	if (List_head == NULL)
	{
		printf("顺序表初始化失败，程序退出！");
		exit(-1);
	}

	//初始化顺序表
	List_head->data = (int *)malloc(sizeof(int) * LISTSIZE);	//分配空间
	if (List_head->data == NULL)
	{
		printf("顺序表初始化失败，程序退出！");
		exit(-1);
	}
	List_head->length = 0;
	List_head->listsize = LISTSIZE;
	return List_head;
}

//判空
bool Listempty(SqList * u)
{
	if (u->length == 0)
	{
		return true;
	}
	else
		return false;
}

//判满
bool Listfull(SqList * u)
{
	if (u->length == u->listsize)
	{
		return true;
	}
	return false;
}

//扩大容量
//最先想到的，不好用
SqList * expansion_List(SqList * u)
{
	SqList * another_u = NULL;
	int len = u->length;
	int size = u->listsize;
	another_u = (SqList *)realloc(u, (u->listsize + LISTSIZE) * sizeof(SqList));	//扩大一个 LISTSIZE 的大小
	another_u->length = len;
	another_u->listsize = size + LISTSIZE;
	return another_u;
}

//添加数据
bool add_data(SqList * u, int val)		//添加的数据的值
{
	if (u->length == u->listsize)
	{
		//这是一种办法，直接把扩大后的顺序表地址发给我们创建的表名，这样子耦合度就高了，不是很好
		//user = expansion_List(u);

		//add_data(user, val);
		//return true;

		//这种方法好
		int * newbase = (int *)realloc(u->data, (u->listsize + LISTSIZE) * sizeof(int));		//可能分配另一块地址，然后把原来的数据拷贝过去，再返回首地址
		u->data = newbase;
		u->listsize += LISTSIZE;
	}

	*(u->data + u->length) = val;
	u->length++;
	return true;
}

//删除数据
int delete_data(SqList * u, int val)	//，删除数据的值，返回删除数据的下标
{
	int index = 0;
	if (Listempty(u))
	{
		printf("\n数组为空, 无法删除。");
	}

	for (int i = 0; i < u->length; i++)
	{
		if (val == *(u->data + i))
		{
			index = i;	//得到下标

			for (int i = index; i < u->length - 1; i++)
			{
				*(u->data + i) = *(u->data + i + 1);
			}
			u->length--;
			break;
		}
	}
	return index;
}

//插入数据
bool insert_data(SqList * u, int val, int index)		//插入数据的值和插入的位置
{
	if (Listfull(u))
	{
		int * newbase = (int *)realloc(u->data, (u->listsize + LISTSIZE) * sizeof(int));		//可能分配另一块地址，然后把原来的数据拷贝过去，再返回首地址
		u->data = newbase;
		u->listsize += LISTSIZE;
	}

	if (index > u->length)		//所要插入的位置大于现表长，则无法插入
	{
		printf("现在的表没有那么长，无法插入。");
		return false;
	}

	u->length++;//表长加一
	int i;
	for (i = u->length - 2; i >= index - 1; i--)
	{
		*(u->data + i + 1) = *(u->data + i);
	}
	*(u->data + index - 1) = val;
	return true;
}

//查看表属性
bool status_List(SqList * u, int * len, int * left)
{
	*len = u->length;
	*left = u->listsize - u->length;
	return true;
}

//浏览数据
void browe(SqList * u)			//所要浏览的顺序表
{
	printf("\n");
	for (int i = 0; i < u->length; i++)
	{
		printf("%d\t", *(u->data + i));
	}
	printf("\n");
}

//欢迎界面
void welcome(void)
{
	char choice;
	printf("欢迎使用顺序表系统，按 y or Y 确定继续，按 q or Q 退出系统！");
	while (1)
	{
		choice = getch();

		if (choice == 'y' || choice == 'Y')
		{
			system("cls");
			user = Initlist();		//所以函数 Initlist() 应该在本函数前面;
			printf("\n成功进入系统，已为您创建好一个大小为%d的顺序表。\n", LISTSIZE);
			break;
		}

		else if (choice == 'q' || choice == 'Q')
		{
			system("cls");
			printf("\n成功退出程序!");
			exit(0);
		}
	}
}

PART ONE —— 遇到的问题

第一 即这个部分

			case '4':
			{
		
				int * len = (int *)malloc(sizeof(int));
				int * left = (int *)malloc(sizeof(int));
				if (status_List(user, len, left))
				{
					printf("\n当前表的长度为%d, 还剩下%d个空间。", *len, *left);
				}
				printf("\n");
				break;
			}

我在这个’case’加了两个中括号，这样就可以运行了，如果把两个中括号去掉就会报错，如下图所示

			case '4':
			
		
				int * len = (int *)malloc(sizeof(int));
				int * left = (int *)malloc(sizeof(int));
				if (status_List(user, len, left))
				{
					printf("\n当前表的长度为%d, 还剩下%d个空间。", *len, *left);
				}
				printf("\n");
				break;
			

不知道什么情况，希望知道的小伙伴可以告诉我，前提是你能看的到这篇文章（笑哭）

第二 憨批算法

SqList * user = NULL;

//扩大容量
//最先想到的，不好用
SqList * expansion_List(SqList * u)
{
	SqList * another_u = NULL;
	int len = u->length;
	int size = u->listsize;
	another_u = (SqList *)realloc(u, (u->listsize + LISTSIZE) * sizeof(SqList));	//扩大一个 LISTSIZE 的大小
	another_u->length = len;
	another_u->listsize = size + LISTSIZE;
	return another_u;
}

//添加数据
bool add_data(SqList * u, int val)		//添加的数据的值
{
	if (u->length == u->listsize)
	{
		//这是一种办法，直接把扩大后的顺序表地址发给我们创建的表名，这样子耦合度就高了，不是很好
		user = expansion_List(u);

		add_data(user, val);
		return true;

		//这种方法好
		//int * newbase = (int *)realloc(u->data, (u->listsize + LISTSIZE) * sizeof(int));		//可能分配另一块地址，然后把原来的数据拷贝过去，再返回首地址
		//u->data = newbase;
		//u->listsize += LISTSIZE;
	}

	*(u->data + u->length) = val;
	u->length++;
	return true;
}