面试常用算法之排序(1)

package algorithm.sort;

/**
 * @Auther: AaronPi
 * @Date: 2019-4-27 23:01
 * @Description:
 * 稳定性:待排序的序列中有想等值得元素排序后元素之间原有的先后顺序不变
 * 原地排序算法:特指空间复杂度为O(1)的排序算法
 */
public class BaseSort {

    /**
     * 冒泡排序:最多排序n次能出结果,第一次排序能找到最大数放在最后,
     * 如此反复第k次排序能找到排第k大的数,所以每次排序对前n-k个数排序即可,所以第k次找到n-k-1)个数即可。
     * 并且,如果任何数据交换说明已经全部排好了,可以提前结束。
     *
     * 空间复杂度O(1) ->原地排序算法
     * 稳定的算法,相同大小不会改变顺序
     * 平均时间复杂度为O(n^2)
     */
    public static int[] bubbleSort(int[] array){
        int n = array.length;
        boolean flag = false;
        if(n != 0 && n != 1){
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n-i-1; ++j) {
                    if (array[j] > array[j + 1]) {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                        flag = true;
                    }
                }
                if(!flag){
                    return array;
                }
            }
        }
        return array;
    }

    /**
     * 插入排序
     * 是原地排序算法,
     * 稳定
     * 平均时间复杂度为O(n^2)
     * 最好时间复杂度为O(n)
     * 最坏时间复杂度为O(n^2)
     */
    public static int[] insertSort(int[] array){
        int n = array.length;
        if(n > 1){
            for (int i = 1; i < n; ++i) {
                int value = array[i];
                int j = i-1;
                for (; j >= 0; --j) {
                    if(array[j] > value){
                        array[j+1] = array[j];
                    }else{
                        break;
                    }
                }
            }
        }
        return array;
    }

    /**
     * 选择排序
     * 思想:把数组分成已排序和未排序两部分,每次把未排序中最小的元素放在已排序部分的末端(交换)
     * 是原地排序算法
     * 不稳定
     * 平均时间复杂度为O(n^2)
     * 最好时间复杂度为O(n^2)
     * 最坏时间复杂度为O(n^2)
     */
    public static int[] selectionSort(int[] array){
        int n = array.length;
        for (int i = 0; i < n-1; i++) {
            int minIndex = i;
            //找出当前剩余未排序元素中最小的位置
            for (int j = i+1; j < n-1; j++) {
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
            }
            //把上边排出的当前次小元素和未排序数组的头交换
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;

        }
        return array;
    }

    public static void printAll(int[] array){
        for(int i : array){
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        int[] test = {1, 6, 8, 3, 2};
        int[] bubbleResult = bubbleSort(test);
        int[] selectionResult = selectionSort(test);
        printAll(selectionResult);
    }
}

原文地址:https://www.cnblogs.com/pipicai96/p/11407559.html

时间: 2024-10-10 15:09:58

面试常用算法之排序(1)的相关文章

面试常用算法总结——排序算法(java版)

排序算法 重要性不言而喻,很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解 1.冒泡算法 冒泡排序(Bubble Sort)也是一种简单直观的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端.也就是双重循环就可以搞定的问题但是需要注意下一边界 算法步骤: 1)比较相邻的元素.如果第一个比第二个大,

面试常用算法之排序(2)

归并排序 package algorithm.sort; /** * @Auther: AaronPi * @Date: 2019-5-6 21:32 * 归并排序 * 思想:(分治法->用递归来实现)把数组从中间分成两部分,分别排序,再组合在一起 * 思路很巧妙,需要尤其注意边界条件.判断剩余元素等事项 */ public class MergeSort { // 归并排序算法, a是数组,n表示数组大小 public static void mergeSort(int[] a, int n)

面试常用算法之排序(3)

快速排序 package algorithm.sort; /** * 快速排序 * 思想:类似于归并排序,但是不同于归并排序每次排序寻找一次子数组中点的是,寻找一个更恰当的分区点 * * @Author 28370 * @Date 2019-5-13 **/ public class QuickSort { public static void main(String[] args) { int[] a= {1,7,4,8,5,3,9,2}; quickSort(a); for (int i =

常用算法之排序算法三【快速排序】

快速排序是东尼·霍尔在1962提出的划分交换排序,并采用一种分治的策略.在这,我们先总结一下:快速排序 = 划分交换排序 + 分治.然后我们在一一介绍他. 划分交换排序 在讨论它时,感觉有种看了崔颢<黄鹤楼>之后,再去写黄鹤楼的感觉,因为MoreWindows写 得白话经典算法系列之六 快速排序 快速搞定已经足够出色了.我在这只是进行简单的复述,你需要了解更多请看他的博文. 先来看看划分交换排序的具体算法描述: 1.从数列中选出一个数作为基准 2.从数组中选出比它大的数放右边,比它小的数放左边

常用算法之排序算法四【归并排序】

归并排序是将排好序的序列逐步合成一个大序列的算法,从字面上来分析,主要分为归并和排序. 算法描述: 1.申请一块空间,大小为两个排好序序列长度之和,用来存放归并后的序列. 2.设两个指针,分别指向两个已经排好序的序列的起始地址. 3.比较两个指针指向位置的值大小,根据升序降序,选择较小值或者较大值存储在合并空间内,并将相应指针后移. 4.重复3操作,直至指针移至序列尾部. 5.将另一个序列的值全部合并至合并序列中. 先抛开描述,说说自己的理解,就是把一个短有序序列合并成一个新的长有序序列,就是它

C# 常用算法之-排序算法【原创独家】

前段时间因为项目需要,做了个用来对数组排序的类,顺便把以前学过的几种排序算法用C#实现一下.用C#的一些机制来诠释了一下算法的是实现.在阅读本之前,需要一些对C#的有些基本的了解,了解方法参数中out ,ref的作用,掌握面向对象的一些基本思想. 1. 插入排序 1.1. 基本思想: 每次将一个待排序的数据元素,插入到前面已经排好序的数列中的适当位置,使数列依然有序:直到待排序数据元素全部插入完为止. 1.2. 排序过程: [示例]: [初始关键字] [49] 38 65 97 76 13 27

Java学习资料-Java常用算法-选择排序算法

ChooseSort源程序public class ChooseSort { private static void ChooseSort (int [] a){  for(int i = 0; i < a.length; i++){   //对数组循环,假设数据排在前面的元素总比后面的小,然后与后面的数据进行比较   int k = i;   for(int j = i+1; j <a.length; j++){//对数据遍历,寻找最小的数据元素的数组下标    if(a[j]<a[k

PHP面试常用算法

一.冒泡排序 基本思想: 对需要排序的数组从后往前(逆序)进行多遍的扫描,当发现相邻的两个数值的次序与排序要求的规则不一致时,就将这两个数值进行交换.这样比较小(大)的数值就将逐渐从后面向前面移动. //冒泡排序 1 <?php 2 3 function mysort($arr) 4 { 5 for($i = 0; $i < count($arr); $i++) 6 { 7 $isSort = false; 8 for ($j=0; $j< count($arr) - $i - 1; $

PHP面试常用算法(推荐)

一.冒泡排序 基本思想: 对需要排序的数组从后往前(逆序)进行多遍的扫描,当发现相邻的两个数值的次序与排序要求的规则不一致时,就将这两个数值进行交换.这样比较小(大)的数值就将逐渐从后面向前面移动. //冒泡排序 <?php function mysort($arr) { for($i = 0; $i < count($arr); $i++) { $isSort = false; for ($j=0; $j< count($arr) - $i - 1; $j++) { if($arr[$