四种简单的排序算法
部分排序算法总结
冒泡排序
原理：
- 相连两个数据两两比较，后者小于前者，交换位置，执行第一趟比较后，最后一个位置的元素一定是最大的元素；
- 第二趟重复以上过程，直到比较到倒数第二个位置结束，倒数第二个位置一定是次最大的
- 重复上述过程，直到最后一趟比较完成，整个数据完成排序
源码：
void burbSort(int number[], int length){
int i, j, temp;
i = length;
while(i > 0){
for(j = 0; j < i; j++){
if(number[j] > number[j + 1]){
temp = number[j];
number[j] = number[j+1];
number[j+1] = temp;
}
}
i = j - 1;
printArray(number, 0, length);
}
}
总结：
排序过程为相邻数据比较，不存在跳跃数据比较，比较稳定，时间复杂度n(n+1)/2,即为O(n^2)；
当数据末端已经有序或者部分有序，基本冒泡仍然会对齐排序，可以进行改进，减少排序次数：
没排序一次，就记录这次最后交换数据的位置，该位置后面的数据表示已经排好了顺序；下次排序终点就在这个位置结束
同时，可以使用双向冒泡排序，从前往后，排升序，在从后往前，排降序
插入排序
原理：
假设把一个元素插入到一个已经排好顺序的数据列表，从第一个元素开始比较，如果比插入元素小，在比较第二个，以此类推…，如果其中一个比插入的元素大，那该元素及其以后的数据后移一位，插入元素插入到这个位置；插入排序就是按照这个原理，默认把第二个元素当做插入元素插入到前一个元素的数据列表，在把第三个元素插入到前两个元素的数据列表，以此类推完成排序
源码：
void insertSort(int number[], int length){
int i,j;
int temp;
printArray(number, 0, length);
for(i = 0; i < length - 1; i++){
j = i + 1;
temp = number[j];
while(j != 0 && temp < number[j - 1]){
number[j] = number[j - 1];
j--;
}
if(j != i +1){
number[j] = temp;
}
printArray(number, 0, length);
}
}
总结：
插入排序的效率时间和元素个数以及数据排列顺序的程度有关，最佳情况就是已经排好顺序的情况，最差的情况是倒序的数据排序情况，时间复杂度为O(n^2)
快速排序
原理：
- 选择数据列表中任意一个元素作为分割点数据（后称关键数据），默认是列表第一个数据
- 对比整个列表数据，比关键数据大的数据移动到关键数据后面，比关键数据小的移动到关键数据前面
- 这样就分成了两个数据表，并且关键数据的位置一定是确定好了
- 把分割好的两个表重复上述过程进行分割字表，直到字表里面的个数为1时结束比较
源码：
int splitArray(int number[], int start, int end){
int value = number[start];
printf("------------------------------------------");
while(start < end){
while(value < number[end] && start < end){
end--;
}
if(start >= end)
break;
number[start] = number[end];
printf(" %d ", number[start]);
start++;
while(value > number[start] && start < end){
start++;
}
if(start >= end)
break;
number[end] = number[start];
printf(" %d ", number[end]);
end--;
}
number[end] = value;
printf("------------------------------------------\n");
printArray(number, 0, 17);
return end;
}
void quickSort(int number[], int start, int end){
int mIndex;
// printArray(number, start, end + 1);
if(start < end){
mIndex = splitArray(number, start, end);
quickSort(number, start, mIndex - 1);
quickSort(number, mIndex + 1, end);
}
}
总结：
快速排序相对来说是一种比较快的排序，因为它是属于跳跃式排序，比某个值大的数据放到一边，小的放到另一边，交换数据的位置变大了，总的数据交换次数就少了；最差的情况就是相邻数据的交换，在最差的情况下时间复杂度是O(n^2),平均复杂度是O(nlogn)
堆排序
原理：
了解排序原理前需要先弄明白两个定义：
完全二叉树：
如果一个二叉树深度为h，则除h层外的其它层，叶子节点必须全部都有，并且第h层的所有节点是先左后右；
最大堆和最小堆
最大堆 – 所有节点必须大于它的子节点，堆顶为整个数据列表的最大值
最小堆 – 所有节点必须小于它的子节点，堆顶为整个数据列表的最小值
二叉树的特性：
树的深度height = length / 2 - 1
当前节点的位置为index，则它左右子节点分别为2index + 1和 2index + 2
- 把数据列表构造成一个完全二叉树，假设以最大堆的方式排列
- 从index = length / 2 - 1的位置开始比较，比较该index节点和其左右子节点，如果子节点比它大，交换位置；如果小，在把子节点中大的一个节点比较其它的子节点
- index–,重复上面第二个步骤，最终index=0的时候，将在堆顶得到一个最大值
- 将堆顶的最大值和最后一个叶子节点交换位置
- 在从倒数第二个叶子节点开始，重复上面第二个步骤进行最大堆比较，再把堆顶元素和倒数第二个叶子节点交换位置
- 依次类推，重复比较，直至比较完成
源码：
void heapSort(int number[], int startIndex, int endIndex){
int parentNode = startIndex;
int childNode = 2 * parentNode + 1;
int parentNodeValue = number[startIndex];
for(; childNode <= endIndex; parentNode = childNode, childNode = 2 * childNode + 1){
if(childNode < endIndex && number[childNode] < number[childNode+1]){
childNode++;
}
if(parentNodeValue < number[childNode]){
number[parentNode] = number[childNode];
number[childNode] = parentNodeValue;
}else{
break;
}
}
}
void maxHeapSort(int number[], int length){
int i;
int j;
int temp;
for(i = length / 2 - 1; i >= 0; i--){
heapSort(number, i, length - 1);
}
j = length - 1;
for( i = 0; i < length - 1 ; i++){
temp = number[0];
number[0] = number[j];
number[j] = temp;
j--;
heapSort(number, 0, j);
}
}
堆排序的时间复杂度为O(nlogn)
总结：
对于大数据的处理： 如果对100亿条数据选择Topk数据，选择快速排序好还是堆排序好？ 答案是只能用堆排序。
堆排序只需要维护一个k大小的空间，即在内存开辟k大小的空间。而快速排序需要开辟能存储100亿条数据的空间
树扩展阅读
平衡二叉书
- 所有节点，左子树上所有节点比叶节点小，右节树上所有节点比叶节点大，并且左右子树上的节点也满足这个特性
- 且左右子节点高度差绝对值不能大于1
第二个条件怎么理解，就是左右子节点各自从自己树下面的叶子节点从下往上数高度，而不是从根节点开始数，那样数两个高度始终一样；
平衡二叉书是一种有序排列的数，故查询效率较高O(log n)；但是每次插入或者删除时涉及到树的旋转
树的前序：
（1）访问根结点。
（2）前序遍历左子树。
（3）前序遍历右子树 。
中序、后序同理
前序：根-> 左 -> 右
中序：左->根 -> 右
后序：左 -> 右 -> 根
关键点在于，打印输出value的位置，如下是前序：
public void preOrderTraverse1(TreeNode root) {
if (root != null) {
System.out.print(root.val+" ");
preOrderTraverse1(root.left);
preOrderTraverse1(root.right);
}
}
对应中序：
public void preOrderTraverse1(TreeNode root) {
if (root != null) {
preOrderTraverse1(root.left);
System.out.print(root.val+" ");
preOrderTraverse1(root.right);
}
}
还有一种红黑树，查询复杂度是O(lg n)可以参考这篇文章
归并排序
https://www.cnblogs.com/chengxiao/p/6194356.html
