常用排序与查找

最新推荐文章于 2024-10-01 09:29:45 发布

y_aoyao

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量138

点赞数

分类专栏： java 文章标签： java se

本文链接：https://blog.csdn.net/y_aoyao/article/details/84836031

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

参考文献http://www.cnblogs.com/xwz0528/p/4557743.html

冒泡排序(交换排序)

public class Demo12 {

public static void main(String[] args) {

// 冒泡排序

int[] arr = {34,1,78,9,43};

int temp;

for(int i = 0 ; i < arr.length-1;i++) {//轮

for(int j = 0; j < arr.length-1-i; j++) {//次

            if(arr[j] > arr[j+1]) {

                temp = arr[j];

                arr[j]= arr[j + 1];

                arr[j + 1] = temp;

            }
        }

}
for(int n: arr) {
System.out.println(n);
}
}
}

选择排序

import java.util.Arrays;

public class Demo13 {

public static void main(String[] args) {

// 选择排序

int [] arr = {5,12,3,78,345};

int temp;

for(int i = 0; i < arr.length-1; i++) {//位置

for(int j = i + 1; j < arr.length; j++) {

            if(arr[i] > arr[j]) {

                temp = arr[i];

                arr[i] = arr[j];

                arr[j] = temp;

            }

}

for(int n:arr) {

System.out.println(n);

}

//
System.out.println(Arrays.toString(arr));

}

小顶堆（堆排序）

堆的定义、堆的存储、堆排序

输出堆顶元素（因为它是最值），将堆顶元素和最后一个元素交换，然后从堆顶向下调整

堆排序是一种树形选择排序方法，它的特点是，在排序过程中，将L[1…n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大（或最小）的元素。

堆的定义如下：

n个关键字序列L[1…n]称为堆，当且仅当该序列满足：① L(i)≤L(2i) 且 L(i)≤L(2i+1) 或 ② L(i)≥L(2i) 且 L(i)≥L(2i+1)，其中1≤i≤⌊n/2⌋。

满足情况①的堆称为小根堆，满足情况②的堆称为大根堆。堆的含义表明，完全二叉树中所有非终端结点的值均不大于（或不小于）其左、右孩子结点的值。

堆排序和堆排序 Heap Sort中的实现都挺好的，前者中HeapAdjust用递归实现，后者HeapAdjust采用非递归实现。下面把他们分别贴出

/堆排序(大顶堆) 2011.9.14/

#include

using namespace
std;

void
HeapAdjust(int *a,int i,int size) //调整堆

{

int lchild=2*i;       //i的左孩子节点序号 

int rchild=2*i+1;     //i的右孩子节点序号 

int max=i;            //临时变量 

if(i<=size/2)          //如果i是叶节点就不用进行调整 

{

if(lchild<=size&&a[lchild]>a[max])

    {

        max=lchild;

    }

if(rchild<=size&&a[rchild]>a[max])

    {

        max=rchild;

    }

    if(max!=i)

    {

        swap(a[i],a[max]);

        HeapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆 

    }

}

}

void
BuildHeap(int *a,int size) //建立堆

{

int i;

for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2 

{

    HeapAdjust(a,i,size);    

}

}

void
HeapSort(int *a,int size) //堆排序

{

int i;

BuildHeap(a,size);

for(i=size;i>=1;i--)

{

    //cout<<a[1]<<"

    swap(a[1],a[i]);           //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 

      //BuildHeap(a,i-1);        //将余下元素重新建立为大顶堆 

      HeapAdjust(a,1,i-1);      //重新调整堆顶节点成为大顶堆

}

}

int main(int
argc, char *argv[])

{

 //int a[]={0,16,20,3,11,17,8};

int a[100];

int size;

while(scanf("%d",&size)==1&&size>0)

{

    int i;

    for(i=1;i<=size;i++)

        cin>>a[i];

    HeapSort(a,size);

    for(i=1;i<=size;i++)

cout<<a[i]<<"";