冒泡排序与简单选择排序——Java实现

1、冒泡排序

1)原理说明:重复遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

2)代码实现:

package com.test.sort;

public class BubbleSort
{

    public static void sort(int[] data)
    {
        for (int i = 0; i < data.length; i++)
        {
            for (int j = data.length - 1; j > i; j--)
            {
                if (data[j] < data[j - 1])
                {
                    swap(data, j, j - 1);
                }
            }
        }
    }

    private static void swap(int[] data, int a, int b)
    {
        int temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }

    public static void main(String[] args)
    {
        int[] data = new int[] { 3, 5, 55, 34, 67, 3, 78, 3423, 675, 4567 };
        sort(data);
        System.out.print("result is: {");

        for (int temp : data)
        {
            System.out.print(temp + "  ");
        }

        System.out.print("}");

    }
}

2、简单选择排序

1)原理说明:简单选择排序的基本思想非常简单,即:第一趟,从n 个元素中找出关键字最小的元素与第一个元素交换;第二趟,在从第二个元素开始的n-1 个元素中再选出关键字最小的元素与第二个元素交换;如此,第k 趟,则从第k 个元素开始的n-k+1 个元素中选出关键字最小的元素与第k
个元素交换,直到整个序列按关键字有序。

2)代码实现:

package com.test.sort;

public class SelectSort
{

    public static void sort(int[] data)
    {
        for (int i = 0; i < data.length; i++)
        {
            int index = i;
            for (int j = data.length - 1; j > i; j--)
            {
                if (data[j] < data[index])
                {
                    index = j;
                }
            }

            swap(data, i, index);
        }
    }

    private static void swap(int[] data, int a, int b)
    {
        int temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }

    public static void main(String[] args)
    {
        int[] data = new int[] { 3, 5, 55, 34, 67, 3, 78, 3423, 675, 4567 };
        sort(data);
        System.out.print("Select sort result is: {");

        for (int temp : data)
        {
            System.out.print(temp + "  ");
        }

        System.out.print("}");

    }

}

冒泡排序与简单选择排序——Java实现

时间: 2024-10-10 04:19:25

冒泡排序与简单选择排序——Java实现的相关文章

排序(二)__冒泡排序、简单选择排序和直接插入排序

前面<排序(一)__综述>提到按照算法的复杂度分为简单算法和改进算法两大类,本文主要就简单算法中的冒泡排序.简单选择排序和直接插入排序进行通俗详细的解析. 一.冒泡排序 1.基本概念 冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.(动态图来自维基百科) 2.关键代码(优化之后) void BubbleSort(SqList *L) { int i,j; Status flag=TRUE;            //flag用作标记,避

直接插入排序、二分插入排序、希尔排序、冒泡排序与简单选择排序

一.直接插入排序 稳定,时间复杂度:最好O(n).最差O(n^2).平均O(n^2),空间复杂度O(1) void InsertSort(int L[], int n) { int i, j,key; for (i = 1; i<n; i++) if(L[i] < L[i-1])//需要将L[i]插入到有序表L[0...i-1] { key = L[i]; for(j = i-1; j >= 0 && key < L[j]; j--)//后移 L[j+1] = L[

七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)

 写在前面: 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.因此排序掌握各种排序算法非常重要.对下面介绍的各个排序,我们假定所有排序的关键字都是整数.对传入函数的参数默认是已经检查好了的.只是简单的描述各个算法并给出了具体实现代码,并未做其他深究探讨. 基础知识: 由于待排序的记录数量不同,使得排序过程中设计的存储器不同,可将排序方法分为两大类:一类是内部排序,指的是待排序记录存放在计算机随机存储器中进行的排序过程.另一类是外部排序,

排序算法学习之简单排序(冒泡排序,简单选择排序,直接插入排序)

一.冒泡排序 冒泡排序算是最基础的一种算法了,复杂度为O(N^2),其基本思想是:从最低端数据开始,两两相邻比较,如果反序则交换.代码如下: /*最基本的冒泡排序*/ void BubbleSort1 (int n, int *array) /*little > big*/ { int i, j; for (i=0; i<n-1; i++) { for (j=n-1; j>i; j--) { if (array[j] < array[j-1]) { int temp = array

冒泡排序、简单选择排序、直接插入排序

冒泡排序(Bubble Sort)的基本思想:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.时间复杂度为O(n2). 简单选择排序(Simple Selection Sort)的基本思想:通过n-i次关键字之间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i个记录交换.应该说,尽管与冒泡排序同为O(n2), 但简单选择排序的性能上还是要略优于冒泡排序. 直接插入排序(Straight Insertion Sort)的基本思想:将一个记录插入到前面已经排序好的有序表中

冒泡排序、简单选择排序

冒泡排序:(如升序) 在第一趟排序中,从第一个元素开始,扫描整个待排序元素序列,若相邻的两个元素逆序,则交换位置.直到最后一个元素,此时,最后一个元素必为最大的元素. 第二趟排序,依然从第一个元素开始扫描直到倒数第二个元素. 第三趟排序,从第一个扫描到倒数第三个. ...... 直到只剩一个元素需要扫描. 程序如下: #include<stdio.h> int main() { int arr[]={1,2,3,9,8,7,5,6,4}; int i=0; int j=0; int len=s

冒泡排序and简单选择排序

冒泡排序:(如升序) 在第一趟排序中,从第一个元素开始,扫描整个待排序元素序列,若相邻的两个元素逆序,则交换位置.直到最后一个元素,此时,最后一个元素必为最大的元素. 第二趟排序,依然从第一个元素开始扫描直到倒数第二个元素. 第三趟排序,从第一个扫描到倒数第三个. ...... 直到只剩一个元素需要扫描. 程序如下: #include<stdio.h> int main() { int arr[]={1,2,3,9,8,7,5,6,4}; int i=0; int j=0; int len=s

Java排序算法(二):简单选择排序

[基本思想] 在要排序的一组数中.选出最小的一个数与第一个位置的数交换:然后在剩下的数中再找出最小的与第二个位置的数交换,如此循环至倒数第二个数和最后一个数比較为止. 算法关键:找到最小的那个数.并用变量记住它的下标. [java实现] public class SimpleSelectionSort { public static void main(String[] args) { int[] arr = { 9, 1, 5, 8, 3, 7, 4, 6, 2 }; System.out.p

排序系列 之 简单选择排序及其改进算法 —— Java实现

简单选择排序算法: 基本思想: 在待排序数据中,选出最小的一个数与第一个位置的数交换:然后在剩下的数中选出最小的数与第二个数交换:依次类推,直至循环到只剩下两个数进行比较为止. 实例: 0.初始状态 3,1,5,7,2,4,9,6(共8个数) 1.n=8 个数中,最小数值为1,与第一个数交换:1,3,5,7,2,4,9,6 2.剩下 n-1=7 个数中,最小数值为2,与第二个数交换:1,2,5,7,3,4,9,6 3.剩下 n-2=6 个数中,最小数值为3,与第三个数交换:1,2,3,7,5,4