数据结构精要------冒泡与直接排序算法

作为程序员的我们在程序开发的时候经常会用到一些简单的排序算法,例如:对数组进行快速排序;要实现这些就需要运用到数据结构排序算法的知识,那么熟练使用和掌握排序算法对于开发人员来说是百利而无一害。同时记录一下知识点也是自己对自己的进一步巩固总结:

那么何为排序算法呢?

排序是计算机内经常进行的一种操作,其目是一组 “无序 ”的记录序列调整为 “有序 ”的记 录序列。排序分内排序和外排序。

那么何为内排和外排呢?

内排序 :指在排序 期间数据对象全部存放在内存排序。

外排序 :指在排序期间全部对象个数太多, 不能同时存放内存,必须根据派寻过程的要求,不断在内、外存之间移动的排序。

内排序的方法有许多种,按所用策略不同,可归纳为五类:插入排序、选择排序、交换排序、归并排序和分配排序。

--交换排序 主要包括冒泡排序 和 快速排序;

--插入排序 主要包括直接插入排序 和 希尔排序;

--选择排序 主要包括直接选择排序 和 堆排序;

--归并排序 主要包括二路归并(常用的归并排序)和 自然归并排序。

--分配排序 主要包括 箱排序 和 基数排序。

稳定排序:假设在待排序的文件中,存在两个或两个以上的记录具有相同的关键字,在用某种排序法排序后,若这些相同关键字的元素的相对次序仍然不变,则这种排序方法是稳定的。 其中冒泡,插入,基数,归并属于稳定排序; 选择,快速,希尔,堆属于不稳定排序。

时间复杂度是衡量算法好坏的最重要的标志。 排序的时间复杂度与算法执行中的数据比较次数与数据移动次数密切相关。

下面我们一步一步用代码来实现:首先实践交换排序的两种

-----冒泡排序

package com.sort;

/**
 *
 * 冒泡排序
 * @author weixing-yang
 *
 *实现思路:
 * 首先比较 a[1]与 a[2]的值,若 a[1]大于 a[2]则交换两者的值,否则不变。
 * 再比较 a[2]与 a[3]的值,若 a[2]大于 a[3]则交换两者的值,否 则不变。
 * 再比较a[3]与a[4]的值,以此类推,最后比较a[n-1]与a[n]的值。
 * 这样一轮下来,a[n]的指一定是这组数据中最大的。
 * 在对a[1]~a[n-1]的用相同的方法处理一轮。
 * 共处理n-1轮后a[1]、a[2]、...,a[n]就以升序排列了。
 *
 */
public class BubbleSort {
	int temp = 0;
	int i,j,k;
	public void bubbleSort(int[] arr, int n){
		//将i设置为最后一对元素较小的下标
		for (i = n-1; i > 0; i = k) {
			for (k = j = 0; j < i; j++) {
				if(arr[j]>arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					//如发生交换,记录较小的下标
					k = j;
				}
			}
		}
	}
}

-----快速排序

package com.sort;
/**
 *
 * @author weixing-yang
 *
 *实现思路:
 *	通过一次排序将待排序对象分割成独立的两部分。
 *  其中一部分对象的关键码均比另一部分对象的关键码小。
 *  再分别对这两部分子序列对象继续进行排序,以达到整个序列有序。
 */
public class QuickSort {

	public void quickSort(int[] arr,int l, int r){
		if(l >= r)
			return;
		int i = l,           //从左到右的游标
			j = r+1;         //从右到左的游标
		int pivot = arr[l];  //以a[l]为支点
		int temp = 0;
		while(true){
			while (arr[++i] < pivot && i < r); //从左边找>=pivot的元素
			while (arr[--j] > pivot && j > l); //从右边找<=pivot的元素

			if(i >= j) break;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		//将支点a[l]与a[j]交换
		arr[l] = arr[j];
		arr[j] = pivot;
		//递归
		if(l < r)
			quickSort(arr, l, j-1); // 左段快速排序
		if(r > l)
			quickSort(arr, j+1, r); //右段快速排序
	}

}

-----测试函数

package com.sort;

public class Main {

	public static void main(String[] args){
		int[] array = {25, 36, 21, 45, 9, 40, 12, 34, 5, 55};
		int n = array.length;
		BubbleSort bubble = new BubbleSort();
		QuickSort quick = new QuickSort();
		long start = System.currentTimeMillis();
		//bubble.bubbleSort(array, n);//冒泡排序
		quick.quickSort(array, 0, n-1);//快速排序
		long end = System.currentTimeMillis();
		long sum = end - start;
		System.out.println("排序花费的总毫秒数:"+sum);
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+" ");
		}
	}
}

-----运行结果

排序花费的总毫秒数:0
5 9 12 21 25 34 36 40 45 55 

冒泡排序的时间复杂度是n2, 快速排序的时间复杂度是nlogn。

快速排序被认为是最快的内排序算法。当数据量少时,快速排序甚至不及简单的排序算法;此外,当数据本身已有序时,快速排序的效率极低。

@@------->>下篇继续实践插入排序的两种排序算法

数据结构精要------冒泡与直接排序算法,布布扣,bubuko.com

时间: 2024-10-18 06:42:25

数据结构精要------冒泡与直接排序算法的相关文章

数据结构精要------直接选择和堆排序算法

上篇总结中主要实践了算法的内排序的交换排序,那么接下来我们继续实践选择排序的两种:直接选择和堆排序算法. -----直接选择排序 package com.sort; /** * 直接选择排序算法 * @author weixing-yang * * 算法思路: * 首先找出最大元素,将其与a[n-1]位置置换. * 然后在余下的n-1个元素中寻找最大元素,将其与a[n-2]位置置换. * 如此进行下去,知道n个元素排序完成. */ public class SelectSort { public

链表上的冒泡、选择排序算法

做如下定义 typedef struct LNode { int num; char name[20]; struct LNode *next; } LNode, *LinkList; 冒泡排序算法 void BubbleSort(LinkList &L) { LinkList i = NULL, j = NULL; for (i = L; i->next->next != NULL; i = i->next) { for (j =i ; j->next->next

[数据结构(二)]七种排序算法的C++简单实现

一.冒泡排序(Bubble Sort) 基本思想:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止. //冒泡排序 void BubbleSort(int *p, int length) { for (int i = 0; i < length-1; i++) { for (int j =length-1; j>=i;j--) { if (p[j-1] > p[j]) { swap(p[j-1], p[j]); } } } } 排序前的顺序为:9 1 5 8 3 7 4

【数据结构】常见的7种比较排序算法1

● 直接插入排序(Insert Sort) 1.算法描述: 该算法是一种简单直观的是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上只需用到O(1)的额外空间的排序,因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位为最新元素提供插入空间. 2.步骤: 1)从第一个元素开始,该元素可以认为已经被排序 2)取出下一个元素,在已经排序的元素序列中从后向前扫描 3)如果该元素(已排序)大于新元素,将该元素移到下一位置 4)重复步骤3,直到找到已

常见经典排序算法学习总结,附算法原理及实现代码(插入、shell、冒泡、选择、归并、快排等)

博主在学习过程中深感基础的重要,经典排序算法是数据结构与算法学习过程中重要的一环,这里对笔试面试最常涉及到的7种排序算法(包括插入排序.希尔排序.选择排序.冒泡排序.快速排序.堆排序.归并排序)进行了详解.每一种算法都有基本介绍.算法原理分析.算法代码. 转载请注明出处:http://blog.csdn.net/lsh_2013/article/details/47280135 插入排序 1)算法简介 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过

数据结构杂谈(一)浅谈基本排序算法

0.基本概念 记录:待排序的项目 关键词:决定排序结果 稳定性:相同关键词的记录保持原来的相对次序 1.1插入排序(Insertion Sort) 算法思想 一种简单直观的排序算法,工作原理是通过构建有序序列:对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入. 算法描述 具体算法描述如下: 从第一个元素开始,该元素可以认为已经被排序 取出下一个元素,在已经排序的元素序列中从后向前扫描 如果该元素(已排序)大于新元素,将该元素移到下一位置 重复步骤3,直到找到已排序的元素小于或者等于

数据结构——排序算法总结

排序(Sorting)就是将一组对象依照规定的次序又一次排列的过程,排序往往是为检索而服务的.它是数据处理中一种非常重要也非经常常使用的运算.比如我们日常学习中的查字典或者书籍的文件夹.这些都事先为我们排好序,因此大大减少了我们的检索时间,提高工作效率. 排序可分为两大类: 内部排序(Internal Sorting):待排序的记录所有存放在计算机内存中进行的排序过程: 外部排序(External Sorting):待排序的记录数量非常大,内存不能存储所有记录.须要对外存进行訪问的排序过程. 外

(2)Java数据结构--二叉树 -和排序算法实现

=== 注释:此人博客对很多个数据结构类都有讲解-并加以实例 Java API —— ArrayList类 & Vector类 & LinkList类Java API —— BigDecimal类Java API —— BigInteger类Java API —— Calendar类Java API —— DateFormat类Java API —— Date类Java API —— HashMap类 & LinkedHashMap类Java API —— JDK5新特性Java

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

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