c++堆调整(2)_队伍调整-2c++-CSDN博客

本文链接：https://blog.csdn.net/hdminn/article/details/130834405

文章讲述了作者在实现堆排序时遇到的问题，原本的代码由于每个节点包含过多变量导致内存消耗大。为了解决这个问题，作者简化了类结构，将节点信息精简为仅包含数据和值，并通过外部函数计算左右孩子和父节点的索引，从而降低了内存使用。新的堆调整代码实现了一个更高效的解决方案。

摘要由CSDN通过智能技术生成

上一次，我做了一个堆调整

回去做了个堆排序，结果不行

我仔细想了想，好像变量开的有点多

class tree{//最重要的!!!
	public://表示他是公开的，在类外也能用
		int l_kid=data*2/*某节点左孩子的数据域 = 该节点数据域 x 2*/,r_kid=data*2+1/*右孩子数据域 = 左孩子 + 1*/;
		int father=(data-(data%2))/2;//父节点数据域 = ( 该节点数据域 - 该节点数据域 % 2 ) / 2
		int data,n;//数据域与值
};

这样一来，每个信息点都开5个int形变量，一个int变量好像占用内存4B，一个节点开20B，堆排序: 50个元素，1000个B，大约1KB

当然没法玩

新的代码，我简化了类:

class tree{
	public:
		int data,n;
};

增加了3个函数:

int l_kid(int data){
	return data*2;
}

int r_kid(int data){
	return data*2+1;
}

int father(int data){
	return (data-(data%2))/2;
}

新的HEAP_AJUST:

int heap_ajust(tree heap[],int data,int n){
	heap[data].n=n;
	heap[data].data=data;
	for(;;){
		if(heap[data].n>heap[father(data)].n){
			swap(heap[data].n,heap[father(data)].n);
			data=father(data);
		}
		else if((heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
			swap(heap[data].n,max(heap[l_kid(data)].n,heap[r_kid(data)].n));
			data=max(l_kid(data),r_kid(data));
		}
		else if(heap[data].n<heap[l_kid(data)].n){
			swap(heap[data].n,heap[l_kid(data)].n);
			data=l_kid(data);
		}
		else if(heap[data].n<heap[r_kid(data)].n){
			swap(heap[data].n,heap[r_kid(data)].n);
			data=r_kid(data);
		}
		else if((heap[data].n>heap[father(data)].n)&&(heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
			break;
		}
	}
	return data;
}

全部源代码:

#include<iostream>
using namespace std;
class tree{
	public:
		int data,n;
};
int l_kid(int data){
	return data*2;
}
int r_kid(int data){
	return data*2+1;
}
int father(int data){
	return (data-(data%2))/2;
}
void swap(int a,int b){
	int c;
	c=a;
	a=b;
	b=a;
}
int max(int a,int b){
	if(a>=b){return a;}
	if(a<b){return b;}
}
int heap_ajust(tree heap[],int data,int n){
	heap[data].n=n;
	heap[data].data=data;
	for(;;){
		if(heap[data].n>heap[father(data)].n){
			swap(heap[data].n,heap[father(data)].n);
			data=father(data);
		}
		else if((heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
			swap(heap[data].n,max(heap[l_kid(data)].n,heap[r_kid(data)].n));
			data=max(l_kid(data),r_kid(data));
		}
		else if(heap[data].n<heap[l_kid(data)].n){
			swap(heap[data].n,heap[l_kid(data)].n);
			data=l_kid(data);
		}
		else if(heap[data].n<heap[r_kid(data)].n){
			swap(heap[data].n,heap[r_kid(data)].n);
			data=r_kid(data);
		}
		else if((heap[data].n>heap[father(data)].n)&&(heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
			break;
		}
	}
	return data;
}
int main(){
	
}

@没登录的:

#include<iostream>
using namespace std;
class tree{
   public:
       int data,n;
};
int l_kid(int data){
   return data*2;
}
int r_kid(int data){
   return data*2+1;
}
int father(int data){
   return (data-(data%2))/2;
}
void swap(int a,int b){
   int c;
   c=a;
   a=b;
   b=a;
}
int max(int a,int b){
   if(a>=b){return a;}
   if(a<b){return b;}
}
int heap_ajust(tree heap[],int data,int n){
   heap[data].n=n;
   heap[data].data=data;
   for(;;){
       if(heap[data].n>heap[father(data)].n){
           swap(heap[data].n,heap[father(data)].n);
           data=father(data);
       }
       else if((heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
           swap(heap[data].n,max(heap[l_kid(data)].n,heap[r_kid(data)].n));
           data=max(l_kid(data),r_kid(data));
       }
       else if(heap[data].n<heap[l_kid(data)].n){
           swap(heap[data].n,heap[l_kid(data)].n);
           data=l_kid(data);
       }
       else if(heap[data].n<heap[r_kid(data)].n){
           swap(heap[data].n,heap[r_kid(data)].n);
           data=r_kid(data);
       }
       else if((heap[data].n>heap[father(data)].n)&&(heap[data].n<heap[l_kid(data)].n)&&(heap[data].n<heap[r_kid(data)].n)){
           break;
       }
   }
   return data;
}
int main(){

}