关闭

动态顺序表算法

标签: 动态顺序表算法
913人阅读 评论(0) 收藏 举报
分类:
#ifndef __SEQLIST_D_H__                          //条件编译
#define __SEQLIST_D_H__
#define _CRT_SECURE_NO_WARNINGS 1

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

#define INIT_SIZE  2
#define ADD_SIZE 3
typedef int DataType;

typedef struct Seqlist
{
	DataType *data;
	int size;                         //当前空间存储的元素个数
	int capacity;                     //当前空间所能存储的最大容量
}Seqlist,*pSeqlist;

void InitSeqlist(pSeqlist pSeq);
void DestorySeqlist(pSeqlist pSeq);
void PushBack(pSeqlist pSeq,DataType x);
void PopBack(pSeqlist pSeq);
void PushFront(pSeqlist pSeq,DataType x);
void PopFront(pSeqlist pSeq);
void Remove(pSeqlist pSeq,DataType x);
void RemoveAll(pSeqlist pSeq,DataType x);
void BubbleSort(pSeqlist pSeq);
void InsertSort(pSeqlist pSeq);
void SelectSort(pSeqlist pSeq);
int BinarySearch(pSeqlist pSeq,DataType x);
void  Erase(pSeqlist pSeq,int pos);
void PrintSeqlist(pSeqlist pSeq);

#endif             //SEQLIST_D_H__






#include"seqlist_d.h"

void InitSeqlist(pSeqlist pSeq)               
{
	pSeq->data = (DataType *)malloc(INIT_SIZE*sizeof(DataType));
	if (pSeq->data == NULL)
	{
		printf("out of memory\n");
		exit(1);
	}
	pSeq->size = 0;
	pSeq->capacity = INIT_SIZE;     //将容量置为当前空间所能存储的最大值
}

void DestorySeqlist(pSeqlist pSeq)
{
	free(pSeq->data);
	pSeq->data = NULL;
	pSeq->size = 0;
	pSeq->capacity = 0;
}

void CheckCapacity(pSeqlist pSeq)       //查看当前空间是否已满
{
	assert(pSeq);
	if (pSeq->size == pSeq->capacity)    //如果满了则进行扩容
	{
		DataType *tmp = NULL;                        
		//扩容,注意这时capacity也发生了变化
		tmp = (DataType *)realloc(pSeq->data, (pSeq->capacity += ADD_SIZE)*sizeof(DataType));
		if (NULL == tmp)
		{
			printf("out of memory\n");
			exit(1);
		}
		pSeq->data = tmp;
	}
}

void PushBack(pSeqlist pSeq, DataType x)
{
	assert(pSeq);
	CheckCapacity(pSeq);                  //只要插入元素,首先就要检查空间是否以满
	pSeq->data[pSeq->size++] = x;         //插入元素后size也要变化
}

void PopBack(pSeqlist pSeq)
{
	assert(pSeq);
	if (pSeq->size == 0)                   //异常情况,表已空
	{
		printf("表已空\n");
		return;
	}
	pSeq->size--;
}

void PushFront(pSeqlist pSeq, DataType x)
{
	assert(pSeq);
	CheckCapacity(pSeq);            //只要插入元素,首先就要检查空间是否以满
	int i = 0;
	for (i = pSeq->size; i > 0; i--)   //从后往前先将数据移动
	{
		pSeq->data[i] = pSeq->data[i-1];
	}
	pSeq->data[0] = x;
	pSeq->size++;
}

void PopFront(pSeqlist pSeq)
{
	assert(pSeq);
	int i = 0;
	if (pSeq->size == 0)                     //异常情况,表空
	{
		printf("表已空\n");
		return;
	}
	for (i = 0; i < pSeq->size-1; i++)        //直接从第二个元素依次向前覆盖
	{
		pSeq->data[i] = pSeq->data[i + 1];
	}
	pSeq->size--;
}

void Remove(pSeqlist pSeq, DataType x)       //删除第一个出现的x
{
	assert(pSeq);
	int i = 0;
	int j = 0;
	for (i = 0; i < pSeq->size; i++)
	{
		if (pSeq->data[i] == x)
		{
			for (j = i; j < pSeq->size-1; j++)      //删除的时候从这个元素的后面向前覆盖
			{
				pSeq->data[j] = pSeq->data[j + 1];
			}
			pSeq->size--;
			return;
		}
	}
}

void RemoveAll(pSeqlist pSeq, DataType x)
{
	assert(pSeq);
	int i = 0;
	int j = 0;
	for (i = 0; i < pSeq->size; i++)
	{
		if (pSeq->data[i] == x)
		{
			for (j = i; j < pSeq->size - 1; j++)      //删除的时候从这个元素的后面向前覆盖
			{
				pSeq->data[j] = pSeq->data[j + 1];
			}
			pSeq->size--;
		}
	}
}

void BubbleSort(pSeqlist pSeq)
{
	assert(pSeq);
	int flag = 0;
	int i = 0;
	int j = 0;
	int k = pSeq->size-1;
	for (i = 0; i < pSeq->size - 1; i--)
	{
		int m = 0;
		flag = 1;                               //将标记置1
		for (j = 0; j < k; j++)
		{
			if (pSeq->data[j]>pSeq->data[j + 1])
			{
				DataType tmp = pSeq->data[j];
				pSeq->data[j] = pSeq->data[j + 1];
				pSeq->data[j + 1] = tmp;
				flag = 0;
				m = j;                           //记录最后一次交换的位置
			}
		}
		if (flag)               //标记位1表示已经有序
		{
			return;
		}
		m = k;                  //将k设置成最后一次交换的位置
	}
}

void InsertSort(pSeqlist pSeq)                //插入排序
{
	assert(pSeq);
	int i = 0;
	int j = 0;
	for (i = 1; i < pSeq->size; i++)
	{
		DataType tmp = pSeq->data[i];
		for (j = i-1; j >=0; j--)
		{
			if (pSeq->data[j]>tmp)              //从有序区倒着查找一个位置,使的tmp大于这个位置的元素
			{
				pSeq->data[j+1] = pSeq->data[j];
			}
			else
			{
				break;
			}
		}
		pSeq->data[j+1] = tmp;                 //将tmp进行插入
	}
}

void SelectSort(pSeqlist pSeq)
{
	assert(pSeq);
	int i = 0;
	int j = 0;
	int k = 0;
	for (i = 0; i < pSeq->size; i++)
	{
		k = i;
		for (j = i + 1; j < pSeq->size; j++)
		{
			if (pSeq->data[k]>pSeq->data[j])
			{
				k = j;                                 //记录无无序区中最小元素的下标
			}
		}
		if (k != i)        //当找到的元素不是有序区的最后一个元素时,再进行交换
		{
			DataType tmp = pSeq->data[k];
			pSeq->data[k] = pSeq->data[i];
			pSeq->data[i] = tmp;
		}
	}
}

int BinarySearch(pSeqlist pSeq, DataType x)
{
	assert(pSeq);
	int left = 0;
	int right = pSeq->size - 1;
	int mid = (left&right) + ((left^right) >> 1);  //求平均值
	while (left <= right)
	{
		if (pSeq->data[mid]>x)
		{
			right = mid - 1;
		}
		else if (pSeq->data[mid] < x)
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

void  Erase(pSeqlist pSeq, int pos)
{
	assert(pSeq);
	int i = 0; 
	if (pos>= pSeq->size&&pos < 0)            //异常情况
	{
		printf("删除位置不合法\n");
		return;
	}
	for (i = pos; i < pSeq->size - 1; i++)      //从pos之后依次向前覆盖
	{
		pSeq->data[i] = pSeq->data[i + 1];
	}
	pSeq->size--;
}

void PrintSeqlist(pSeqlist pSeq)
{
	assert(pSeq);
	int i = 0;
	if (pSeq->size == 0)
	{
		printf("表为空\n");
		return;
	}
	for (i = 0; i < pSeq->size; i++)
	{
		printf("%d ", pSeq->data[i]);
	}
	printf("\n");
}





#include"seqlist_d.h"

void menu()
{
	printf("*********************************\n");
	printf("0.exit            1.PrintSeqlist \n");
	printf("2.InitSeqlist     3.PushBack     \n");
	printf("4.Popback         5.PushFornt    \n");
	printf("6.PopFornt        7.Erase        \n");
	printf("8.Remove          9.RemoveAll    \n");
	printf("10.BubbleSort     11.BinarySearch\n");
	printf("12.DestorySeqlist 13.InsertSort  \n");
	printf("14.SelectSort           \n");
	printf("请输入:>");
}


void test(pSeqlist pSeq)
{
	DataType x = 0;
	int n = 0;
	int pos = 0;
	while (1)
	{
		menu();
		scanf("%d", &n);
		switch (n)
		{
		case 0:
			exit(1);
			break;
		case 1:
			PrintSeqlist(pSeq);
			break;
		case 2:
			InitSeqlist(pSeq);
			break;
		case 3:
			printf("请输入元素\n");
			scanf("%d", &x);
			PushBack(pSeq, x);
			break;
		case 4:
			PopBack(pSeq);
			break;
		case 5:
			printf("请输入元素\n");
			scanf("%d", &x);
			PushFront(pSeq, x);
			break;
		case 6:
			PopFront(pSeq);
			break;
		case 7:
			printf("请输入删除位置\n");
			scanf("%d", &pos);
			Erase(pSeq, pos);
			break;
		case 8:
			printf("请输入元素\n");
			scanf("%d", &x);
			Remove(pSeq, x);
			break;
		case 9:
			printf("请输入元素\n");
			scanf("%d", &x);
			RemoveAll(pSeq, x);
			break;
		case 10:
			BubbleSort(pSeq);
			break;
		case 11:
			printf("请输入元素\n");
			scanf("%d", &x);
			int ret=BinarySearch(pSeq, x);
			if (ret == -1)
				printf("没有这个元素\n");
			printf("下标为:%d\n", ret);
			break;
		case 12:
			DestorySeqlist(pSeq);
			break;
		case 13:
			InsertSort(pSeq);
			break;
		case 14:
			SelectSort(pSeq);
			break;
		default:
			printf("输入无效\n");
			break;
		}
	}
}



int main()
{
	Seqlist pSeq;
	test(&pSeq);
	system("pause");
	return 0;
}

2
0
查看评论

静态顺序表和动态顺序表 对比

静态顺序表的缺陷:静态顺序表显然就是里面的内存是一定的,不能改变的,所以定义的时候可以定义一个宏,然后定义一个数组,这样就可以在数组中存储信息,而且,还可以随时改变数组的大小。typedef int DataType; #define MaxSize 10typedef struct SeqList...
  • jhcconan614
  • jhcconan614
  • 2016-12-30 23:13
  • 179

【C语言】静态顺序表和动态顺序表的实现

C语言
  • SuLiJuan66
  • SuLiJuan66
  • 2015-06-29 19:31
  • 1516

数据结构—动态顺序表的实现

前面我们实现了顺序表,但是我们应该会考虑到一个问题,顺序表一次性创建那么大空间造成的浪费很多,所以在这里,我们需要一个可以动态增长的顺序表来满足我们的需求!实现中需要注意的是:在这里我们要注意的是首先你应该给顺序表一个容量,当每次满了的时候,进行扩容!另外,在这里我分别使用了三种的排序算法:插入排序...
  • qq_26768741
  • qq_26768741
  • 2016-06-01 19:05
  • 2869

顺序表(动态分配空间)

嗯,开始写写数据结构了。 不过,一直有个疑问,就是malloc分配空间,逻辑上是连续的,不知道物理空间是不是连续的;是否有大神帮着解答一下,不胜感谢!! #include "stdlib.h" #define MAXSIZE 30 #define INCREMENT 10 #d...
  • u012829552
  • u012829552
  • 2014-01-03 15:04
  • 574

妙趣横生的算法(1.1)动态创建顺序表

/* 编写一个程序,动态的创建一个顺序表。要求:顺序表初始长度为10,向顺序表中输入 15个整数,并打印出来: */ #include #include #include #define MaxSize 10 typedef int Integer; typedef struct {...
  • tc1hen
  • tc1hen
  • 2013-10-02 13:04
  • 1402

C语言实现动态顺序表

1、用于存放声明的头文件#pragma once //避免重复引入头文件,作用于预编译指令几乎相同#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <assert.h> #include <ma...
  • ljx_5489464
  • ljx_5489464
  • 2016-03-14 13:33
  • 986

简单c之实现顺序表的以下接口

1、实现动态顺序表的以下接口 SeqListD.h #include #include #include typedef int DataType; typedef struct SeqListD { DataType* array; size_t ...
  • someday1314
  • someday1314
  • 2017-03-03 23:10
  • 161

c语言动态顺序表的实现

动态顺序表是在静态顺序表的基础上优化更改的 1.其中将静态顺序表中的数组数据类型改成了指针类型方便内存的开辟 2.多增加了一个容量的变量来表示顺序表的容量 3.初始化的时候需要给*data动态开辟空间 4.多增加的函数有1.增容函数  2.减容函数  3.空间销毁函数(因为mal...
  • IT_iverson
  • IT_iverson
  • 2017-07-28 12:01
  • 301

动态顺序表

//seqlist.h #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #define CAPACITY 3 typedef struct { int *array; int size; int capacity; }Seqlist; typedef...
  • ZDF0414
  • ZDF0414
  • 2015-06-25 19:18
  • 255

C语言 顺序表的实现 (动态)

上一篇博客写了顺序表的静态实现,即指定大小的顺序表,这篇则给出动态实现的顺序表,即可以改变大小的顺序表。 给出顺序表的定义: typedef int DataType; typedef struct SeqListD { DataType *array; int size;// 记录有效元素的个...
  • xy913741894
  • xy913741894
  • 2016-09-11 15:19
  • 696
    博客专栏
    文章分类
    最新评论