大顶堆第二弹----堆排序(递归实现)

  1 package tooffer;
  2
  3 import java.util.ArrayList;
  4 import java.util.Arrays;
  5
  6 public class BigHeap {
  7
  8
  9
 10     /*
 11      *交换堆中的两个元素
 12      */
 13     private void swap(ArrayList<Integer> heapList,int srcIndex,int dstIndex)
 14     {
 15         int tmp = heapList.get(srcIndex);
 16
 17         heapList.set(srcIndex,heapList.get(dstIndex));
 18         heapList.set(dstIndex, tmp);
 19
 20     }
 21
 22     /*
 23      *将指定元素的位置进行上移操作
 24      */
 25     private void HeapUp(ArrayList<Integer> heapList,int index)
 26     {
 27
 28         if(index > 1)
 29         {
 30             int parent = index / 2;
 31             int parentVal = heapList.get(parent).intValue();
 32             int indexVal =  heapList.get(index).intValue();
 33
 34             if(indexVal > parentVal)
 35             {
 36                 swap(heapList,parent,index);
 37                 HeapUp(heapList,parent);
 38             }
 39
 40         }
 41     }
 42
 43     /*
 44      *将指定元素的位置进行下移操作
 45      */
 46     private void HeapDown(ArrayList<Integer> heapList,int index)
 47     {
 48         int heapSize = heapList.size(); //这里进行了重复的计算,可以将作为形参传入，或者将该函数，写成非递归形式
 49
 50         if(index > heapSize - 1)
 51         {//节点不存在
 52             return;
 53         }
 54
 55         int child = index * 2; //左孩子节点
 56
 57         if(child > (heapSize - 2))
 58         {//当前节点为叶子节点，不能进行下移操作，直接返回
 59          //-2是由于最后一个元素已经是要删除的节点，不在计算范围之内
 60             return;
 61         }
 62         else if(child < heapSize - 2)
 63         {//有两个孩子节点
 64              if(heapList.get(child).intValue() < heapList.get(child + 1).intValue())
 65              {
 66                  child++; //右孩子结点值大，作为新的父节点
 67              }
 68         }
 69
 70         if(heapList.get(child).intValue() > heapList.get(index).intValue())
 71         {//孩子节点的值大，进行下移
 72             swap(heapList,child, index);
 73             HeapDown(heapList,child);//继续进行下移操作
 74         }
 75
 76     }
 77
 78     /*
 79      *向大顶堆中插入一个元素
 80      */
 81     public void HeapInsert(ArrayList<Integer> heapList,int value)
 82     {
 83         int heapSize = heapList.size();
 84
 85         if(heapSize == 0)
 86         {//第一个元素不为堆中的元素，跳过
 87             heapList.add(-100);
 88         }
 89
 90         heapList.add(value);
 91         heapSize++; //添加新元素后，改变堆的大小
 92
 93         HeapUp(heapList,heapSize - 1);
 94     }
 95
 96     /*
 97      *从大顶堆中删除一个元素
 98      */
 99     public void HeapDelete(ArrayList<Integer> heapList,int value)
100     {
101         int index = 1,heapSize = heapList.size();
102         for(; index < heapSize; index++)
103         {
104             if(heapList.get(index).intValue() == value)
105             {
106                 break;
107             }
108         }
109
110         if (index >= heapSize)
111         {//元素不存在
112             return;
113         }
114
115         heapList.set(index, heapList.get(heapSize-1)); //将最后一个叶子节点值赋值到当前节点
116         HeapDown(heapList,index);
117
118         int parent = index / 2;
119
120         if(parent > 0 && ( heapList.get(index).intValue() > (Integer)heapList.get(parent).intValue() ))
121         {//如果下移操作后该元素大于父节点还要进行上移
122             HeapUp(heapList,index);
123         }
124
125         heapList.remove(heapSize - 1);
126     }
127
128     /*
129      *调整堆结构
130      */
131     public void heapAdjust(ArrayList<Integer>heapList,int index,int end)
132     {
133         int child = -1,heapSize = heapList.size();
134
135         end = end > heapSize - 1 ? heapSize - 1 : end; //确保结束正确
136
137         while(index <= end / 2)
138         {//只需调整非叶子节点
139             child = index * 2; //左孩子节点
140             if(child + 1 <= end && (heapList.get(child+1).intValue() > heapList.get(child).intValue()) )
141             {
142                 child += 1; //右孩子节点值大右孩子节点上移
143             }
144
145             if(heapList.get(child).intValue() > heapList.get(index).intValue())
146             {
147                 swap(heapList, child, index);
148                 index = child;
149             }
150             else
151             {
152                 break;
153             }
154         }
155     }
156
157
158     /*
159      * 初始化时调整堆结构
160      * 由于堆是完全二叉树结构，所以只有前一半节点是非叶子节点
161      */
162     public void heapInitAdjust(ArrayList<Integer> heapList)
163     {
164         int heapSize = heapList.size();
165
166         for(int i = heapSize / 2; i > 0; i--)
167         {
168             heapAdjust(heapList, i, heapSize - 1);
169         }
170
171     }
172
173     /*
174      * 堆排序
175      * 将大顶堆堆顶元素和最后一个元素交换，调整剩下元素的对结构
176      * 直到调整到最后一个元素就排好序
177      */
178     public void heapSort(ArrayList<Integer>heapList)
179     {
180         int heapSize = heapList.size();
181
182         for(int i = heapSize - 1; i > 0; i--)
183         {
184             swap(heapList, 1, i); //交换堆顶和最后一个元素
185             heapAdjust(heapList, 1, i - 1);
186         }
187     }
188
189     /*
190      *  打印堆元素
191      */
192     public void PrintHeap(ArrayList<Integer> heapList)
193     {
194         for(int i = 1; i < heapList.size(); i++)
195         {
196             System.out.print(heapList.get(i) + " ");
197         }
198
199         System.out.println();
200     }
201
202
203
204     public static void main(String args[])
205     {
206         ArrayList<Integer> heapList = new ArrayList<>(Arrays.asList(null,1,3,4,5,8,2,7));
207
208         BigHeap bigHeap = new BigHeap();
209
210         bigHeap.heapInitAdjust(heapList);
211         bigHeap.PrintHeap(heapList);
212
213         bigHeap.HeapInsert(heapList, 6);
214         bigHeap.PrintHeap(heapList);
215
216         bigHeap.heapSort(heapList);
217         bigHeap.PrintHeap(heapList);
218     }
219 }