数据结构-顺序表、链表-基本操作

#ifndef SLIST_H_
#define SLIST_H_

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

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType _data;
	struct SListNode* _next;
}SListNode;
typedef struct SList
{
	SListNode* _head;
}SList;

void SListInit(SList* plist);
void SListDestory(SList* plist);

SListNode* BuySListNode(SLTDataType x);

void SListPushFront(SList* plist, SLTDataType x);
void SListPopFront(SList* plist);

SListNode* SListFind(SList* plist, SLTDataType x);
void SListInsertAfter(SListNode* pos, SLTDataType x);// 在pos的后面进行插入
void SListEraseAfter(SListNode* pos);// 在pos的前面进行插入

void SListRemove(SList* plist, SLTDataType x);//作业：给一个x，把这个结点删除(练习链表的遍历)

void SListPrint(SList* plist);
void TestSList();

#endif

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
typedef int SLDataType;

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

typedef struct SeqList
{
	SLDataType * array;//指向动态开辟的数组
	size_t size;//有效数据的个数
	size_t capicity;//容量空间大小
}SeqList;
void SeqListInit(SeqList* psl, size_t capacity);
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);

void SeqListBubbleSort(SeqList* psl);
int SeqListBinaryFind(SeqList* psl, SLDataType x);// 本题要求：时间复杂度：O(N) 空间复杂度 O(1)
void SeqListRemoveAll(SeqList* psl, SLDataType x);//作业：先排序->(去重，1 3 3 3 4 5->1 3 4 5)
#endif //_SEQLIST_H_

#include "slist.h"

void SListInit(SList* plist)//初始化一个头结点
{
	plist->_head = NULL;
}
void SListPushFront(SList* plist, SLTDataType x)//头插
{
	assert(plist);
	SListNode *cur = (SListNode *)malloc(sizeof(SListNode));
	cur->_data = x;
	cur->_next = plist->_head;
	plist->_head = cur;
}
void SListPopFront(SList* plist)//头删
{
	assert(plist);
	SListNode *tmp;
	if (plist->_head)
	{
		tmp = plist->_head;
		plist->_head = plist->_head->_next;
		free(tmp);
	}
}

void SListPrint(SList* plist)//打印链表
{
	assert(plist);
	SListNode * cur;
	for (cur = plist->_head; cur; cur = cur->_next)
	{
		printf("%d->", cur->_data);
	}
	printf("NULL\n");
}

void SListDestory(SList* plist)//释放链表
{
	SListNode * tmp;
	while (plist->_head)
	{
		tmp = plist->_head;
		plist->_head = plist->_head->_next;
		free(tmp);
	}
}

SListNode* SListFind(SList* plist, SLTDataType x)//查找一个节点，并且返回位置
{
	SListNode * cur;
	for (cur = plist->_head; cur; cur = cur->_next)
	{
		if (cur->_data == x)
		{
			return cur;
		}
	}
	return NULL;
}
void SListInsertAfter(SListNode* pos, SLTDataType x)//在pos的后面插入结点
{
	assert(pos);
	SListNode *cur = (SListNode *)malloc(sizeof(SListNode));
	cur->_data = x;
	cur->_next = pos->_next;
	pos->_next = cur;
}

//void SListInsertFront(SList * plist, SLTDataType x)//在pos的前面插入结点
//{
//	SListNode * cur;
//	SListNode * newdata = (SListNode *)malloc(sizeof(SListNode));
//	if (plist->_head->_data == x)
//	{
//		SListPushFront(plist, x);
//		return;
//	}
//	for (cur = plist->_head; cur->_next; cur = cur->_next)
//	{
//		if (cur->_next->_data == x)
//		{
//			break;
//		}
//	}
//	newdata->_next = cur->_next;
//	cur->_next = newdata;
//}
void SListEraseAfter(SListNode* pos)//在pos的后面删除结点
{
	SListNode * tmp;
	tmp= pos->_next;
	pos->_next=tmp->_next;
	free(tmp);
}

#include "SeqList.h"
#include <assert.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;
	psl->size--;
	for (i = 0; i < psl->size;++i)
	{
		psl->array[i] = psl->array[i + 1];
	}
}

void SeqListPrint(SeqList* psl)//输出
{
	assert(psl);
	int i;
	for (i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->array[i]);
	}
	putchar('\n');
}

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)//删除含有x里面的数据
{
	int pos=SeqListFind(psl,x);
	if (pos >= 0)
	{
		SeqListErase(psl,pos);
	}
}
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)//将pos位置的数据替换为x
{
	assert(psl || pos < psl->size);

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

void SeqListBubbleSort(SeqList* 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)// 本题要求：时间复杂度：O(N) 空间复杂度 O(1)
{
	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 "slist.h"


void listtest()
{
	SList test;
	SListInit(&test);
	SListPushFront(&test, 1);
	SListPushFront(&test, 2);
	SListPushFront(&test, 4);
	SListPushFront(&test, 5);
	SListPushFront(&test, 6);
	SListPushFront(&test, 9);
	SListPrint(&test);
	SListPopFront(&test);
	SListPrint(&test);

	
	//SListDestory(&test);
}
/*int main()
{
	SeqList test;
	SeqListInit(&test, 10);
	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);

	SeqListInsert(&test, 1, 16);
	SeqListErase(&test, 2);
	SeqListRemove(&test, 16);
	SeqListModify(&test, 3, 10);

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

	SeqListPrint(&test);





	SeqListDestory(&test);
	system("pause");
	return 0;
}*/

int main()
{
	listtest();
	system("pause");
	return 0;
}