程序设计进阶——C语言（翁凯版）第四周

Ccjf酷儿

已于 2024-02-04 18:44:09 修改

阅读量225

点赞数 10

文章标签： c语言算法数据结构

于 2024-02-04 15:31:45 首次发布

本文链接：https://blog.csdn.net/qq_44845100/article/details/136005419

版权

4.1 链表

4.1.1 可变数组

可变数组

考虑一组提供可调整大小的数组机制的函数；
可生长的；
获取当前大小；
对元素的访问；

接口

Array array_create(int init_size);
void array_free(Array *a);
int array_size(const Array *a);
int* array_at(Array *a,int index);
void array_inflate(Array *a,int more_size);

头文件如下

#ifndef _ARRAY_H_
#define _ARRAY_H_

typedef struct{
	int *array;
	int size;
}Array; 

Array array_create(int init_size);
void array_free(Array *a);
int array_size(const Array *a);
int* array_at(Array *a,int index);
void array_inflate(Array *a,int more_size);

#endif

c代码如下

#include "array.h"
#include <stdio.h>
#include <stdlib.h>
//typedef struct{
//	int *array;
//	int size;
//}Array; 

Array array_create(int init_size)
{
	Array a;
	a.size=init_size;
	a.array=(int*)malloc(sizeof(int)*a.size);
	return a;
}
void array_free(Array *a)
{
	free(a->array);
	a->array=NULL;
	a->size=0;
}
//int array_size(const Array *a);
//int* array_at(Array *a,int index);
//void array_inflate(Array *a,int more_size);

int main()
{
	Array a=array_create(100);
	return 0;
}

4.1.2 可变数组的数组访问

#include "array.h"
#include <stdio.h>
#include <stdlib.h>
//typedef struct{
//	int *array;
//	int size;
//}Array; 

Array array_create(int init_size)
{
	Array a;
	a.size=init_size;
	a.array=(int*)malloc(sizeof(int)*a.size);
	return a;
}
void array_free(Array *a)
{
	free(a->array);
	a->array=NULL;
	a->size=0;
}

//封装 
int array_size(const Array *a)
{
	return a->size;
}
int* array_at(Array *a,int index)
{
	return &(a->array[index]); 
}

int array_get(const Array *a,int index)
{
	return a->array[index];
}

void array_set(Array *a,int index,int value)
{
	a->array[index]=value;
}

//void array_inflate(Array *a,int more_size);

int main()
{
	Array a=array_create(100);
	printf("%d\n",array_size(&a));
	*array_at(&a,0)=10;
	printf("%d\n",*array_at(&a,0));
	array_free(&a);
	return 0;
}

输出

100
10

4.1.3 可变数组的自动增长

#include "array.h"
#include <stdio.h>
#include <stdlib.h>
//typedef struct{
//	int *array;
//	int size;
//}Array; 

const BLOCK_SIZE=20;

Array array_create(int init_size)
{
	Array a;
	a.size=init_size;
	a.array=(int*)malloc(sizeof(int)*a.size);
	return a;
}
void array_free(Array *a)
{
	free(a->array);
	a->array=NULL;
	a->size=0;
}

//封装 
int array_size(const Array *a)
{
	return a->size;
}
int* array_at(Array *a,int index)
{
	if(index>=a->size){
		array_inflate(a,(index/BLOCK_SIZE+1)*BLOCK_SIZE-a->size);
	}
	return &(a->array[index]); 
}

int array_get(const Array *a,int index)
{
	return a->array[index];
}

void array_set(Array *a,int index,int value)
{
	a->array[index]=value;
}

void array_inflate(Array *a,int more_size)
{
	int *p=(int*)malloc(sizeof(int)*(a->size+more_size));
	int i;
	for(i=0;i<a->size;i++)
	{
		p[i]=a->array[i];
	}//这里可以用memcpy来做
	//memcpy((void*)p,(void*)a->array,a->size*sizeof(int));
	free(a->array);
	a->array=p;
	a->size+=more_size;
}

int main()
{
	Array a=array_create(100);
	printf("%d\n",array_size(&a));
	*array_at(&a,0)=10;
	printf("%d\n",*array_at(&a,0));
	int number;
	int cnt=0;
	while(number!=-1){
		scanf("%d",&number);
		*array_at(&a,cnt++)=number;
	}
	array_free(&a);
	return 0;
}

4.2 链表

4.2.1 可变数组的缺陷

可变数组增长时，可能会涉及到频繁的内存重分配，这可能导致性能开销，特别是在连续插入或删除元素时，每次调整大小都可能涉及复制现有数据到新分配的内存区域。在资源受限的环境中，如嵌入式系统，可用内存可能非常有限，可变数组可能由于无法获得足够的连续内存而导致内存溢出或系统不稳定。

4.2.2 链表

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

//typedef struct _node{
//	int value;
//	struct _node *next;
//}Node; 

int main(int argc,char const *argv[])
{
	Node *head=NULL;
	int number;
	do{
		scanf("%d",&number);
		if(number!=-1){
			//add to linked-list
			Node *p=(Node*)malloc(sizeof(Node));
			p->value=number;
			p->next=NULL;
			//find the last
			Node *last=head;
			if(last){
				while(last->next){
					last=last->next;
				}
				//attach
				last->next=p;
			}else{
				head=p;
			}
		}
	}while(number!=-1);
}

4.2.3 链表的函数

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

//typedef struct _node{
//	int value;
//	struct _node *next;
//}Node; 

typedef struct _list{
	Node* head;
//Node* tail;
}List;

void add(List* pList,int number);

int main(int argc,char const *argv[])
{
	List list;
	int number;
	list.head=NULL;
	do{
		scanf("%d",&number);
		if(number!=-1){
			add(&list,number);
		}
	}while(number!=-1);
	return 0;
}

void add(List* pList,int number)
{
	//add to linked-list
	Node *p=(Node*)malloc(sizeof(Node));
	p->value=number;
	p->next=NULL;
	//find the last
	Node *last=pList->head;
	if(last){
		while(last->next){
			last=last->next;
		}
		//attach
		last->next=p;
	}else{
		pList->head=p;
	}
}

4.2.4 链表的搜素

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

//typedef struct _node{
//	int value;
//	struct _node *next;
//}Node; 

typedef struct _list{
	Node* head;
//Node* tail;
}List;

void add(List* pList,int number);
void print(List *pList);

int main(int argc,char const *argv[])
{
	List list;
	int number;
	list.head=NULL;
	do{
		scanf("%d",&number);
		if(number!=-1){
			add(&list,number);
		}
	}while(number!=-1);
	print(&list);
	scanf("%d",&number);
	Node *p;
	int isFound=0;
	for(p=list.head;p;p=p->next){
		if(p->value==number){
			printf("找到了\n");
			isFound=1;
			break; 
		}
	}
	if(!isFound){
		printf("没找到"); 
	}
	return 0;
}

void add(List* pList,int number)
{
	//add to linked-list
	Node *p=(Node*)malloc(sizeof(Node));
	p->value=number;
	p->next=NULL;
	//find the last
	Node *last=pList->head;
	if(last){
		while(last->next){
			last=last->next;
		}
		//attach
		last->next=p;
	}else{
		pList->head=p;
	}
}

void print(List *pList){
	Node *p;
	for(p=pList->head;p;p=p->next){
		printf("%d",p->value);
	}
	printf("\n");
}

4.2.5 链表的删除

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

//typedef struct _node{
//	int value;
//	struct _node *next;
//}Node; 

typedef struct _list{
	Node* head;
//Node* tail;
}List;

void add(List* pList,int number);
void print(List *pList);

int main(int argc,char const *argv[])
{
	List list;
	int number;
	list.head=NULL;
	do{
		scanf("%d",&number);
		if(number!=-1){
			add(&list,number);
		}
	}while(number!=-1);
	print(&list);
	scanf("%d",&number);
	Node *p;
	int isFound=0;
	for(p=list.head;p;p=p->next){
		if(p->value==number){
			printf("找到了\n");
			isFound=1;
			break; 
		}
	}
	if(!isFound){
		printf("没找到"); 
	}
	Node* q;
	for(q=NULL,p=list.head;p;q=p,p=p->next){
		if(p->value==number){
			if(q){
				q->next=p->next;
			}else{
				list.head=p->next;
			}
			free(p);
			break; 
		}
	}
	return 0;
}

void add(List* pList,int number)
{
	//add to linked-list
	Node *p=(Node*)malloc(sizeof(Node));
	p->value=number;
	p->next=NULL;
	//find the last
	Node *last=pList->head;
	if(last){
		while(last->next){
			last=last->next;
		}
		//attach
		last->next=p;
	}else{
		pList->head=p;
	}
}

void print(List *pList){
	Node *p;
	for(p=pList->head;p;p=p->next){
		printf("%d",p->value);
	}
	printf("\n");
}

任何“-”>左边的指针都应该检查边界情况

4.2.6 链表的清除

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

//typedef struct _node{
//	int value;
//	struct _node *next;
//}Node; 

typedef struct _list{
	Node* head;
//Node* tail;
}List;

void add(List* pList,int number);
void print(List *pList);

int main(int argc,char const *argv[])
{
	List list;
	int number;
	list.head=NULL;
	do{
		scanf("%d",&number);
		if(number!=-1){
			add(&list,number);
		}
	}while(number!=-1);
	print(&list);
	scanf("%d",&number);
	Node *p;
	int isFound=0;
	for(p=list.head;p;p->next){
		if(p->value==number){
			printf("找到了\n");
			isFound=1;
			break; 
		}
	}
	if(!isFound){
		printf("没找到"); 
	}
	Node* q;
	for(q=NULL,p=list.head;p;q=p,p->next){
		if(p->value==number){
			if(q){
				q->next=p->next;
			}else{
				list.head=p->next;
			}
			free(p);
			break; 
		}
	}
	for(p=list.head;p;p=q){
		q=p->next;
		free(p);
	}
	return 0;
}

void add(List* pList,int number)
{
	//add to linked-list
	Node *p=(Node*)malloc(sizeof(Node));
	p->value=number;
	p->next=NULL;
	//find the last
	Node *last=pList->head;
	if(last){
		while(last->next){
			last=last->next;
		}
		//attach
		last->next=p;
	}else{
		pList->head=p;
	}
}

void print(List *pList){
	Node *p;
	for(p=pList->head;p;p=p->next){
		printf("%d",p->value);
	}
	printf("\n");
}

这一周的内容感觉有点抽象。。。多看几遍吧。。

Ccjf酷儿

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
程序设计进阶——C语言（翁凯版）第四周

可变数组增长时，可能会涉及到频繁的内存重分配，这可能导致性能开销，特别是在连续插入或删除元素时，每次调整大小都可能涉及复制现有数据到新分配的内存区域。在资源受限的环境中，如嵌入式系统，可用内存可能非常有限，可变数组可能由于无法获得足够的连续内存而导致内存溢出或系统不稳定。
复制链接

扫一扫