Object 通过堆排序传递对象
试图通过堆排序传递要排序的对象类时出现问题。基本上，我有一个类，它保存员工数据，如姓名、地址、电话号码和员工ID。我们将使用堆排序将该类作为对象传递，并按员工ID对其进行排序。我的主要问题是将堆排序结构转换为可以接收对象的位置。这是一门开始的数据结构课程，所以我们不允许使用高级技术。我遇到的障碍是，如何将对象传递到堆排序方法中，而堆排序方法目前只接受基本数据类型 办公室类：Object 通过堆排序传递对象,object,heapsort,Object,Heapsort,试图通过堆排序传递要排序的对象类时出现问题。基本上，我有一个类，它保存员工数据，如姓名、地址、电话号码和员工ID。我们将使用堆排序将该类作为对象传递，并按员工ID对其进行排序。我的主要问题是将堆排序结构转换为可以接收对象的位置。这是一门开始的数据结构课程，所以我们不允许使用高级技术。我遇到的障碍是，如何将对象传递到堆排序方法中，而堆排序方法目前只接受基本数据类型 办公室类： public class Office_Staff { public String Name , Dept , P
public class Office_Staff
{
public String Name , Dept , Phonenumber;
public int Id, years;
Office_Staff()
{
Id = ("");
Name = ("");
Dept = ("");
Phonenumber = ("");
years = 0;
}
Office_Staff(int empid ,String empname, String empdept , String empphone, int service)
{
Id = empid;
Name = empname;
Dept = empdept;
Phonenumber = empphone;
years = service;
}
public void setId(int empid)
{
Id = empid;
}
public void setName(String empname)
{
Name = empname;
}
public void setDept(String empdept)
{
Dept = empdept;
}
public void setPhone(String empphone)
{
Phonenumber = empphone;
}
public void setYears(int service)
{
years = service;
}
public String getId()
{
return Id;
}
public String getName()
{
return Name;
}
public String getDept()
{
return Dept;
}
public String getPhone()
{
return Phonenumber;
}
public int getYears()
{
return years;
}
public String toString()
{
String str = "Office_Staff Name : " + Name + "Office_Staff ID : " + Id +
"Office_Staff Deaprtment : " + Dept + "Office_Staff Phone Number : "
+ Phonenumber + "Years Active : " + years;
return str;
}
}
import java.util.Scanner;
import java.util.ArrayList;
import java.io.*;
class zNode
{
private int iData;
public zNode(int key)
{
iData = key;
}
public int getKey()
{
return iData;
}
public void setKey(int k)
{
iData = k;
}
}
class HeapSort
{
private int [] currArray;
private int maxSize;
private int currentSize;
private int currIndex;
HeapSort(int mx)
{
maxSize = mx;
currentSize = 0;
currArray = new int[maxSize];
}
//buildheap
public boolean buildHeap(int [] currArray)
{
int key = currIndex;
if(currentSize==maxSize)
return false;
int newNode = key;
currArray[currentSize] = newNode;
siftUp(currArray , currentSize++);
return true;
}
//siftup
public void siftUp(int [] currArray , int currIndex)
{
int parent = (currIndex-1) / 2;
int bottom = currArray[currIndex];
while( currIndex > 0 && currArray[parent] < bottom )
{
currArray[currIndex] = currArray[parent];
currIndex = parent;
parent = (parent-1) / 2;
}
currArray[currIndex] = bottom;
}
//siftdown
public void siftDown(int [] currArray , int currIndex)
{
int largerChild;
int top = currArray[currIndex];
while(currIndex < currentSize/2)
{
int leftChild = 2*currIndex+1;
int rightChild = leftChild+1;
if(rightChild < currentSize && currArray[leftChild] < currArray[rightChild] )
largerChild = rightChild;
else
largerChild = leftChild;
if( top >= currArray[largerChild] )
break;
currArray[currIndex] = currArray[largerChild];
currIndex = largerChild;
}
currArray[currIndex] = top;
}
//remove max element
public int removeMaxElement(int [] currArray)
{
int root = currArray[0];
currArray[0] = currArray[--currentSize];
siftDown(currArray , 0);
return root;
}
//heapsort
private void _sortHeapArray(int [] currArray)
{
while(currentSize != 0)
{
removeMaxElement(currArray);
}
}
public void sortHeapArray()
{
_sortHeapArray(currArray);
}
//hepify
private int[] heapify(int[] currArray)
{
int start = (currentSize) / 2;
while (start >= 0)
{
siftDown(currArray, start);
start--;
}
return currArray;
}
//swap
private int[] swap(int[] currArray, int index1, int index2)
{
int swap = currArray[index1];
currArray[index1] = currArray[index2];
currArray[index2] = swap;
return currArray;
}
//heapsort
public int[] _heapSort(int[] currArray)
{
heapify(currArray);
int end = currentSize-1;
while (end > 0)
{
currArray = swap(currArray,0, end);
end--;
siftDown(currArray, end);
}
return currArray;
}
public void heapSort()
{
_heapSort(currArray);
}
import java.util.Scanner；
导入java.util.ArrayList；
导入java.io.*；
类zNode
{
私家侦探；
公共zNode（int键）
{
iData=键；
}
public int getKey（）
{
返回iData；
}
公共无效设置密钥（int k）
{
iData=k；
}
}
类堆
{
私有int[]数组；
私有int-maxSize；
私有int-currentSize；
私人指数；
HeapSort（int-mx）
{
maxSize=mx；
currentSize=0；
currArray=新整数[maxSize]；
}
//构建堆
公共布尔构建堆（int[]currray）
{
int key=currendex；
如果（currentSize==maxSize）
返回false；
int newNode=key；
currArray[currentSize]=新节点；
siftUp（currArray，currentSize++）；
返回true；
}
//siftup
公共无效siftUp（int[]currArray，int currIndex）
{
int parent=（currendex-1）/2；
int bottom=currArray[currIndex]；
而（currIndex>0&&currArray[parent]=currray[largerChild]）
打破
currArray[currIndex]=currArray[largerChild]；
currIndex=较大的儿童；
}
currArray[currIndex]=顶部；
}
//删除max元素
公共int removeMaxElement（int[]currArray）
{
int root=currray[0]；
currArray[0]=currArray[--currentSize]；
siftDown（电流阵列，0）；
返回根；
}
//堆
私有void _sortHeapArray（int[]currray）
{
while（currentSize！=0）
{
removeMaxElement（currArray）；
}
}
公共无效sortHeapArray（）
{
_sortHeapArray（currArray）；
}
//和平化
私有int[]heapify（int[]currray）
{
int start=（当前大小）/2；
while（开始>=0）
{
siftDown（电流阵列，启动）；
开始--；
}
返回数组；
}
//交换
专用int[]交换（int[]数组，int index1，int index2）
{
int swap=currArray[index1]；
currArray[index1]=currArray[index2]；
currArray[index2]=交换；
返回数组；
}
//堆
公共int[]\u heapSort（int[]currray）
{
heapify（currray）；
int end=currentSize-1；
而（结束>0）
{
currArray=交换（currArray，0，end）；
结束--；
siftDown（电流阵列，结束）；
}
返回数组；
}
公共空堆
{
_heapSort（currray）；
}