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

//陣列的應用

struct Array
{
	int * pBase;      //儲存首地址
	int len;
	int cet;          //cet: current efficient(當前有效元素的個數) 
};

void test01();   
void init_arr(struct Array * pArr, int length); //init: initialize (初始化)
bool append_arr(struct Array * pArr, int val);
bool insert_arr(struct Array * pArr, int pos, int val); //pos: position,  pos的值從1開始
bool delete_arr(struct Array * pArr, int pos, int * pVal);
int get();
bool is_empty(struct Array * pArr);
bool is_full(struct Array * pArr);
void sort_arr(struct Array * pArr);
void show_arr(struct Array * pArr);
void inversion_arr(struct Array * pArr); //陣列倒置


int main()
{
	test01();

	return 0;
	
} 

void test01()
{
	struct Array arr;
	int val;
	
	init_arr(&arr, 6); //實現陣列的初始化

	show_arr(&arr);    //實現輸出

	append_arr(&arr, 1);//實現追加
	append_arr(&arr, 2);
	append_arr(&arr, 3);
	append_arr(&arr, 4);
	append_arr(&arr, 5);
	append_arr(&arr, 6);

	printf("新增元素後的陣列為：\n");
	show_arr(&arr); 

	if(delete_arr(&arr, 1, &val))
	{
		printf("刪除成功!  您刪除的元素是:%d\n", val);
	}
	else 
	{
		printf("刪除失敗！\n");
	}

	printf("刪除元素後的陣列為：\n");
	show_arr(&arr);    //實現輸出

	printf("倒置後的陣列為：\n");
	inversion_arr(&arr);
	show_arr(&arr); 

	printf("排序後的陣列為：\n");
    sort_arr(&arr);
	show_arr(&arr); 

	printf("插入後的陣列為：\n");
	insert_arr(&arr, 1, 66);
	//insert_arr(&arr, 6, 99);
	show_arr(&arr); 
}
 

void init_arr(struct Array * pArr, int length) //pArr = &arr, *pArr = arr
{
	pArr->pBase =  (int *)malloc(sizeof(int) * length); //動態分配陣列才可跨函式使用，分配在堆區

	if(NULL == pArr->pBase)
	{
		printf("動態記憶體分配失敗！");
		exit(-1);   //終止整個程式
	}
	else
	{
		//初始化陣列
		pArr->len = length;
		pArr->cet = 0;
	}
	return;   //函式終止標誌
}

bool append_arr(struct Array * pArr, int val)
{
	if(is_full(pArr))  //判斷陣列是否滿了
	{
		return false;  //滿了返回false
	}

	pArr->pBase[pArr->cet] = val; //不滿將變數val的內容加入
    (pArr->cet)++;                //cet總是比下標多1，cet可以作為要新增的下標

	return true;
}

bool is_full(struct Array * pArr)
{
	if(pArr->cet == pArr->len)        //注意等號 ==
	{
		return true;
	}
	else
	{
		return false;
	}
}


void show_arr(struct Array * pArr)
{
	if(is_empty(pArr))               //忘記傳實參
	{
		printf("此時陣列是空的!\n");
	}
	else
	{
		for(int i = 0; i<pArr->cet; i++)
		{
			printf("%d\t", pArr->pBase[i]);
		}
		printf("\n\n");
	}
}


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


bool insert_arr(struct Array * pArr, int pos, int val)//pos是元素的位置，而不是下標的位置
{
	int i;   //i是下標

	if(is_full(pArr))
	{
		return false;
	}

	if(pos<1 || pos>pArr->cet+1)
	{
		return false;
	}

	for(i = pArr->cet-1; i>=pos-1; i--)    //從最後一個元素迴圈到需要新增的元素
	{
		pArr->pBase[i+1] = pArr->pBase[i]; //給需要新增的元素騰出一個位置
	}

	pArr->pBase[pos-1] = val;
	(pArr->cet)++;    //有效元素的個數增加了一個

	return true;
}

bool delete_arr(struct Array * pArr, int pos, int * pVal)
{
	int i;

	if(is_empty(pArr))
	{
		return false;
	}
	if(pos<1 || pos>pArr->cet)
	{
		return false;
	}

	*pVal = pArr->pBase[pos-1]; //把需要刪除的值通過 解引用的方式 放到val中

	for(i = pos; i<pArr->cet; i++)
	{
		pArr->pBase[i-1] = pArr->pBase[i];
	}
	(pArr->cet)--;   //有效元素的個數減少了一個

	return true;
}

void inversion_arr(struct Array * pArr)
{
	int i = 0;           //注意i和j是下標
	int j = pArr->cet-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 Array * pArr)
{
	int i, j, t;

	for(i = 0; i<pArr->cet-1; i++) //氣泡排序求最小值
	{
		for(j = i+1; j<pArr->cet; j++)
		{
			if(pArr->pBase[i]>pArr->pBase[j])
			{
				t = pArr->pBase[j];
				pArr->pBase[j] = pArr->pBase[i];
				pArr->pBase[i] = t;
			}
		}
	}
}