顺序表

1.seqlist.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int data;
typedef struct Seqlist
{
	data* array;//顺序表中存的值
	size_t size;//有效个数
	size_t capacity;//容量
}Seqlist;

void Seqlist_Int(Seqlist* pcb,size_t capacity);//初始化
void Seqlist_Destroy(Seqlist* pcb);//销毁
void enlarge_Seqlist(Seqlist* pcb);//判断capacity足够，否则增容
void Seqlist_Print(Seqlist* pcb);//打印

void tail_insert(Seqlist* pcb, data value);//尾插
void tail_Delete(Seqlist* pcb);//尾删
void head_insert(Seqlist* pcb, data value);//头插
void head_delete(Seqlist* pcb);//头删
void random_insert(Seqlist* pcb, size_t num, data value);//随机插入
void random_delete(Seqlist* pcb, size_t num);//随机删除
int seqlist_find(Seqlist* pcb, data value);//查找某一个值
void seqlist_alter(Seqlist* pcb, size_t num, data value);//修改
void seqlist_bubblesort(Seqlist* pcb);//冒泡排序
void seqlist_binaryfind(Seqlist* pcb);//二分查找
void seqlist_remove(Seqlist* pcb,data value);//删除重复数字中的第一个数
void seqlist_remove_All(Seqlist* pcb, data value);//删除所有重复数字

2.seqlist.c

#include"seqlist.h"
void Seqlist_Int(Seqlist* pcb, size_t capacity)
{
	assert(pcb);
	pcb->array = (data*)malloc(sizeof(data)*capacity);
	if (pcb->array == NULL)
	{
		printf("malloc error");
		exit(-1);
	}
	pcb->size = 0;
	pcb->capacity = 8;
}
void Seqlist_Destroy(Seqlist* pcb)
{
	assert(pcb);
	free(pcb->array);
	pcb->array = NULL;
}
void enlarge_Seqlist(Seqlist* pcb)
{
	assert(pcb);
	if (pcb->size < pcb->capacity) //有效个数小于容量，不扩容
	{
		return;
	}
	else if (pcb->size == pcb->capacity)//有效个数等于容量，扩容，大小为原容量的N倍
	{
		int newcapacity = (pcb->capacity) * 2;
		data* newarray = (data*)realloc(pcb->array, sizeof(int)*newcapacity);
		if (newarray == NULL)
		{
			printf("realloc error");
		}
		 free(pcb->array);//搬完后，释放原来的.
		//特别注意：因为上面用到了realloc,realloc扩容完毕后自动释放原来原来的空间，所以不能再free(pcb->array)。
		pcb->array = NULL;
		pcb->array = newarray;
		pcb->capacity = newcapacity;
	}
}
void tail_insert(Seqlist* pcb, data value)
{
	assert(pcb);
	enlarge_Seqlist(pcb);//在进行插入数据时，一定要进行判断扩容
	pcb->array[pcb->size] = value;
	pcb->size++;
}
void Seqlist_Print(Seqlist* pcb)
{
	assert(pcb);
	for (size_t i = 0; i < pcb->size; i++)
	{
		printf("%d ", pcb->array[i]);
	}
}
void tail_Delete(Seqlist* pcb)
{
	assert(pcb);
	pcb->size--;
}
void head_insert(Seqlist* pcb, data value)
{
	assert(pcb);
	enlarge_Seqlist(pcb);//在进行插入数据时，一定要进行判断扩容
	if (pcb->size == 0)//当有效个数为 0 时
	{
		pcb->array[pcb->size] = value;
	}
	else//当有效个数不为 0 时
	{
		size_t num = pcb->size;
		while (num)
	{
		 pcb->array[num] = pcb->array[num - 1];
		 --num;
	}
		pcb->array[num] = value;
	}
		pcb->size++;
}
void head_delete(Seqlist* pcb)
{
	assert(pcb);
	if (pcb->size == 0)
	{
		return;
	}
	else
	{
		for (size_t i = 0; i < pcb->size; i++)
	 {
		  pcb->array[i] = pcb->array[i + 1];
	 }
	}
	pcb->size--;
}
int seqlist_find(Seqlist* pcb, data value)
{
	assert(pcb);
	for (size_t i = 0; i < pcb->size; i++)
	{
		if (pcb->array[i] == value)
		{
			return 1;
		}
	}
	return -1;
}
void random_insert(Seqlist* pcb, size_t num, int value)
{
	assert(pcb);
	enlarge_Seqlist(pcb);//在进行插入数据时，一定要进行判断扩容
	if (num > pcb->size || num < 0)
	{
		printf("所输入的位置越界，随机插入失败！\n");
		return;
	}
	else
	{
		for (size_t i = pcb->size; i > num ; i--)
		{
			pcb->array[i] = pcb->array[i - 1];
		}
		pcb->array[num] = value;
		pcb->size++;
	}
}
void random_delete(Seqlist* pcb, size_t num)
{
	assert(pcb);
	if (pcb->size == 0)
	{
		return;
	}
	else
	{
		for (size_t i = num; i < pcb->size; i++)
		{
			pcb->array[i - 1] = pcb->array[i];
		}
		pcb->size--;
	}
}
void seqlist_alter(Seqlist* pcb, size_t num, data value)
{
	assert(pcb);
	if (num > pcb->size || num < 0)
	{
		printf("所输入的位置越界，导致修改失败！\n");
		return;
	}
	else
	{
		pcb->array[num - 1] = value;
	}
}
void seqlist_bubblesort(Seqlist* pcb)
{
	assert(pcb);
	int i = 0;
	int j = 0;
	for (j = 0; j <= pcb->size- 1; j++)
	{
		for (i = 0; i < pcb->size - 1 - j; i++)
		{
			if (pcb->array[i]>pcb->array[i+1])
			{
				int tmp = pcb->array[i];
				pcb->array[i] = pcb->array[i + 1];
				pcb->array[i + 1] = tmp;
			}
		}
	}
}
void seqlist_binaryfind(Seqlist* pcb, data value)
{
	int left = 0;
	int right = pcb->size - 1;
	int mid = 0;
	int flag = 0;
	while (left <= right)
    //如果是(left <= right)，下面right = mid-1;
	//如果是(left < right)，下面right = mid;
	{
		int mid = left + (right - left) / 2;
		if (value > pcb->array[mid])
		{
			left = mid + 1;
		}
		else if(value < pcb->array[mid])
		{
			right = mid - 1;
		}
		else if (pcb->array[mid] == value)
	   {
		   flag = 1;
		   printf("\n");
	 	   printf("找到了，下标是%d\n", mid);
		   break;
	   }
    }
	if (flag == 0)
	{
		printf("\n");
		printf("未找到所给值\n");
	}	
}
void seqlist_remove(Seqlist* pcb, data value)
{
	assert(pcb);
	if (pcb->size == 0)
	{
		return;
	}
	for (int i = 0; i < pcb->size - 1; i++)
	{
		if (pcb->array[i] == value)
		{
			for (int j = i; j < pcb->size; j++)
			{
				pcb->array[j] = pcb->array[j+1];
			}
			pcb->size--;
			return;
		}
	}
}
void seqlist_remove_All(Seqlist* pcb, data value)
{
	assert(pcb);
	if (pcb->size == 0)
	{
		return;
	}
	for (int i = 0; i < pcb->size - 1; i++)
	{
		if (pcb->array[i] == value)
		{
			for (int j = i; j < pcb->size; j++)
			{
				pcb->array[j] = pcb->array[j + 1];
			}
			pcb->size--;
			//return;
		}
	}
}

 

3.test.c

#include"seqlist.h"
int main()
{
	Seqlist cb;
	Seqlist_Int(&cb,8);
	//Seqlist_Destroy(&cb);
	enlarge_Seqlist(&cb);

	tail_insert(&cb,1);
	tail_insert(&cb,2);
	tail_insert(&cb,3);
	tail_insert(&cb,2);
	tail_insert(&cb,4);
	tail_insert(&cb,2);
	tail_insert(&cb,5);
    /*tail_Delete(&cb);*/
	//head_insert(&cb,20);
	//head_delete(&cb);
	//head_delete(&cb);	

	//printf("%d\n",seqlist_find(&cb, 15));

	//random_insert(&cb, 3, 8);
	//random_delete(&cb,3);
	//seqlist_alter(&cb, 3, 8);
	//seqlist_bubblesort(&cb);
	//seqlist_remove(&cb,2);
	seqlist_remove_All(&cb, 2);
	Seqlist_Print(&cb);
	//seqlist_binaryfind(&cb, 1);
	//seqlist_binaryfind(&cb, 2);
	//seqlist_binaryfind(&cb, 3);
	//seqlist_binaryfind(&cb, 4);
	//seqlist_binaryfind(&cb, 77);
	//seqlist_binaryfind(&cb, 5);

	Seqlist_Destroy(&cb);
	system("pause");
	return 0;
}