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

排序算法

重要性不言而喻,很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解

1、冒泡算法

冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。也就是双重循环就可以搞定的问题但是需要注意下一边界

算法步骤:

1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。

2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

3)针对所有的元素重复以上的步骤,除了最后一个。

4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

<span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort(int[] a) {
		int temp = 0;
		int len = a.length;
		for (int i = 0; i < len; i++) {
			for (int j = 1; j < len - i; j++)
				if (a[j - 1] > a[j]) {
					//注意分清是a[j-1]还是a[j]不然容易出现边界问题
					// 从小到大排序
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
				}
		}
	}</span>

优化的冒泡排序

由于可能在前几次就已经排好序,但是在上一种冒泡排序中仍然需要一直遍历到最后。

优化措施:设置一个标志,如果这一趟发生了交换,则为true,否则为false。明显如果有一趟没有发生交换,说明排序已经完成。

<span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort1(int[] a) {
		int temp = 0;
		int len = a.length;
		boolean flag = true;
		while (flag) {
			flag = false;
			for (int j = 1; j < len - 1; j++)
				if (a[j - 1] > a[j]) {
					// 注意分清是a[j-1]还是a[j]不然容易出现边界问题
					// 从小到大排序
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
					// 设置标志位
					flag = true;
				}
		}
	}</span>

2、快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。

算法步骤:

1) 从数列中挑出一个元素,称为 “基准”(pivot),

2 )重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。

3 )递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

<span style="font-family:Microsoft YaHei;font-size:14px;">	private static void quick_sort(int[] arr, int low, int high) {
		// 解决和合并
		if (low <= high) {
			int mid = partition(arr, low, high);
			// 递归
			quick_sort(arr, low, mid - 1);
			quick_sort(arr, mid + 1, high);
		}

	}

	private static int partition(int[] arr, int low, int high) {
		// 分解
		int pivot = arr[high];
		int i = low - 1;
		int temp;
		for (int j = low; j < high; j++) {

			if (arr[j] < pivot) {
				i++;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		// 交换中间元素和privot
		temp = arr[i + 1];
		arr[i + 1] = arr[high];
		arr[high] = temp;
		return i + 1;

	}</span>

3、归并排序

归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

算法步骤:

1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列

2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

4. 重复步骤3直到某一指针达到序列尾

5. 将另一序列剩下的所有元素直接复制到合并序列尾

<span style="font-family:Microsoft YaHei;font-size:14px;">  public static int[] sort(int[] nums, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左边
            sort(nums, low, mid);
            // 右边
            sort(nums, mid + 1, high);
            // 左右归并
            merge(nums, low, mid, high);
        }
        return nums;
    }  

    public static void merge(int[] nums, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;  

        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (nums[i] < nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }  

        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = nums[i++];
        }  

        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = nums[j++];
        }  

        // 把新数组中的数覆盖nums数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            nums[k2 + low] = temp[k2];
        }
    }  </span>

4、选择排序

选择排序(Selection sort)也是一种简单直观的排序算法。

算法步骤:

1)首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置

2)再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

3)重复第二步,直到所有元素均排序完毕。

<span style="font-family:Microsoft YaHei;font-size:14px;">  public int[] ChoseSort(int[] intArr){
        for(int i=0;i<intArr.length;i++){
            int lowIndex = i;  

            for(int j=i+1;j<intArr.length;j++){
                if(intArr[j]<intArr[lowIndex]){
                    lowIndex = j;
                }
            }  

            //将当前第一个元素与它后面序列中的最小的一个 元素交换,也就是将最小的元素放在最前端
            int temp = intArr[i];
            intArr[i] = intArr[lowIndex];
            intArr[lowIndex] = temp;
        }  

        return intArr;
    } </span>

5、堆排序

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤:

1)创建一个堆H[0..n-1]

2)把堆首(最大值)和堆尾互换

3)把堆的尺寸缩小1,并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4) 重复步骤2,直到堆的尺寸为1

调整堆部分不太好写建议参考http://blog.csdn.net/jdream314/article/details/6634863

最后给出一张各算法的性能比较图

参考:http://www.cricode.com/3212.html

http://blog.csdn.net/morewindows/article/details/7961256

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-10 01:21:03

面试常用算法总结——排序算法(java版)的相关文章

算法学习?挑战高薪的必经之路!让面试官满意的排序算法(图文解析)

让面试官满意的排序算法(图文解析) 这种排序算法能够让面试官面露微笑 这种排序算法集各排序算法之大成 这种排序算法逻辑性十足 这种排序算法能够展示自己对Java底层的了解 这种排序算法出自Vladimir Yaroslavskiy.Jon Bentley和Josh Bloch三位大牛之手,它就是JDK的排序算法--java.util.DualPivotQuicksort(双支点快排) 想看以往学习内容的朋友可以看我的GitHub:https://github.com/Meng997998/And

微博URL短网址生成算法原理及(java版、php版实现实例)

短网址(Short URL),顾名思义就是在形式上比较短的网址.通常用的是asp或者php转向,在Web 2.0的今天,不得不说,这是一个潮流.目前已经有许多类似服务,借助短网址您可以用简短的网址替代原来冗长的网址,让使用者可以更容易的分享链接. 例如:http://t.cn/SzjPjA 短网址服务,可能很多朋友都已经不再陌生,现在大部分微博.手机邮件提醒等地方已经有很多应用模式了,并占据了一定的市场.估计很多朋友现在也正在使用. 看过新浪的短连接服务,发现后面主要有6个字符串组成,于是第一个

算法学习-排序算法

数据结构-算法复杂度 时间复杂度 事件频度 一个算法花费的时间与算法种语句的执行次数成正比,哪个算法种语句执行次数多,它花费时间就多. 一个算法中的语句执行次数称为语句频度或时间频度.记为T(n) eg:计算1-100的和 方法一:for循环 T(n) = n + 1 方法二:直接计算 T(n) = 1 时间复杂度 一般情况下,算法中的基本操作语句的重复执行次数时问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n) / f(n) 的极限值为不等于0的常

在Object-C中学习数据结构与算法之排序算法

笔者在学习数据结构与算法时,尝试着将排序算法以动画的形式呈现出来更加方便理解记忆,本文配合Demo 在Object-C中学习数据结构与算法之排序算法阅读更佳. 目录 选择排序 冒泡排序 插入排序 快速排序 双路快速排序 三路快速排序 堆排序 总结与收获 参考与阅读 选择排序 选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n2) 的时间复杂度.所以用到它的时候,数据规模越小越好.唯一的好处可能就是不占用额外的内存空间了吧. 1.算法步骤 首先在未排序序列中找到最小(大)元素,存放到排

【C/C++学院】0907-象棋五子棋代码分析/寻找算法以及排序算法

象棋五子棋代码分析 编译代码报错: 错误 1 error MSB8031: Building an MFC project for a non-Unicode character set is deprecated. You must change the project property to Unicode or download an additional library. See http://go.microsoft.com/fwlink/p/?LinkId=286820 for mo

STL算法之排序算法

STL排序算法通常复杂度坏于线性,且必须要random-access Iterators. 所以,forward_list, list, associative and unordered contains 不提供随机访问迭代器,这些容器不能用排序算法. 但是,forward_list,list提供了成员函数sort,associative contains 自动排序,unordered contains不能排序. 通常,排序元素一次要比保持元素有序要更快.STL提供了不同的排序算法,根据需求选

c/c++ 通用的(泛型)算法 之 只读算法,写算法,排序算法

通用的(泛型)算法 之 只读算法,写算法,排序算法 只读算法: 函数名 功能描述 accumulate 求容器里元素的和 equal 比较2个容器里的元素 写算法 函数名 功能描述 fill 用给定值,覆盖给定的范围的元素 fill_n 用给定值,覆盖给定开始位置后的,n个元素变 back_inserter 在容器末尾插入元素 copy 把容器1指定范围里的值拷贝给容器2,并返回指向容器2最后一个元素的下个元素 replace 用某个值替换掉给定范围的某个值 replace_copy 用某个值替

算法之排序算法总结

算法之排序算法总结 | Carrie博客 全部 全部 博客 友链 关于 ps:这里的排序都是从小到大进行排列. 冒泡排序 算法思想:从第一个数开始,将两个相邻的数进行比较,如果前一个数大于后一个数,则互换位置,否则保持不变.这样比较一趟,可以把最大的数放在末尾(根据循环的趟数决定).依次循环,直到排序完成. 时间复杂度:O(n^2) 大专栏  算法之排序算法总结li>空间复杂度:O(1) 选择排序 算法思想:从待排序的数字中找出最小的数,放在排序数字的最开始,之后依次在未排序的数字中选出最小的数

[转载]图解程序员必须掌握的Java常用8大排序算法

这篇文章主要介绍了Java如何实现八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序,分享给大家一起学习. 分类1)插入排序(直接插入排序.希尔排序)2)交换排序(冒泡排序.快速排序)3)选择排序(直接选择排序.堆排序)4)归并排序5)分配排序(基数排序) 所需辅助空间最多:归并排序所需辅助空间最少:堆排序平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一