D24. 顺序表的动态存储

// 顺序表的动态存储 
#ifndef _SEQLIST_H_
#define _SEQLIST_H_

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

typedef int SLDataType; //相当于给int起一个datatype的别称，及datatype就是int

typedef struct SeqList {    
	SLDataType* array;  // 指向动态开辟的数组   
	size_t size;       // 有效数据个数  
	size_t capicity;   // 容量空间的大小
}SeqList;

// 基本增删查改接口 
void SeqListInit(SeqList* psl, size_t capicity);
void SeqListDestory(SeqList* psl);

void CheckCapacity(SeqList* psl);
void SeqListPushBack(SeqList* psl, SLDataType x);
void SeqListPopBack(SeqList* psl);
void SeqListPushFront(SeqList* psl, SLDataType x);
void SeqListPopFront(SeqList* psl);

int SeqListFind(SeqList* psl, SLDataType x);
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
void SeqListErase(SeqList* psl, size_t pos);
void SeqListRemove(SeqList* psl, SLDataType x);
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);
void SeqListPrint(SeqList* psl);

#endif //_SEQLIST_H_

#include "SeqList.h"

void SeqListInit(SeqList* psl, size_t capicity)
{
	assert(psl);
	psl->capicity = capicity;
	psl->array = (SLDataType *)malloc(capicity*sizeof(SLDataType));
	assert(psl->array);
	psl->size = 0;
}

void SeqListDestory(SeqList* psl)
{
	assert(psl);

	if (psl->array)
	{
		free(psl->array);
		psl->array = NULL;
		psl->size = 0;
		psl->capicity = 0;
	}
}

void CheckCapacity(SeqList* psl)
{
	assert(psl);

	if (psl->size == psl->capicity)
	{
		psl->capicity *= 2;
		psl->array = (SLDataType *)realloc(psl->array, psl->capicity*sizeof(SLDataType));
	}
}

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);

	CheckCapacity(psl);

	psl->array[psl->size] = x;
	psl->size++;
}

//释放尾部元素
void SeqListPopBack(SeqList* psl)
{
	assert(psl || psl->size);
	psl->size--;
}

//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);

	CheckCapacity(psl);

	int i;
	for (i = psl->size - 1; i >= 0; i--)  //向后移动
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[0] = x;
	psl->size++;
}

//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);

	psl->size--;

	int i;
	for (i = 0; i < psl->size; i++)
	{
		psl->array[i] = psl->array[i + 1];
	}
}

int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);

	int i;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl || pos <= psl->size);

	CheckCapacity(psl);

	int i;
	for (i = psl->size - 1; i >= pos; i--)  //向后移动
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[pos] = x;
	psl->size++;
}

void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl || pos < psl->size);

	psl->size--;
	int i;
	for (i = pos; i < psl->size; i++)
	{
		psl->array[i] = psl->array[i + 1];
	}
}


void SeqListRemove(SeqList* psl, SLDataType x)
{
	assert(psl);

	int pos = SeqListFind(psl, x);
	if (pos >= 0)
	{
		SeqListErase(psl, pos);
	}
}

 void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
 {
	 assert(psl || pos < psl->size);

	 psl->array[pos - 1] = x;
 }



void SeqListPrint(SeqList* psl)
{
	assert(psl);

	int i;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d", psl->array[i]);
	}
	putchar('\n');
}

void SeqListBubbleSort(SeqList* psl)
{
	assert(psl);

	int i, j;
	SLDataType	tmp;
	for (i = 0; i < psl->size - 1; i++)
	{
		for (j = 0; j < psl->size - 1 - i; j++)
		{
			if (psl->array[j]>psl->array[j + 1])
			{
				tmp = psl->array[j];
				psl->array[j] = psl->array[j + 1];
				psl->array[j + 1] = tmp;
			}
		}
	}
}

int SeqListBinaryFind(SeqList* psl, SLDataType x)
{
	assert(psl);

	int left = 0;
	int right = psl->size - 1;
	int mid;

	while (left <= right)
	{
		mid = (left + right) / 2;
		if (psl->array[mid] < x)
		{
			left = mid + 1;
		}
		else if (psl->array[mid] >x)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

#include"SeqList.h"
#include<stdlib.h>

void seqtest()
{
	SeqList test;
	SeqListInit(&test, 10);
	SeqListPrint(&test);
	SeqListPushBack(&test, 1);
	SeqListPushBack(&test, 2);
	SeqListPushBack(&test, 3);
	SeqListPushBack(&test, 4);
	SeqListPushBack(&test, 5);
	SeqListPushBack(&test, 6);
	SeqListPushBack(&test, 7);
	SeqListPushBack(&test, 8);
	SeqListPushBack(&test, 9);
	SeqListPrint(&test);
	SeqListPushFront(&test, 10);
	SeqListPushFront(&test, 10);
	SeqListPushFront(&test, 10);
	SeqListPrint(&test);

	SeqListPopBack(&test);
	SeqListPopBack(&test);
	SeqListPopBack(&test);
	SeqListPopBack(&test);
	SeqListPrint(&test);
	SeqListPopFront(&test);
	SeqListPrint(&test);

	SeqListInsert(&test, 1, 16);
	SeqListPrint(&test);
	SeqListErase(&test, 2);
	SeqListPrint(&test);
	SeqListRemove(&test, 4);
	SeqListPrint(&test);
	SeqListModify(&test, 5, 6);
	SeqListPrint(&test);

	SeqListBubbleSort(&test);
	printf("%d\n", SeqListBinaryFind(&test, 6));

	SeqListPrint(&test);
	SeqListDestory(&test);
}
int main()
{
	seqtest();
	system("pause");
	return 0;
}