数据结构最最基础的程序

最新推荐文章于 2022-05-17 18:17:41 发布
最新推荐文章于 2022-05-17 18:17:41 发布
阅读量567 收藏 7
点赞数 6
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheTechnologyOfCat/article/details/105274193
版权

数据结构的作业，暂时先把代码放着，有时间再写注释，嗯，有时间再说，感觉养成了不好的习惯。。。。。。。。代码中有好多不合理的地方，希望有心人士能够指出来，毕竟我还只是一个半吊子的码农。

顺序表

基本操作

定义线性表
typedef struct{
	listdata data[maxsize-1];
	int len;
}seqlist;
建立空表
seqlist SETNULL(){
	seqlist l;
	l.len = 0;
	return l;
}
求表长度
int Length(seqlist l){
	printf("该表的长度为：%d\n",l.len);
	return l.len;
}
按序号取出元素
listdata Get(seqlist l,int n){
	//判断是否超出表的范围 
	if(n <= 0||n > l.len){
		printf("该位置超出列表长度\n");
		return 0;
	}
	else{
		printf("第%d个元素是：%d\n",n,l.data[n-1]);
		return l.data[n-1];
	}
}
按值查询
int Locate(seqlist l,listdata x){
	int i,k=1;
	//判断是否存在，存在返回所在位置，否则返回0 
	for(i = 0;i <= l.len-1;i++)
		if(x==l.data[i]){
			printf("%d第一次出现在第%d个位置上。\n",x,i+1); 
			return i+1;
			k=0;
		} 
	if(k!=0)
		printf("该值不存在\n");		
	return 0; 
}
将新结点x插入到顺序表的第i个位置上
int insert(seqlist *l,int n,listdata x)
{int j; 
 if (l->len >= maxsize-1) //判断表空间是否溢出？
  {printf("表空间已满或溢出\n"); return 0;}
 else
  if((n < 1)||(n > l->len+1)) //判断插入位置合法否？
  	{printf("表中该位置不存在\n"); return 0;}
  else{
  	for(j = l->len-1;j >= n-1;j--) //批量移动
       l->data[j+1] = l->data[j]; //后移一个位置
   	l->data[n-1] = x; //在第i个位置上插入x,所对应的下标为n-1
   	l->len++;   
  }  
  return 1;   
}
从顺序表l中删除第i个位置上的结点
int delete(seqlist *l ,int n)
{int j;
 if((n < 1)||(n > l->len)) //判断删除位置n是否合法？
  {printf("表中该位置不存在\n"); return 0;}//非法位置返回0 
 else
  {for(j = n;j <= l->len;j++) //从第n+1至len-1 
      l->data[j-1] = l->data[j];//顺序前移一个位置
   l->len--; //表长减1
   }
 return 1; 
 }
给空表赋值
seqlist giveValue(seqlist l){
 	int i=0,j=1;
 	printf("请输入该表的整数值，回车后按Ctrl+Z结束输入：\n"); 
 	while(scanf("%d",&i) != EOF)//存储顺序表的元素 
    {	printf("第%d个数是：%d\n",j,i); 
        l.data[l.len] = i;
        l.len++;
        j++;
    }
    printf("输入完毕！！！\n"); 
    return l;
 }
检查A是不是B的子集
bool Check01(seqlist A, seqlist B){//检查A是不是B的子集 
 	int i,k;
 	bool f=true;
 	for(i=0;i<=A.len-1;i++){	//从第一个遍历到最后一个 
 		if(f){		//如果前一个值是，则判断下一个值，否则结束 
		 	for(k=0;k<=B.len-1;k++){
			if(A.data[i]==B.data[k]){
				f=true;
				break;
			}
			else
				f=false;
		 	}
		 }
	 	else
	 		return f;
	 }
	return f;
 }
合并两个子序列
seqlist packList(seqlist A,seqlist B){//合并两个子序列 
	seqlist C=B;
	printf("C表的长度为%d\n",C.len);
	int i,low=0,high,mid,k=0,n;		
	for(i=0;i<=A.len-1;i++){	//对A的每个子元素进行遍历 
		high = C.len-1;
		mid=ceil((low+high)/2.0);
		while(low<high&&C.data[mid] != A.data[i]){	//如果C的中间值不等于A中元素值 
			if(A.data[i]>C.data[mid]){ //A的元素值大于C的中间值 
				if(A.data[i]>=C.data[high]){//并且大于C中的最大值 
					k = C.len+1;
					break;
				}
				else{
					if(low == mid){	//如果low和mid相等，则返回 
						k = mid + 1;
						break; 
					}
					else{//如果low和mid不相等，则继续向右查找 
						low = mid;
					}
				}
			}	
			else if(A.data[i]<C.data[mid]){ // A的元素值小于C的中间值 
				if(A.data[i]<=C.data[low]){  //并且小于C中的最小值 
					k = low+1;
					break; 
				}
				else
					if(mid == high){//如果lhigh和mid相等，则返回 
						k = high+1;
						break;
					}
					else{ //如果high和mid不相等，则继续向左查找 
						high = mid;
					}
			} 
			//承接上面的if，没有出现过这种情况 ，这句代码相当于多余的。 
			else	
				k = mid+1;
			mid=ceil((low+high)/2.0); 
		}
		//执行完循环，如果C的中间值等于A的元素，则把A元素放到C中间值的位置上 
		if(A.data[i]==C.data[mid])
			k = mid+1; 
		//用n来接受是否成功插入元素 
		n = insert(&C,k,A.data[i]);
	}
	return C;
}

链式表

基本操作

定义链表
typedef struct node{	//定义链表 
	datatype data;
	struct node *next;
}linklist;
头插法创建链表
linklist* Create(void){
	//建立两个链表，一个用于存放数据，一个存放另一个链表的地址 
	linklist *l,*head;
	datatype ch;
	//首先建立空指针 
	head = NULL;  
	printf("请输入链表的值，以$结束\n"); 
	ch = getchar();
	while(ch != '\n'){
		// 建立一个空表大约有5字节空间（字符数据占1字节，指针占4字节），分配空间 
		l = (linklist *)malloc(sizeof(linklist)); 
		//向空间中存字符数据 
		l->data = ch;
		//向链表存放上一个节点的地址。 
		l->next = head;
		//存取当前链表地址 
		head = l;
		printf("%c",l->data);
		ch = getchar();
	}	
	return head;
}
尾插法创建链表
linklist* Creatlistr(void){
	datatype ch;
	linklist *head,*l,*r;
	//建立一个表头 
	head = (linklist*)malloc(sizeof(linklist));
	//建立一个指向下一节点的指针 
	r = head;
	printf("请输入链表的值\n"); 
	ch = getchar();
	while(ch !='\n'){
		//创建节点，分配空间 
		l = (linklist*)malloc(sizeof(linklist));
		//节点赋值 
		l->data = ch;
		//将l节点加入到链表的下一个 
		r->next = l;
		//最后一个指向l节点 
		r = l;
		//printf("%c\n",l->data);
		//获取下一节点的值 
		ch = getchar();	
	}
	r->next = NULL;
	return head->next;
}
求链表中有多少个节点
void Length(linklist *l){
	int j = 0;
	linklist *p;
	p = l;
	//链表有一个头指针，当链表是空的时候到达尾部 
	while(p != NULL){
		p = p->next;
		j++;
	}
	printf("现在链表长度是%d\n",j);
}
找前趋节点
linklist* get(linklist *l,int i){
 	if(i ==0)
 		i = 1;
 	linklist *p;
 	p = l;
 	int j = 1;
 	while((p != NULL)&&(j<i)){
	 	p = p->next;
	 	j++;
	 }
	 if(j == i){
 		return p;
 	}
 	else
 		return NULL;
 }
按序号取元素
datatype Get(linklist *l,int i){
	int j = 1;
	linklist *p;
	p = (linklist*)malloc(sizeof(linklist));
	p = l;
	while((p->next != NULL)&&(j<i)){
		p = p->next;
		j++;
	}
	//如果存在返回值 
	if(i == j)
		return p->data;
	else
		return '$';
}
按值查询
int Locate(linklist *l,datatype ch){
	int i = 1;
	linklist *p;
	p = (linklist*)malloc(sizeof(linklist));
	p = l;
	while(p!=NULL){
		if(p->data == ch)
			return i;
		p = p->next;
	    i++;
	}
	//如果存在返回节点的值 
	if(p->data == ch)
		return  i;
	else
		return 0;
}
后插操作
int insertafter(linklist *l,int i,datatype x){
	//把要插入的值给新节点 
	linklist *s,*p;
	//获得第i个节点的地址 
	p = get(l,i+1);
	//给新节点分配空间，返回空间地址 
	s = (linklist*)malloc(sizeof(linklist));
	if(p != NULL){
		s->data = x;
		//将新节点链接到第i后面的节点中 
		s->next = l->next;
		//将前面的节点到新节点的节点连接 
		l->next = s;
		return 1;		
	}
	else
		return 0;
}
前插操作
int insertbefore(linklist *l,int i,datatype x){
	linklist *s,*p;
	//给新节点分配空间，返回空间地址 
	s = (linklist*)malloc(sizeof(linklist));
	//获得第i个节点的前趋节点 
	p = get(l,i);
	if(p != NULL){
		//将第i个节点数据给新节点 
		s->data = p->data;
		//将新节点与第i后面的节点相连 
		s->next = p->next;
		//将第i个节点赋值为新值
		p->data = x;
		//链接新节点 
		p->next = s;
		return 1; 		 
	}
	else
		return 0;
}
删除第i个节点
int Delete(linklist *l,int i){
	//找到第i个节点
	linklist *p,*s;
//	if(i==1)
//		p = get(l,i);
//	else
	p = get(l,i-1);
	if(p!=NULL){
		s = p->next;
		p->next = p->next->next;
		free(s);
		return 1;
	}
	else
		return 0;
}
输出链表
void display(linklist *l){
	linklist *p;
	int i = 1;
	p = l;
	while(p){
		printf("第%d个节点元素是%c\n",i,p->data);
		i++;
		p = p->next;
	}
}

栈

基本操作

定义栈
typedef struct
{	datatype data[MAXSIZE];
	int top;	
}seqstack;
初始化操作，设置空栈
int InitStack(seqstack *s){
	s->top = 0;
	return 1;
}
判断空栈操作,返回0是空，1是非空
int EmptyStack(seqstack *s){
	if(s->top>0)
		return 1;
	else
		return 0; 
}
入栈操作
int Push(seqstack *s,datatype x){
	if(s->top>=MAXSIZE){
		printf("OVERFLOE\n");
		return 0;
	}
	else{
		s->data[s->top] = x;
		s->top++;
		return 1;
	}
}
出栈操作
int Pop(seqstack *s,datatype *d){
	if(EmptyStack(s)){
		s->top--;
		*d = s->data[s->top];
		return 1;
	}
	else{
		printf("EMPTY\n");
		return 0;
	}
}
取栈顶元素操作
int GetTop(seqstack *s,datatype *d){	
	if(EmptyStack(s)){
		s->top--;
		*d = s->data[s->top];
		return 1;
	}
	else{
		printf("This stack is Empty");
		return 0;
	}
}
置栈空操作
int ClearStack(seqstack *s){
	if(EmptyStack(s)){
		printf("This is not Empty,do you want clear\n");
		printf("Y or N\n");
		//getchar();
		int order;
		while((order=getchar())!= EOF){
			if(order='Y'){
				InitStack(s);
				return 1;
			}
			else
				return 0;	
		}	
	}
	else{
		printf("This is Empty\n");
		return 1;
	}
}
求当前栈中元素的个数
int CurrentSize(seqstack *s){
	return s->top;
}

链表栈

基本操作

定义节点
typedef struct node{
	datatype data;
	struct node *next;
}linkstack;
初始化操作
void InitStack(linkstack *top){
	top->next = NULL;
	printf("栈初始化成功\n"); 
}
判空操作
int EmptyStack(linkstack *top){
	if(top == NULL){
		printf("this stack is empty\n");
		return 0;
	}
	else{
		printf("this stack is not empty\n");
		return 1;
	}
}
入栈操作
int Push(linkstack *top,datatype ch_in,linkstack *node_in){
	if(node_in != NULL){
		node_in->data = ch_in;
		node_in->next = top->next;
		top->next = node_in;
		printf("%c入栈成功\n",ch_in);
		return 1;
	}
	else{
		printf("入栈失败\n");
		return 0;
	}
}
出栈操作
int Pop(linkstack *top){
	datatype ch_out;
	if(EmptyStack(top)){
		ch_out = top->next->data;
		top->next = top->next->next;
		printf("出栈成功，出栈元素为%c\n",ch_out);
		return 1;
	}
	else
	{
		printf("出栈失败\n"); 
		return 0;
	}
}
取栈顶元素
int GetTop(linkstack *top){
	datatype ch_btn;
	if(EmptyStack(top)){
		ch_top = top->next->data;
		printf("取栈顶元素成功，栈顶元素为%c\n",ch_top);
		return 1;
	}
	else
	{
		printf("没有栈顶元素\n"); 
		return 0;
	}
}
置栈空操作
int ClearStack(linkstack *top){
	if(top != NULL){
		char ch;
		printf("this stack is not empty,dou you want to clear?(Y or N)\n");
		while(scanf("%c",&ch) != EOF){
			if(ch == 'Y'){
				top->next = NULL;
				printf("this stack is empty\n");
				return 1;
			}
			else if(ch == 'N'){
				printf("栈置空失败\n");
				return 0;
			}
			else{
				printf("输入格式错误\n"); 
			}
		}
	}
	else{
		printf("this stack is empty\n");
		return 1;
	}
}
求当前栈中元素的个数
int CurrentSize(linkstack *top){
	int len = 0;
	linkstack *down = (linkstack *)malloc(sizeof(linkstack));
	down = top;
	while(down->next != NULL){
		len++;
		down->next = down->next->next;
	} 
	return len;
}

两个栈共享一个空间

基本操作

定义
datatype v[M];

int ta,tb;
int flag = 0;	//入a栈flag=0,入b栈flag=1
初始化栈
void InitStack(){
	ta = -1;
	tb = M; 
}
判栈空
int EmptyStack(datatype	*v){
	if(((tb-ta)>=0)&&((tb-ta)<=M)){
		printf("非空\n");
		return 1;
	}
	else{
		printf("空栈\n");
		return 0; 
	}
}
入栈操作
int Push(datatype *v,datatype data_in){
	if((tb-ta>1)){
		if(flag){
			tb--;	
			v[tb] = data_in;
			printf("%c入B栈成功\n",data_in); 
		}
		else{
			ta++;
			v[ta] = data_in;
			printf("%c入A栈成功\n",data_in); 
		}		
		return 1;
	}
	else{
		printf("OVERFLOW\n");
		return 0;
	} 
}
出栈操作
int Pop(datatype *v,datatype *data_out){
	if(EmptyStack(v)){
		if(flag){
			*data_out = v[tb];
			tb++;
		}
		else{
			*data_out = v[ta];
			ta--;
		}
		return 1;
	}
	else{
		printf("出栈失败\n");
		return 0;
	}
}
取栈顶元素
int GetTop(datatype	*v,datatype	*data_top){
	if(EmptyStack(v)){
		if(flag){	
			*data_top = v[tb];
		}
		else{
			*data_top = v[ta];
		}
		return 1;
	}
	else{
		printf("取栈顶元素失败\n"); 
		return 0;
	}
}
取栈底元素
int GetBottom(datatype *v,datatype *data_btm){
	if(EmptyStack(v)){
		if(flag){	
			*data_btm = v[M-1];
			int i = M-1; 
			for(i;i<=tb;i--)
				v[i] = v[i-1];
		}
		else{
			*data_btm = v[0];
			int i = 0;
			for(i;i>=tb;i++)
				v[i] = v[i+1];
		}
		return 1;
	}
	else{
		printf("取栈底元素失败\n");
		return 0;
	}
}

循环列表

基本操作

定义列表
typedef struct{
	datatype data[M];
	int front,rear;
}sequeue;
置空队列
void SETNULL(sequeue *sq){
	sq->front = 0;
	sq->rear = 0;
	printf("现在队列已经置空"); 
}
判空
int EMPTY(sequeue *sq){
	if(sq->front == sq->rear){
		printf("this squeue is Empty\n");
		return 0;
	}
	else{
		printf("this squeue is not Empty\n");
		return 1;
	}
}
取队列头，元素不动
int FRONT(sequeue *sq){
	if(EMPTY(sq)){
		printf("队列头元素为%c\n",sq->data[(sq->front%M)]);
		return 1;
	}
	else{
		printf("队列中没有元素\n");
		return 0;
	}
}
将元素放到队列尾部
int ENQUEUE(sequeue *sq,datatype data_in){
	if(((sq->rear+1)%M) == sq->front){
		printf("这个队列已经满了\n");
		return 0;
	}
	else{
		sq->data[sq->rear] = data_in;
		printf("%c元素在%d位置上添加成功\n",data_in,sq->rear);
		sq->rear = (sq->rear)%M+1;
		return 1;
	}	
}
出队
int DEQUEUE(sequeue *sq){
	datatype data_out;
	if(EMPTY(sq)){
		data_out = sq->data[sq->front%M];
		printf("出队元素为%c\n",data_out);
		sq->front = sq->front%M+1;
		return 1;
	}
	else{
		printf("队列中没有元素，出队失败\n");
		return 0;
	}
}

链表队列

基本操作

定义
typedef struct node{
	datatype data;
	struct node *next;
}linknode;
typedef struct{
	linknode *front,*rear;
}linksqueue;
置空队列
void SETNULL(linksqueue *sq){
	sq->front =  (linknode *)malloc(sizeof(linknode));
	sq->rear = (linknode *)malloc(sizeof(linknode));
	sq->front->next = NULL;
	sq->rear = sq->front;
	printf("初始化成功\n");
}
判空
int EMPTY(linksqueue *sq){
	if(sq->front==sq->rear){
		printf("this linkqueue is Empty\n");
		return 0;
	}
	else{
		printf("this linkqueue is not Empty\n");
		return 1;
	}
}
取队列头，元素不动
int FRONT(linksqueue *sq){
	datatype data_get;
	if(EMPTY(sq)){
		data_get = sq->front->next->data;
		printf("获得队列头元素为%c\n",data_get);
		return 1;
	}
	else{
		printf("取队列头元素失败\n");
		return 0;
	} 
}
将元素放到队列尾部
int ENQUEUE(linksqueue *sq,datatype data_in){
	linknode *n = (linknode *)malloc(sizeof(linknode));
	if(n != NULL){
		n->data = data_in;
		sq->rear->next = n;
		sq->rear = n;
		printf("%c元素入队成功\n",data_in);
		return 1;
	}
	else{
		printf("OVERFLOW\n");
		return 0;
	}
	
}
出队
int DEQUEUE(linksqueue *sq){
	linknode *n = (linknode *)malloc(sizeof(linknode));
	if(EMPTY(sq)){
		n = sq->front->next;
		printf("出队元素%c\n",n->data);
		sq->front->next = sq->front->next->next;
		return 1;
	}
	else{
		printf("出队失败\n");
		return 0;
	}
}
The Electronic Cat
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构基本程序
01-14
计算机，数据结构，二叉树的基本算法和一些基本的代码
数据结构五个程序（比较经典）
06-04
初学数据结构时~这些事比较经典的程序。。。不过做的不好~还有待改进！希望共同学习~
数据结构程序
kk__w的博客
12-30 556
数据结构的练习 1，上传代码的动机 这学期我选了《数据结构与数据库》这门课，被课上的一些同学恶心到了，这些同学不写课程要求的程序作业，从学长学姐那里白嫖了往年的全部程序作业。虽然说，这些东西都是些很成熟的，有大量成功范例可以去借鉴的，但这些同学的做法实在令人不齿。可这样的人却也恰恰是同学中较为优秀的那一批中的部分，是啊，这样做节省了许多时间，而课程的期末测试又几乎是仅仅检查了不了解算法是如何运行的...
数据结构最全源程序
09-27
里面有数据结构中的所有程序而且全都可以直接使用！ 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 049 基数排序 050 二叉搜索树操作 051 二项式系数递归 052 背包问题 053 顺序表插入和删除 054 链表操作（1） 055 链表操作（2） 056 单链表就地逆置 057 运动会分数统计 058 双链表 059 约瑟夫环 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 070 用栈设置密码 071 魔王语言翻译 072 火车车厢重排 073 队列实例 074 K阶斐波那契序列
程序设计与数据结构
06-09
### 程序设计与数据结构 #### C程序设计与数据结构概览 本书由周立功编写，作为一本深入浅出介绍...通过本书的学习，读者可以建立起坚实的程序设计基础，并掌握常用的数据结构及算法，为进一步深入学习打下良好基础。
华中师范计算机874c语言数据结构 最全资料
04-19
《874数据结构与C语言程序设计》是华中师范大学计算机科学专业考研的重要参考书目，涵盖了C语言和数据结构两大核心主题。C语言是一种强大的、高效的编程语言，广泛应用于系统开发、嵌入式系统以及各类算法实现。数据...
831程序设计与数据结构大纲1
08-08
在831程序设计与数据结构大纲中，程序设计部分占据了考试内容的50%，涵盖了C语言的基础知识，选择结构，循环结构，函数，数组，指针，结构体、共用体和枚举类型，以及文件操作。 1. **C语言基础知识**：这部分考察...
数据结构源程序 图
qdu_huihui的博客
02-20 419
0 图的定义   图是一种十分复杂的数据结构，在图的任意两个结点之间都可能存在直接关系，且这种关系有可能是双向的。   图分为有向图和无向图，其区别在于有向图结点之间的连接是有方向的，即由出发点指向终端点；无向图中结点之间的连接是双向的，没有出发和终端。 1 相关程序 （1）图的遍历 图的遍历有两种：   深度优先搜索：访问到一个新的结点立刻对其进行搜索，类似于先序遍历。   广度优先搜索：访问完...
数据结构程序代码
12-23
试编写程序： 从键盘随机输入（或随机产生）30个整数 （1） 用顺序查找算法查找给定的某个数 （2） 对30个排序后进行折半查找 （3） 建立这30个数的二叉排序树，并进行查找。 （4） 归并排序
数据结构——简单例子的程序（C语言实现）
02-01
数据结构——简单例子的程序（C语言实现），希望对初学者有所帮助
简单的数据结构
雨潇的博客
05-14 649
哇，最近终于交上了作业，下一份作业……暂时还不及，所以就勉勉强强终于晚上不用熬夜思考作业了，开始思考我的选修课了……，啊，哭唧唧，选修课马上要结束了 ，就要去每周三周五的小比赛了，我到底有多菜就要暴漏在公众的目光之中了,不过应该没有那么多人注意到我，安心安心…… 嗯，接下来好好写一下最后学的东西，这个再拖就忘没影子了。 一.栈 栈是一种只支持栈顶插入（进栈）或者删除（出栈）的一种特殊线性表...
初学数据结构的入门过程
手撕鸡翅的博客
06-26 374
初学数据结构的入门过程 数据结构的简单基础入门知识，也是我当初入门时自己跑的代码，具体我的理解已注释。（过几天开始准备数据结构复习认认真真梳理后再大更新~） 可以通过跑一跑代码看看注释来理解理解~ 写的不好仅供参考。 目录初学数据结构的入门过程1、指针理解2、递归理解-汉诺塔、数列求和、阶乘3、栈理解--链实现4、队列理解5、链表理解-用冒泡实现链表6、树理解 1、指针理解 #include<iostream> using namespace std; void fun(int **q) /
数据结构程序设计
qq_35709786的博客
05-17 714
实验一 实验二 实验三
数据结构程序.docx
07-11
数据结构程序 数据结构程序全文共10页，当前为第1页。数据结构程序全文共10页，当前为第1页。PSeqList createNullList_seq(int m) 数据结构程序全文共10页，当前为第1页。 数据结构程序全文共10页，当前为第1页。 { PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList)); if (palist != NULL) { palist->element = (DataType*)malloc(sizeof(DataType)*m); if (palist->element) { palist->MAXNUM=m; palist ->n = 0; return (palist); } else free (palist); } printf("Out of space!!!\n"); return NULL; } int insertPre_seq(PSeqList palist, int p, DataType x) { int q; if ( palist->n >= palist-> MA
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值