数据结构（连续存储--动态数组）

数据结构的概述

1. 定义：我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法

数据结构 = 个体 + 个体的关系
算法 = 对存储数据的操作

2. 算法
   解题的方法和步骤

衡量算法的标准：
（1）时间复杂度：大概程序要执行的次数，而非执行的时间
（2）空间复杂度：算法执行过程中大概所占用的最大内存
（3）难易程度
（4）健壮性

3. 数据结构的地位
   是软件中最核心的课程

程序 = 数据的存储 + 数据的操作 + 可以被计算机执行的语言

预备知识

主要是指针、结构体、动态创建内存，这些知识，这个在我的c语言笔记里面有

线性结构

线性结构：把所有的节点用一根直线穿起来

1. 联系存储【数组】
   （1）什么叫数组：元素类型相同，大小相等
   （2）数组的缺点

创建一个动态数组，并且实现数组的初始化，输出，插入，追加，删除，排序，倒叙等功能。

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

struct Arr {  // 定义了一个数据类型，该数据类型的名字叫做 struct Arr, 该数据类型含有三个成员，分别是 pBase, len, cnt 
	int *pBase; // 存储的是数组的第一个元素的地址 
	int len;    // 数组所能容纳的最大元素的个数 
	int cnt;    // 当前数组的有效元素的个数 
};

void init_arr(struct Arr *, int);
bool append_arr(struct Arr *, int);
bool insert_arr(struct Arr *, int, int); // post从1开始 
bool delete_arr(struct Arr *, int, int *);
int get();
bool is_empty(struct Arr *);
bool is_full(struct Arr *);
void sort_arr(struct Arr *);
void show_arr(struct Arr *); 
void inversion_arr(struct Arr *);  //倒置 

int main(void)
{
	struct Arr arr;
	int val;
	
	init_arr(&arr, 6);
//	printf("%d\n", arr.len);
	show_arr(&arr);
	append_arr(&arr, 1);
	append_arr(&arr, 3);
	append_arr(&arr, 5);
	append_arr(&arr, 2);
	append_arr(&arr, 3);
	show_arr(&arr);
	
	sort_arr(&arr);
	
	show_arr(&arr);
	printf("倒序：\n");
	
	
	inversion_arr(&arr);
	
/*	if (delete_arr(&arr, 1, &val)) {
		printf("删除成功！\n");
		printf("您删除的元素:%d\n", val);
	}
	insert_arr(&arr, 1, 99);
	append_arr(&arr, 6);
	if (append_arr(&arr, 7))
		printf("追加成功！\n");
	else
		printf("追加失败！\n");
		*/
	show_arr(&arr);
	
	return 0;
} 

void init_arr(struct Arr * pArr, int length)
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase) {
		printf("动态内存分配失败!\n");
		exit(-1); // 终止整个程序 
	} else {
		pArr->len = length;
		pArr->cnt = 0;
	}
	
	return;
}

bool is_empty(struct Arr *pArr)
{
	if (0 == pArr->cnt)
		return true;
	else
		return false;
}

bool is_full(struct Arr * pArr) 
{
	if (pArr->cnt == pArr->len)
		return true;
	else 
		return false;
}

void show_arr(struct Arr *pArr)
{
	if ( is_empty(pArr) ) {
		printf("数组为空！\n");
	} else {
		for (int i=0; i<pArr->cnt; i++)
			printf("%d ", pArr->pBase[i]);
		printf("\n");
	}
}

bool append_arr(struct Arr * pArr, int val)
{
	// 满时返回false 
	if (is_full(pArr))
		return false;
	
	// 不满时追加 
	pArr->pBase[pArr->cnt] = val;
	pArr->cnt++;
	
	return true; 
}

bool insert_arr(struct Arr *pArr, int post, int val) 
{
	int i;
	
	if (is_full(pArr))
		return false;
	
	if (post<1 || post>pArr->cnt+1)
		return false;
	
	for (i=pArr->cnt-1; i>=post-1; --i) {
		pArr->pBase[i+1] = pArr->pBase[i];
	} 
	pArr->pBase[post-1] = val;
	pArr->cnt++;
	
	return true;
} 

bool delete_arr(struct Arr *pArr, int post, int *pVal)
{
	int i;
	
	if (is_empty(pArr))
		return false;
	
	if (post<1 || post>pArr->cnt)
		return false;
	
	*pVal = pArr->pBase[post-1];
	
	for (i=post; i<pArr->cnt; ++i)
		pArr->pBase[i-1] = pArr->pBase[i];
	pArr->cnt--;
	
	return true;
	
}

void inversion_arr(struct Arr * pArr)
{
	int i = 0;
	int j = pArr->cnt-1;
	int t;
	
	while(i < j)
	{
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		++i;
		--j;
	}
	
	return;
}


void sort_arr(struct Arr *pArr)
{
	int i, j, t;
	
	for (i=0; i<pArr->cnt-1; i++) {
		for (j=0; j<pArr->cnt-1-i; j++) {
			if (pArr->pBase[j] > pArr->pBase[j+1]) {
				t = pArr->pBase[j];
				pArr->pBase[j] = pArr->pBase[j+1];
				pArr->pBase[j+1] = t;
			}
		}
	}
	
	return;
}

2. 离散存储【链表】
3. 线性结构的两种常见应用之一 【栈】
4. 线性结构的两种常见应用值二 【队列】