动态数组 系列操作实现——C语言（创建、插入、删除、排序、复制、唯一化）

最新推荐文章于 2024-07-12 21:58:44 发布
最新推荐文章于 2024-07-12 21:58:44 发布
阅读量3.5k 收藏 18
点赞数 2
分类专栏： C语言 文章标签： C语言 动态数组 归并排序 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxp189/article/details/88386962
版权

 

【实验目的】

实现动态数组的创建、元素插入、元素删除、数组复制、唯一化、排序（归并排序（自下而上）、选择排序）。

 

【实验内容】

  1. 实现一个元素类型为char的动态数组，动态数组的初始容量假设为3。
  2. 实现动态数组的创建与删除、元素插入、元素删除、动态素组的唯一化。
  3. 给出序列“CDACDDCECBAABCDCEBCB”的唯一化(Deduplication)结果。
  4. 可以基于读入某一文件中的字符串。（如：读取Test.txt文件）
  5. 实现归并排序。（自下而上归并排序）
  6. 实现选择排序。
  7. 实现不同元素出现次数的统计。

【实验要求】

  1. 将上述序列存入动态数组，给出最终动态数组的容量和规模。（请读者自行调整输出）
  2. 给出在存入上述序列的过程中动态数组调用扩容函数的次数。
  3. 计算并输出上述序列的唯一化序列。
  4. 对计算所得的归一化序列，选择排序。
  5. 对于外部文件中的大量字符排序（归并排序）。（如：对基因的排序）

（下面附上代码）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define inti_len 3	/*初始化数组长度（初始化长度为3）*/ 
#define dn_lim 0.25	/*下限百分比（若使用的数组长度小于总可用长度的25%，则总可用长度缩小为原来的1/2）*/ 
#define Default -1	/*插入函数、删除函数 中的参数；表示末尾*/ 

char* Create_arr (int len);
int Copy_arr (char* From_store,int len,int total_store_len,char** To_store);
int Insert_element (char** store,int* len_p,int total_store_len,char ch,int position);
int Del_element (char** store,int* len_p,int total_store_len,int position);
int Sort_arr (char* store,int now_store_len);  
int sort_2arrs(char* store_haed,int len1,char* store_tail,int len2); 
int merge_sort(char* store,int now_store_len);
int Unique_arr (char* store,int len,int total_store_len,char** store_unique);
int Frequency_conter (char* store,int now_store_len,int total_store_len);
void Free_arr(char* store);

int Expand_time = 0;//动态数组扩张次数 
int Shrink_time = 0;//动态数组收缩次数

/*	
author:YXP
e-mail:yxp189@protonmail.com
如有问题，欢迎和我联系~ 
*/

int main(int argc, char *argv[]) 
{
    Expand_time = 0;
	Shrink_time = 0;
	clock_t start, finish;//用于计时 
	int total_store_len = inti_len,now_store_len = 0;//总的可用储存空间，当前使用的长度 
	int new_len;
	char *STORE = "CDACDDCECBAABCDCECB";//待处理字符串 
	char* store = Create_arr (inti_len);
	
	
	int i;
/***** 动态读入元素 *****/
printf ("/***** 动态读入元素 *****/\n");
	while (STORE[i]!='\0'){
			total_store_len = Insert_element (&store,&now_store_len,total_store_len,STORE[i],Default);
			/*每次插入一个元素；Insert_element函数详解，见插入操作*/
			i++;
	}
	for (i=0;i<now_store_len;i++){
		printf (">>%c",store[i]);		
	}
	printf ("\n");


/****** 唯一化操作 ******/
printf ("/****** 唯一化操作 ******/\n");
	char* store_unique;
	int uni_len = Unique_arr (store,now_store_len,total_store_len,&store_unique);
	/*Unique_arr (数组*,现在使用的长度,可用空间总长,用于储存归一化结果的数组**);*/ 
	for (i=0;i<uni_len;i++){
		printf (">>%c",store_unique[i]);		
	}
	printf ("\n");

/******* 排序操作 ******///（选择排序）
printf ("/******* 选择排序 *******/\n");
	Sort_arr (store_unique,uni_len);
	for (i=0;i<uni_len;i++){
		printf (">>%c",store_unique[i]);		
	}
	printf ("\n");


/******* 插入操作 ******/
printf ("/******* 插入操作 ******/\n");
	total_store_len = Insert_element (&store,&now_store_len,total_store_len,'$',Default);
	/*Insert_element (数组**,现在使用的长度*,可用空间总长,待插入的字符,插入位置（Default表示末尾）);*/
	for (i=0;i<now_store_len;i++){
		printf (">>%c",store[i]);		
	}
	printf ("\n");			


/******* 删除操作 ******/
printf ("/******* 删除操作 ******/\n");	
	total_store_len = Del_element (&store,&now_store_len,total_store_len,0);//删除位置为0的元素 
	/*Del_element (数组**,现在使用的长度*,可用空间总长,待插入的字符,删除位置（Default表示末尾）);*/
	for (i=0;i<now_store_len;i++){
		printf (">>%c",store[i]);		
	}
	printf ("\n");
	
/******* 复制操作 ******/
printf ("/******* 复制操作 ******/\n");
	char* Copy_store;
	int new_total_store_len = Copy_arr (store,now_store_len,total_store_len,&Copy_store); 
	/*Del_element (数组*,现在使用的长度*,可用空间总长,拷贝到的数组*);*/ 
	for (i=0;i<new_total_store_len;i++){
		printf (">>%c",Copy_store[i]);		
	}
	printf ("\n");
	
/*** 数组当前操作次数 ***/
	printf (">>自动扩容%d次\t自动收缩%d次\n\n",Expand_time,Shrink_time);

/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
/*****************************************************/
/******* 对于文件处理+排序操作 ******///（选择/归并排序+计时）
	Expand_time = 0;
	Shrink_time = 0;
	char ch; 
    char* r_filename = "Test.txt";
	char* w_filename = "result.txt";
	FILE* fp_c,*fp_w,*fp_r =fopen(r_filename, "r");
        
/***** 动态读入元素 *****/
	printf (">>动态读入元素\n");
	start = clock();
	while ((ch = fgetc(fp_r)) != EOF){
			total_store_len = Insert_element (&store,&now_store_len,total_store_len,ch,Default);
			/*每次插入一个元素；Insert_element函数详解，见插入操作*/
			i++;
	}
	finish = clock();
	printf (">>读入扩容用时%lf\n",(double)(finish-start)/CLK_TCK);
	printf (">>自动扩容%d次\t自动收缩%d次\n\n",Expand_time,Shrink_time);
	fclose(fp_r);
	printf ("\n");
	
	fp_w = fopen(w_filename, "w"); 	
	
/******* 选择/归并排序 *******/	
	printf (">>开始排序\n");
	start = clock();
	//Sort_arr (store,now_store_len);//选择排序 
	merge_sort (store,now_store_len);//归并排序 
	finish = clock();
	printf (">>排序用时%lf\n",(double)(finish-start)/CLK_TCK);
	for (i=0;i<now_store_len;i++){
		fprintf (fp_w,"%c",store[i]);		
	}
	printf (">>排序完成！见文件result.txt!\n");
	fclose(fp_w);  

/*****************************************************/
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/

/*****元素出现次数统计*****/
Frequency_conter (store,now_store_len,total_store_len);

	return 0;
}



char* Create_arr (int len)/*创建一个指定大小的数组*/ 
{/*Create_arr (数组的长度)
	返回值 = 申请所得空间的地址*/ 
	char* store;
	store = (char*)malloc(sizeof(char)*len);
	return store; 
}


void Free_arr(char* store)/*用于创建一个指定大小的数组*/
{/*Free_arr(数组*)*/ 

	free(store);
}


int Copy_arr (char* From_store,int len,int total_store_len,char** To_store)/*用于数组复制*/ 
{/*Copy_arr (被拷贝数组*,被复制数组长度,可用空间总长n,拷贝所得数组**)
	返回值=拷贝所得数组大小；*/ 
 
	int new_total_store_len, i;
	if (len<total_store_len*0.25){
		new_total_store_len = (int)(len/2);
		*To_store = (char*)malloc(sizeof(char)*(new_total_store_len));
		for (i=0;i<len;i++){
			(*To_store)[i]=From_store[i];
		}
		Shrink_time++;
	}else{
		if ((len+1)>total_store_len){
			new_total_store_len = (len*2);
			*To_store = (char*)malloc(sizeof(char)*(new_total_store_len));
			for (i=0;i<len;i++){
				(*To_store)[i]=From_store[i];
			}
			Expand_time++;
		}else{
			new_total_store_len = len;
			*To_store = (char*)malloc(sizeof(char)*len);
			for (i=0;i<len;i++){
				(*To_store)[i]=From_store[i];
			}			
		} 
	}
	
	return new_total_store_len;
}


int Insert_element (char** store,int* len_p,int total_store_len,char ch,int position)/*用于在指定位置，插入指定元素*/ 
{/*	Insert_element (数组**,现在使用的长度*,可用空间总长,待插入的字符,插入位置（Default表示末尾）);
	返回当前 最大存储空间
	注意：position start from 0;
		if position = Default,则指末尾；*/ 

	if ((*len_p+1)>total_store_len){
		char* temp_store;
		total_store_len = Copy_arr (*store,*len_p,total_store_len,&temp_store);
		Free_arr(*store);
		*store = temp_store;
		if (position == Default){
			(*store)[*len_p] = ch;
			(*len_p)++;
		}else{
			int i;
			for (i = (*len_p)-1;i>=position;i--){
				(*store)[i+1] = (*store)[i];
			}
			(*store)[position] = ch;
			(*len_p)++;
		}	
	}else{
		if (position == Default){
			(*store)[*len_p] = ch;
			(*len_p)++;
		}else{
			int i;
			for (i = (*len_p)-1;i>=position;i--){
				(*store)[i+1] = (*store)[i];
			}
			(*store)[position] = ch;
			(*len_p)++;
		}
	}

	return total_store_len;
}


int Del_element (char** store,int* len_p,int total_store_len,int position)/*用于删除指定位置元素*/ 
{/*	Del_element (数组**,现在使用的长度*,可用空间总长,待插入的字符,删除位置（Default表示末尾）);
	返回当前 最大存储空间
	注意：position start from 0;
		if position = Default,则指末尾；*/ 

	int new_total_store_len;
	if ((*len_p-1)<(total_store_len*dn_lim)){
		char* temp_store;
		new_total_store_len = Copy_arr (*store,*len_p,total_store_len,&temp_store);
		Free_arr(*store);
		*store = temp_store;
		if (position == Default){
			(*len_p)--;
		}else{
			int i;
			for (i = position;i<(*len_p);i++){
				(*store)[i] = (*store)[i+1];
			}
			(*len_p)--;
		}	
	}else{
		new_total_store_len = total_store_len;
		if (position == Default){
			(*len_p)--;
		}else{
			int i;
			for (i = position;i<((*len_p)-1);i++){
				(*store)[i] = (*store)[i+1];
			}
			(*len_p)--;
		}
	}

	return new_total_store_len;
}


int Unique_arr (char* store,int len,int total_store_len,char** store_unique)
{/*Unique_arr (数组*,现在使用的长度,可用空间总长,用于储存归一化结果的数组**);
	返回值 = 归一化所得数组的长度*/ 
	int i,j,new_len = 0,flag;//flag:0未重复  1重复 
	*store_unique = (char*)malloc(len*sizeof(char));
	for (i=0;i<len;i++){
		
		for (j=0,flag=0;j<new_len;j++){
			if (store[i] == (*store_unique)[j]){
				flag = 1;
				goto AAA;
			}
		}
		AAA:;
		if (flag == 0){
			(*store_unique) [new_len] = store[i];
			new_len ++ ;
		}
	}
	
	char* temp_store;
	total_store_len = Copy_arr (*store_unique,new_len,total_store_len,&temp_store);
	Free_arr(*store_unique);
	*store_unique = temp_store;	
	
	return new_len;
}


int Sort_arr (char* store,int now_store_len)
{
	int i,j,min_e;
	char min ,temp = '\0';
	for (i=0;i<now_store_len;i++){
		min = store[i];
		for (j=i;j<now_store_len;j++){
			if (store[j]<=min){
				min_e = j; 
				min = store[j];
			}
		}
		temp = store[min_e];
		store[min_e] = store[i];
		store[i] = temp;
	}
	return 0;
}

 
int merge_sort(char* store,int now_store_len)//归并排序 
{
	int i, step = 1, sec_step = 0,thr_step = 0;
	for (;((step*3/2)<=now_store_len)||(step==1 );){
		for (i=0;i<now_store_len;){
			if (((i+2*step)<=now_store_len)&&((i+4*step)<now_store_len)){//小于两步 
				sort_2arrs(&(store[i]),step,&(store[i+step]),step);
				i=i + 2*step;
			}else{
				if ((i+4*step)>=now_store_len){
					sec_step = now_store_len-i-2*step;
					thr_step = now_store_len-i-step;
//					Sort_arr (&(store[i+step]),sec_step);
					sort_2arrs(&(store[i+step]),step,&(store[i+2*step]),sec_step);
					sort_2arrs(&(store[i]),step,&(store[i+step]),thr_step);
					i=now_store_len;
				}
			}	
		}
		step=step*2;
	}
	return 0;
}
 
 
int sort_2arrs(char* store_haed,int len1,char* store_tail,int len2)//两有序数组间排序
{
	int temp_now_store_len = len1+len2;
	char* temp_store = Create_arr (temp_now_store_len);
	char temp;
	int i;
	int k = 0,k1 = 0,k2 = 0;
	while ((k1!=(len1))||(k2!=(len2))){
		if (k1==len1){
			while ((k<temp_now_store_len)&&(k2 <len2)){
				temp_store[k++] = store_tail[k2++];
			}
		}
		if (k2==len2){
			while ((k<temp_now_store_len)&&(k1 <len1)){
				temp_store[k++] = store_haed[k1++];
			}
		}		
		while((store_haed[k1]<=store_tail[k2])&&(k1 <len1)){
			temp_store[k++] = store_haed[k1++];
		}
		while((store_haed[k1]>store_tail[k2])&&(k2 <len2)){
			temp_store[k++] = store_tail[k2++];
		}
	}
	
	for (i=0;i<len1;i++){
		store_haed[i] = temp_store[i];
	}
	for (i=0;i<len2;i++){
		store_tail[i] = temp_store[len1+i];
	}
	free (temp_store);
	return 0;
}


int Frequency_conter (char* store,int now_store_len,int total_store_len)
{
	char* store_unique;
	int new_len = Unique_arr (store,now_store_len,total_store_len,&store_unique);
	int *temp_counter= (int*)malloc(new_len*sizeof(int));
	int i,k;
	for (i=0;i<new_len;i++){
		temp_counter[i]=0;
	}
	for (i=0,k=0;i<now_store_len;i++){
		if (store[i]==store_unique[k]){
			temp_counter[k]++;
		}else{
			k++;
			temp_counter[k]++;
		}
	}
	for (i=0;i<new_len;i++){
		printf (">>%c = %d\n",store_unique[i],temp_counter[i]);
	}
	return 0;
}

 

yxp189
关注
专栏目录
对动态数组用 选择排序算法排序（C语言）
tunyue456的专栏
09-07 1104
#include #include #include void swap(int&,int&); void sort(int* ,int n); int main() {      int *array1 = 0, num, i;       printf("please input the number of element: ");       scanf("%d", &nu
动态数组排序
11-16 3299
一个好的算法往往依赖于一个合理的数据结构 在很多情况下排序问题是不知道排序数据的个数的，通常的做法是 （1）建立一个空间很大的数组，保证空间够用，但是这样会造成很大的浪费 （2）在知道数组个数的情况下可以用malloc函数来分配数组个数是个变量的情况，但是在个数未知时就不能实现了 （3）利用链表实现动态的数组，这样不管数组的长度是多少都可以进行存储和排序了 下面通过冒泡排序来理解一下动态
《C语言及程序设计》实践参考——动态数组排序
weixin_34088583的博客
05-02 316
返回：贺老师课程教学链接 【项目2-动态数组排序】编一个程序，输入某班某门课的成绩，进行排序后输出。成绩可能为小数。班级人数不定，要求采用动态数组完成。在下面代码基础上完成#include<stdio.h> #include<malloc.h> int main() { int count, i,j; ...
动态数组的理解及Java实现
最新发布
Working_ccll的博客
07-12 1540
动态数组是一种数据结构，它允许我们在运行期间添加或删除元素，而不必指定固定的大小。这是一种非常灵活的数据结构，因为它能够自动调整大小以适应数据的增减。动态数组是一种非常有用的数据结构，适用于需要在运行时动态添加或删除元素的情况。Java中的ArrayList类提供了方便的接口来操作动态数组。
7-3 L0802:动态数组排序
qq_51935763的博客
10-31 561
7-3 L0802:动态数组排序
动态数组排序实例
weixin_33748818的博客
05-08 453
要实现动态数组排序，需要将数据采用链表的形式存储。举例如下： package com.cn.datastruct; import java.io.IOException; import java.util.Scanner; //动态数组排序实例 public class DynamicArray { //链表结构 static class LinkList{ ...
c语言数组选择排序例题,C语言数组排序——冒泡排序、选择排序、插入排序
weixin_36071371的博客
05-21 1951
一、冒泡排序原理解析：(以从小到大排序为例)在一排数字中，将第一个与第二个比较大小，如果后面的数比前面的小，则交换他们的位置。然后比较第二、第三个……直到比较第n-1个和第n个，此时，每一次比较都将较大的一个数往后移动，所以第n个数是所有数中最大的一个。之后再重复以上过程，直到将所有数据按从小到大顺序排列好。编程实现：通过两个嵌套的循环实现。外层循环执行一次，内层循环执行一遍。其中，内层循环控制比...
插入排序 减治法——C语言代码
05-23
总的来说，"插入排序 减治法——C语言代码"是一个学习和实践C语言基础排序算法的好例子，通过阅读和理解这段代码，你可以深入理解插入排序的工作原理，以及如何用C语言来实现它。同时，也可以探讨如何将问题解决策略...
简单插入排序 递归法——C语言代码
05-22
在"简单插入排序 递归法——C语言代码"这个项目中，我们将看到如何使用C语言实现一个递归版本的插入排序。C语言是一种强大的、低级别的编程语言，常用于系统编程、嵌入式开发和高性能计算等领域。它的语法简洁明了，...
C语言——数组中的插入排序法！
正阳初六_的博客
07-19 3803
C语言——插入排序法！ C语言中有很多排序的方法，这次我先介绍一下插入排序法。
InsertionSort(插入排序)——C语言实现
ctz6d1p的博客
06-20 647
插入排序 InsertionSort
插入排序算法（动态数组实现）
04-04
插入排序算法（动态数组实现） printf("--------插入排序算法的实现--------\n"); printf("输入数组的大小length:\n"); int length=0; scanf("%d",&length); /****动态分配内存初始化数组***********************/ int * array = (int*)malloc(length * sizeof(int)); init(array,length); print_array(array,length); insert_sort(array,length); free(array);//释放动态数组空间
《C语言及程序设计》实践项目——动态数组 ->【项目2-动态数组排序】
七公子的博客
04-30 464
2017-04-30编一个程序，输入某班某门课的成绩，进行排序后输出。成绩可能为小数。班级人数不定，要求采用动态数组完成。//项目2-动态数组排序 #include<stdio.h> #include<malloc.h>//数组打印函数 void Print(float *x, int N) { int i, j; for(i=0, j=1; i<N; i++, j++) {
动态数组的创建、插入、按值删除、按位值删除、销毁（C语言实现）
qq_45164331的博客
09-03 1529
dynamic.h文件： #pragma once #include <stdlib.h> #include <string.h> #include <stdio.h> struct dynamicArray { void** paddr;//维护真实在堆区创建的数组的指针 int m_capamity;//数组容量 int m_size;//数组长度 }; struct dynamicArray* init_DynamicArray(int capamity)
数据结构(Java)之数组(2)-封装自己的数组并实现插入操作
粥粥的博客
06-17 249
使用数组的优点: 快速查找 数组应用场景: 最好应用与"索引有语义"的情况(身份证号不能作为索引,要开辟很大空间) 制作属于自己的数组类 class Array capacity: 容量-数组空间最多可以装多少元素 size: 数组中实际装多少元素 索引 public class Array { private int[] data; private int size;//data数组中有多少个元素 // 数组的容量capacity = data.length pu
L0802:动态数组排序
qq_52846711的博客
04-05 860
动态数组排序：运用动态内存分配函数malloc，创建一个整数类型（int）的动态数组，首先输入动态数组的元素个数，然后再依次输入每个元素，对数组所有元素按照从小到大的顺序排序，最后输入一个起始下标（默认从0开始），程序将依次输出从该下标开始直到动态数组中最后一个元素的全部整数。 输入格式: 10 2 1 6 4 5 3 7 8 10 9 3 输出格式: 按"%d "的形式输出结果，如：4 5 6 7 8 9 10 输入样例: 在这里依次输入数组元素总个数、每个元素和起始下标。例如： 10 2 1 6 4 5
使用数组实现数组元素的插入与删除
qq_42720695的博客
07-31 1605
使用数组编写尾插函数详解如下 使用数组在指定位置插入指定元素详解如下图 删除数组中指定位置的元素详解如下图 删除数组中指定的某个元素详解如下图 以上程序均为个人编写，有些地方可能并不完善，敬请谅解！...
Numpy 用于布尔型数组的方法 唯一化以及其他集合逻辑
略略略的博客
07-27 885
#7用于布尔型数组的方法----------------------- arr = np.random.randn(10) print arr print (arr>0).sum()#正值的数量 #any,和all方法对布尔型数组非常有用 any测试bool数组里面是否有true #all测试是否都是true #所有非零元素都可以当做true bools = np.array([True,Fals
动态数组的排序问题
weixin_44011791的博客
12-08 1799
输入一行数字，如果我们把这行数字中的‘5’都看成空格，那么就得到一行用空格分割的若干非负整数（可能有些整数以‘0’开头，这些头部的‘0’应该被忽略掉，除非这个整数就是由若干个‘0’组成的，这时这个整数就是0）。 你的任务是：对这些分割得到的整数，依从小到大的顺序排序输出。 #include "pch.h" #include &lt;iostream&gt; #include&lt;cstring&...
C语言编程：优化排序方法教程——数组操作详解
这种逐步调整的过程是基于某种排序算法，比如插入排序、冒泡排序或者选择排序，但具体实现未在提供的内容中明确给出。通常，每一步都是通过比较相邻元素并交换它们的位置来达到排序的目的。 改进后的程序可能是实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值