动态顺序表

原创 2016年06月01日 13:32:35

一、动态顺序表:

       动态顺序表也是顺序表,不过它是动态的,也就是说它的容量是可以改变的,这就克服了静态顺序表容量不能改变的缺点。当顺序表的容量存满以后,我们可以对它进行扩容,概念就简单介绍到这里了。

二、动态顺序表的数据结构:

<span style="font-size:18px;">typedef struct SeqList_D
{
	DataType* array;          //指向数据块的指针
	size_t size;              //当前数据数
	size_t capacity;          //总容量
}SeqList_D;</span>


      与静态顺序表不同,因为它的大小要发生改变,所以我们不能用数组,而要使用指针,然后动态开辟内存空间。我们同时需要记住当前存储的数据个数和动态顺序表的总容量。下面解释一下当前存储的数据个数size与顺序表总容量capacity的区别吧,如下图:

       我们开辟了一个10个元素大小的空间,但是空间里面只存储了5个数据,这时的存储数据个数size=5,总容量capacity = 10,为什么要记录他们两个呢?因为我们在操作动态顺序表的时候会用到呀,就比如插入元素的时候你应该把它放在前面那个元素的后面,所以你要知道你已经存了多少个数据,你才能知道你要把这个数据存放的位置,怎么判断你的空间存满呢,你也得知道你的容量呀,是吧。所以,以上三个成员都需要。

三、代码实现:(环境:vs2010       语言:c语言 )

      讲完了思想,就要来看看代码了,下面基本实现了动态顺序表的一部分内容。

1.声明文件SeqList_D.h

#ifndef __SEQLIST_D_H__
#define __SEQLIST_D_H__

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

typedef int DataType;

typedef struct SeqList_D
{
	DataType* data;    //存储数据
	size_t size;       //已存数据个数
	size_t capacity;   //容量
}Seq, *pSeq;

void InitSeqList(pSeq pseq);
void Destroy(pSeq pseq);
void PrintSeqList(const pSeq pseq);
void PushBack(pSeq pseq, DataType x);
void PopBack(pSeq pseq);
void PushFront(pSeq pseq, DataType x);
void PopFront(pSeq pseq);
void Remove(pSeq pseq, DataType x);
void RemoveAll(pSeq pseq, DataType x);
void BubbleSort(pSeq pseq);
void InsertSort(pSeq pseq);
void SelectSort(pSeq pseq);

#endif


 

2.功能实现SeqList_D.c

#include "SeqList_D.h"
#define INIT_VALUE 3

void InitSeqList(pSeq pseq)                  //动态顺序表的初始化                                                                  {
	assert(pseq);
	pseq->data = (DataType *)malloc(INIT_VALUE * sizeof(DataType));
	pseq->size = 0;
	pseq->capacity = INIT_VALUE;
}

void Destroy(pSeq pseq)
{
	assert(pseq);
	if(pseq->data != NULL)
	{
		free(pseq->data);
		pseq->data = NULL;
	}
	pseq->size = 0;
	pseq->capacity = 0;
}

void PrintSeqList(const pSeq pseq)
{
	size_t i = 0;
	assert(pseq);
	for(i = 0; i < pseq->size; i++)
	{
		printf("%d ",pseq->data[i]);
	}
	printf("\n");
}
void CheckCapacity(pSeq pseq)
{
	assert(pseq);
	if(pseq->size == pseq->capacity)
	{
		DataType *tmp = (DataType* )realloc(pseq->data,
						(pseq->capacity*2+1)*sizeof(DataType));
		if(tmp == NULL)
		{
			printf("out of memeory\n");
			exit(0);
		}
		pseq->data = tmp;
		pseq->capacity = pseq->capacity*2+1;
	}
	
}
void PushBack(pSeq pseq, DataType x)
{
	assert(pseq);
	CheckCapacity(pseq);
	pseq->data[pseq->size] = x;
	pseq->size++;
}
void PopBack(pSeq pseq)
{
	assert(pseq);
	if(pseq->size == 0)
	{
		printf("SeqList is Empty\n");
		return;
	}
	pseq->size--;
}
void PushFront(pSeq pseq, DataType x)
{
	int i;
	assert(pseq);
	CheckCapacity(pseq);
	for(i = pseq->size-1; i >= 0; i--)
	{
		pseq->data[i+1] = pseq->data[i];
	}
	pseq->data[0] = x;
	pseq->size++;
}
void PopFront(pSeq pseq)
{
	int i = 0;
	assert(pseq);
	if(pseq->size == 0)
	{
		printf("SeqList is Empty");
		return;
	}
	for(i = 0; i < pseq->size-1; i++)
	{
		pseq->data[i] = pseq->data[i+1];
	}
	pseq->size--;
}
void Remove(pSeq pseq, DataType x)
{
	int i = 0;
	assert(pseq);
	for(i = 0; i < pseq->size; i++)
	{
		if(pseq->data[i] == x)
		{
			break;
		}
	}
	if(i == pseq->size)
	{
		printf("no find\n");
		return;
	}
	for( ;i < pseq->size-1; i++)
	{
		pseq->data[i] = pseq->data[i+1];
	}
	pseq->size--;

}
void RemoveAll(pSeq pseq, DataType x)
{
	int count = 0;
	int i = 0;
	for(i = 0; i<pseq->size; i++)
	{
		if(pseq->data[i] == x)
		{
			count++;
			continue;
		}
		if(count != 0)
		{
			pseq->data[i-count] = pseq->data[i];
		}
	}
	if(count == 0)
	{
		printf("no find \n");
		return;
	}
	pseq->size -= count;
}

void BubbleSort(pSeq pseq)
{
	int i = 0;
	int j = 0;
	int flag1 = 0;
	int k = pseq->size-1;
	assert(pseq);
	for(i = 0; i < pseq->size-1; i++)
	{
		int flag2 = 0;
		flag1 = 0;
		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;
				flag1 = 1;
				flag2 = j;
			}
		}
		k = flag2;
		if(flag1 == 0)
		{
			return;
		}
	}
}

void InsertSort(pSeq pseq)
{
	int i = 0;
	assert(pseq);
	for(i = 1; i < pseq->size; i++)
	{
		if(pseq->data[i-1] > pseq->data[i])
		{
			int j = 0;
			int tmp = pseq->data[i];
			for(j = i-1; (j>=0)&&(tmp<pseq->data[j]); j--)
			{
				pseq->data[j+1] = pseq->data[j];
			}
			pseq->data[j+1] = tmp;
		}
	}
}

void SelectSort(pSeq pseq)
{
	int i = 0;
	int min = 0;
	assert(pseq);
	for(i = 0; i < pseq->size-1; i++)
	{
		int j = 0;
		DataType tmp;
		min = i;
		for(j = i+1; j < pseq->size; j++)
		{
			if(pseq->data[j] < pseq->data[min])
				min = j;
		}
	    tmp = pseq->data[i];
		pseq->data[i] = pseq->data[min];
		pseq->data[min] = tmp;
	}
}


3.测试文件:

#include "SeqList_D.h"

void Test1()
{
	Seq seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 5);

	PopBack(&seq);
	PopBack(&seq);

	PrintSeqList(&seq);
}
void Test2()
{
	Seq seq;
	InitSeqList(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PushFront(&seq, 5);

	PopFront(&seq);
	PopFront(&seq);
	PopFront(&seq);
	PopFront(&seq);
//	PopFront(&seq);
//	PopFront(&seq);

	PrintSeqList(&seq);
}

void Test3()
{
	Seq seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 5);
	PushBack(&seq, 2);
	PushBack(&seq, 5);
	PushBack(&seq, 3);
	PushBack(&seq, 4);
	PushBack(&seq, 5);
    
//	Remove(&seq, 5);
//	Remove(&seq, 6);
//	RemoveAll(&seq, 5);
	RemoveAll(&seq, 6);
	PrintSeqList(&seq);
}

void Test4()
{
	Seq seq;
	InitSeqList(&seq);
	PushBack(&seq, 10);
	PushBack(&seq, 5);
	PushBack(&seq, 2);
	PushBack(&seq, 5);
	PushBack(&seq, 3);
	PushBack(&seq, 10);
	PushBack(&seq, 5);
	PushBack(&seq, 6);
	PushBack(&seq, 8);
	PushBack(&seq, 7);
	PushBack(&seq, 9);
	PushBack(&seq, 1);

	PrintSeqList(&seq);
//	BubbleSort(&seq);
	InsertSort(&seq);
//	SelectSort(&seq);
	PrintSeqList(&seq);

}
int main()
{
	//Test1();
	//Test2();
	//Test3();
	Test4();
	system("pause");
	return 0;
}


 

好啦,代码也写完啦,动态顺序表的讲解到这里就结束了,谢谢阅读,文章属本人编写,若有错误,欢迎指出哦!!

版权声明:本文为博主原创文章,未经博主允许不得转载。

动态顺序表

  • 2012年12月10日 22:12
  • 7KB
  • 下载

动态分配的顺序线性表的十五种操作—C语言实现

线性表 定义:是最常用的,也是最简单的数据结构,是长度为n个数据元素的有序的序列。 含有大量记录的线性表叫文件 记录:稍微复杂的线性表里,数据元素为若干个数据项组成,这时把一个数据元...

线性表之顺序存储结构(C语言动态数组实现)

线性表的定义:N个数据元素的有限序列 线性表从存储结构上分为:顺序存储结构(数组)和 链式存储结构(链表) 顺序存储结构:是用一段连续的内存空间存储表中的数据 L=(a1,a2,a3....an) ...
  • xyang81
  • xyang81
  • 2014年05月16日 00:17
  • 2909

顺序表 结构体的动态数组实现

  • 2011年08月19日 12:49
  • 2KB
  • 下载

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

上一篇博客写了顺序表的静态实现,即指定大小的顺序表,这篇则给出动态实现的顺序表,即可以改变大小的顺序表。 给出顺序表的定义: typedef int DataType; typedef struct ...

顺序表应用8:最大子段和之动态规划法

Problem Description  给定n(1负数时定义子段和为0,依此定义,所求的最优值为: Max{0,a[i]+a[i+1]+…+a[j]},1   注意:本题目要求用动态规划法...

C语言实现动态顺序表

1、用于存放声明的头文件#pragma once //避免重复引入头文件,作用于预编译指令几乎相同#define _CRT_SECURE_NO_WARNINGS 1 #include #inclu...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:动态顺序表
举报原因:
原因补充:

(最多只允许输入30个字)