摘要：
http://www.cnblogs.com/ttltry-air/archive/2012/07/29/2613886.htmlhttp://www.cnblogs.com/smallnest/archive/2009/12/19/1627796.html 阅读全文
posted @ 2013-12-31 20:17
博园少主
阅读(130)
评论(0)
推荐(0)
摘要：
#include"stdio.h"#include"stdlib.h"typedef struct SqList{ int * elem; int length; int MaxSize;}SqList;void CreatList(SqList &L){ L.elem=(int *)malloc(100 * sizeof(int)); if(!L.elem) exit(0); else { L.length = 0; L.MaxSize = 100; int i, n; print... 阅读全文
posted @ 2013-12-31 20:14
博园少主
阅读(250)
评论(0)
推荐(0)
摘要：
http://sjjp.tjuci.edu.cn/sjjg/datastructure/ds/web/duoweishuzu/duoweishuzu5.1.htm 阅读全文
posted @ 2013-12-31 20:09
博园少主
阅读(115)
评论(0)
推荐(0)
摘要：
简介 树形结构是一类非常重要的非线性结构，它可以很好地描述客观世界中广泛存在的具有分支关系或层次特性的对象，因此在计算机领域里有着广泛应用，如操作系统中的文件管理、编译程序中的语法结构和数据库系统信息组织形式等。本章将详细讨论这种数据结构，特别是二叉树结构。1.树的相关术语1. 一个结点的子树的个数称为该结点的度。一棵树的度是指该树中结点的最大度数。 2. 树中度为零的结点称为叶结点或终端结点。 3. 树中度不为零的结点称为分枝结点或非终端结点。除根结点外的分枝结点统称为内部结点。 例如在图1中，结点A，B和E的度分别为3，2，0。其中A为根结点,B为内部结点，E为叶结点，树的度为3。 4. 阅读全文
posted @ 2013-12-31 20:03
博园少主
阅读(273)
评论(0)
推荐(0)
摘要：
最优二叉树1．树的路径长度 树的路径长度是从树根到树中每一结点的路径长度之和。在结点数目相同的二叉树中，完全二叉树的路径长度最短。2．树的带权路径长度(Weighted Path Length of Tree，简记为WPL) 结点的权：在一些应用中，赋予树中结点的一个有某种意义的实数。 结点的带权路径长度：结点到树根之间的路径长度与该结点上权的乘积。 树的带权路径长度(Weighted Path Length of Tree)：定义为树中所有叶结点的带权路径长度之和，通常记为： 其中： n表示叶子结点的数目 wi和li分别表示叶结点ki的权值和根到结点ki之间的路径长... 阅读全文
posted @ 2013-12-31 19:56
博园少主
阅读(1034)
评论(0)
推荐(0)
摘要：
线索二叉树 1．定义 n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前趋和后继结点的指针（这种附加的指针称为"线索"）。 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同 阅读全文
posted @ 2013-12-31 19:47
博园少主
阅读(271)
评论(0)
推荐(0)
摘要：
许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树的定义 1.二叉树的递归定义 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不 阅读全文
posted @ 2013-12-31 19:36
博园少主
阅读(529)
评论(0)
推荐(0)
摘要：
广义表 广义表的定义 广义表是线性表的推广。 广义表一般记作LS=(d0,d1,...dn-1)当广义表LS非空时,称第一个元素d0为表头(Head),称其余元素组成的表(d1,d2,...dn-1)是LS的表尾(Tail)。显然，广义表的定义是一个递归的定义，因为在描述广义表时又用到了广义表的概念。下面列举一些广义表的例子。 1) A=( ); A是一个空表，它的长度为0。 2) B=( e ); 广义表B只有一个单元e，B的长度为１。 3) C=( a,( b,c,d ) ); 广义表C的长度为２，两个元素分别为单元素a和子表( b,c,d )。 4) D=( A,B,C ); ... 阅读全文
posted @ 2013-12-31 19:12
博园少主
阅读(747)
评论(0)
推荐(0)
摘要：
线性表的基本概念1.线性表的定义： 线性表（linear list）是具有相同类型的n（n>=0）个数据元素a0,a1,...an-1 组成的有限序列。其中n为线性表的长度，当n=0,时成为空线性表，n>0,成为非空表在数学上，表现为：数据之间具有线性关系，一对一，一对多等2. 线性表中的数据元素要求具有相同类型。3.特征： （1） 有且仅有一个开始节点a0,他没有直接前驱，只有一个直接后继 （2） 有且仅有一个终端节点an-1,它没有直接后继，只有一个直接前驱 （3） 其他节点都有一个直接前驱和直接后继 （4） 元素直接为一对一的线性关系4、线性表中数据元素的相对位置是确定的，. 阅读全文
posted @ 2013-12-31 19:07
博园少主
阅读(362)
评论(0)
推荐(0)
摘要：
简介堆栈和队列都属于线性结构，是两种在运算上受到某些限制的特殊线性表，他们比一般线性表更简单，被广泛应用于类型的程序设计中，可以用来存放许多中间信息，在系统软件设计以及递归问题处理方面都离不开堆栈和队列。栈栈的操作原则是：先进后出，后进先出二、栈的特点 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 也就是说，栈是一种后进先出(Last In First Out)的线性表，简称为LIFO表。三、栈的运算 1.初始化栈：INISTACK(&S) 将栈S置为一个空栈(不含任何元素)。 2.进栈：PUSH( 阅读全文
posted @ 2013-12-31 18:52
博园少主
阅读(430)
评论(0)
推荐(0)
摘要：
（请网友结合前面的排序基本思想来理解排序的稳定性（8种排序的基本思想已经在前面说过，这里不再赘述）不然可能有些模糊） （1）直接插入排序：一般插入排序，比较是从有序序列的最后一个元素开始，如果比它大则直接插入在其后面，否则一直往前比。如果找到一个和插入元素相等的，那么就插入到这个相等元素的后面。插入 阅读全文
posted @ 2013-12-31 18:13
博园少主
阅读(150)
评论(0)
推荐(0)
摘要：
排序算法所有排序算法汇总：http://en.wikipedia.org/wiki/Sort_algorithmcounting sort 资料 ：http://www.cs.miami.edu/~burt/learning/Csc517.091/workbook/countingsort.html基数排序（radix sort） 资料：http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/RadixSort.htm排序算法可以根据不同的特性划分为不同的类别，这些特性有： + 是否是 comparison-based + 时间复杂度... 阅读全文
posted @ 2013-12-31 18:00
博园少主
阅读(169)
评论(0)
推荐(0)
摘要：
C 快速排序 快速排序描述1.从数列中挑出一个元素，称为 "基准"（pivot）2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。示例代码示例代码为C语言，输入参数中，需要排序的数组为arr[]，取出一个元素为pivot，并根据 pivot值，将数组按照大于pivot和小于pivot分为两个区域，递归完成排序。复制代码 1 #include 阅读全文
posted @ 2013-12-31 17:42
博园少主
阅读(274)
评论(0)
推荐(0)
摘要：
排序简介排序简介 排序是数据处理中经常使用的一种重要运算,在计算机及其应用系统中,花费在排序上的时间在系统运行时间中占有很大比重;并且排序本身对推动算法分析的发展也起很大作用。目前已有上百种排序方法，但尚未有一个最理想的尽如人意的方法，本章介绍常用的如下排序方法，并对它们进行分析和比较。1、插入排序（直接插入排序、折半插入排序、希尔排序）； 2、交换排序（起泡排序、快速排序）； 3、选择排序（直接选择排序、堆排序）； 4、归并排序； 5、基数排序；我们所练习的排序主要是内部排序，所谓内部排序，就是整个排序过程都在内存进行的排序，称为内部排序；反之，若排序过程中要进行数据的内、外存交换，则称之为 阅读全文
posted @ 2013-12-31 17:30
博园少主
阅读(257)
评论(0)
推荐(0)
摘要：
排序集锦http://www.cnblogs.com/longyi1234/archive/2010/03/22/1691904.html关于排序，似乎很简单的很常见的概念，却蕴含着很多技术，下面是从不同的角度，对排序的总结：1 按照排序特性分类首先按照排序本身的操作特性可以分为下面几种：插入排序 直接插入排序(Insert Sort) O(n^2)（稳定） 折半插入排序(Binary Insert Sort)（不稳定） 希尔排序(Shell Sort)（不稳定）交换排序 冒泡排序(Bubble Sort) O(n^2)（稳定） 快速排序(Quick Sort)?? O(nlogn)（不稳定） 阅读全文
posted @ 2013-12-31 17:26
博园少主
阅读(181)
评论(0)
推荐(0)
摘要：
http://jsrun.it/norahiko/oxIy 阅读全文
posted @ 2013-12-31 17:23
博园少主
阅读(92)
评论(0)
推荐(0)
摘要：
http://blog.csdn.net/myjava_024/archive/2008/11/04/3220319.aspx冒泡排序 冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。它是O(n^2)的算法。快速排序快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快速排序可以由下面四步组成。（1） 如果不多于1个数据，直接返回。（2） 一般选择序列最左边的值作为支点数据。（3） 将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。（4） 对两边利用递归排 阅读全文
posted @ 2013-12-31 17:01
博园少主
阅读(155)
评论(0)
推荐(0)
摘要：
排序有很多种方法啦，比如：1 直接插入排序 2 希而排序 3 冒泡排序 4快速排序 5堆排序 6合并排序 7基数排序 8外排序 等等，这里总结一些常用的方法，新人可以学习一下。 冒泡排序法 目的：按要求从大到小或从小到大排序。 基本思路：对尚未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。可以看出如果有 n 个元素，那么一共要进行 n-1 轮比较，第 i 轮要进行 j=n-i 次比较。（如：有5个元素，则要进行5-1轮... 阅读全文
posted @ 2013-12-31 16:52
博园少主
阅读(152)
评论(0)
推荐(0)
摘要：
/************************************************************************** * 题目:编写程序实现快速排序与直接选择排序相结合的排序算法。要求对输入 * 的序列，用PARTITION过程分割成小于10个记录为一组的子序列，然后 * 对每个子序列实施直接选择排序。 * 函数： * Swap: 交换两个参数的值 * Rand: 产生 begin至end之间的随机整数 * StraightSelectSort: 直接选择排序 * PARTITION: 分区 * QUICKSOR... 阅读全文
posted @ 2013-12-31 16:28
博园少主
阅读(382)
评论(0)
推荐(0)
摘要：
#includeusing namespace std;void BubbleSort(int *a,int istart,int len)//冒泡排序{ //a为数组，len为数组长度，对a[istart]~a[len-1]进行排序，小浮大沉 //从后面往前两两比较，小的上浮，直到最顶端a[istart]中存放的是剩余数组中最小的数。 for(int i=len;i>istart+1;i--) { if(a[i-2]>a[i-1]) { int temp=a[i-2]; a[i-2]=a[i-1]... 阅读全文
posted @ 2013-12-31 16:13
博园少主
阅读(271)
评论(0)
推荐(0)
摘要：
代码// Ch08sort.cpp : Defines the entry point for the console application.//默认是从小到大排序#include #include #include using namespace std;#define SIZE 10#define MAX 10000//直接插入排序080201//原理：每次将待排序的记录，按其关键字大小插入到前边已经排好序的子文件中的适当位置int InsertSort(int arr[],int len){int temp,j;for(int i=1;i0&&arr[j-1]>t 阅读全文
posted @ 2013-12-31 16:01
博园少主
阅读(161)
评论(0)
推荐(0)
摘要：
typedef用法小结- -注意：本文转自网络，版权归原作者所有。typedeftypedef用法小结- -这两天在看程序的时候,发现很多地方都用到typedef,在结构体定义,还有一些数组等地方都大量的用到.但是有些地方还不是很清楚,今天下午,就想好好研究一下.上网搜了一下,有不少资料.归纳一下:来源一:Using typedef to Curb Miscreant Code Typedef 声明有助于创建平台无关类型，甚至能隐藏复杂和难以理解的语法。不管怎样，使用 typedef 能为代码带来意想不到的好处，通过本文你可以学习用 typedef 避免缺欠，从而使代码更健壮。typedef 阅读全文
posted @ 2013-12-31 15:52
博园少主
阅读(162)
评论(0)
推荐(0)
摘要：
#include#includeusing namespace std;/*简单插入排序:最差时间复杂度:O(n^2)平均时间复杂度:O(n^2)*/void Insertion_Sort(int *a,int n){ int i,j; for(i=2;ia[0];j--) a[j+1]=a[j]; a[j+1]=a[0]; }}/*折半插入排序:最差时间复杂度:O(n^2)平均时间复杂度:O(n^2)*/void Bin_Sort(int *a,int n){ int i,j,low,mid,high; ... 阅读全文
posted @ 2013-12-31 15:49
博园少主
阅读(182)
评论(0)
推荐(0)
摘要：
常用google产品01.谷歌阅读器(Google Reader)：网页版RSS阅读器，方便订阅，组织和分享新闻。有手机版。02.谷歌相册服务(Google Picasa)：提供照片的下载和编辑软件，用这个软件Email，上传，张贴照片到博客，也可以直接使用网络相册。03.:Google浏览器Chrome的特点是简洁、快速。04.谷歌文件(Google Docs)：您不再需要桌面版的Office了，这个是谷歌的在线Office，你可以创建，发布，共享和协作在线文档和幻灯。05.谷歌记事本(Google Notebook)：剪贴文本，图片和链接页面，可以保存，检索或共享。06.谷歌日历(Goog 阅读全文
posted @ 2013-12-31 15:48
博园少主
阅读(242)
评论(0)
推荐(0)
摘要：
题意：给出N个数，将其中重复出现的去掉，再将新的序列进行排序输出；题意：给出N个数，将其中重复出现的去掉，再将新的序列进行排序输出；#include #include int cmp(const void *a, const void *b) { return *(int *)a-*(int *)b; } int main() { int a[101]; int b[101]={0}; int m; int k=0; while(scanf("%d",&m)!=EOF) { int i,j; for(i=0;i<m... 阅读全文
posted @ 2013-12-31 15:44
博园少主
阅读(175)
评论(0)
推荐(0)
摘要：
#include#includetypedef struct list{ int data; struct list*left; struct list*right;}List;void insert_list_2nd(List*head,int data);void insert_list_last(List*head,int data);void insert_list_order(List*head,int data);void print_list(List*head);void delete_list(List*head,int value);int main(){ int i; L 阅读全文
posted @ 2013-12-31 15:24
博园少主
阅读(143)
评论(0)
推荐(0)
摘要：
#include#includetypedef struct list{ int data; struct list*next;}List;List*insert_list_2nd(List*head,int data);List*insert_list_last(List*head,int data);List*insert_list_order(List*head,int data);void print_list(List*head);List*delete_list(List*head,int value);int main(){ List*head=NULL; int i;// f. 阅读全文
posted @ 2013-12-31 15:22
博园少主
阅读(305)
评论(0)
推荐(0)
摘要：
//链表有序插入和删除最重要的是预判，就是判断下一个是否满足要求，因为如果只是判断当前，那么当你找到要操作的节点时，已经过了指向该节点的指针//删除的时候注意释放空间#include#includetypedef struct list{ int data; struct list*next;}List; void insert_list_2nd(List*head,int data);//表头插入 void insert_list_last(List*head,int data);//表尾插入 void insert_list_order(List*head,int data);//有序.. 阅读全文
posted @ 2013-12-31 15:21
博园少主
阅读(391)
评论(0)
推荐(0)
摘要：
这是我根据下面黑体字总结的：深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。广度优先搜索算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。通常 深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。 广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。但广度优先搜索法一般无回.. 阅读全文
posted @ 2013-12-31 15:14
博园少主
阅读(2874)
评论(0)
推荐(0)
摘要：
一、预备知识—程序的内存分配一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）：由编译器(Compiler)自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 4、文字常量区 — 常量字符串就是放. 阅读全文
posted @ 2013-12-31 15:09
博园少主
阅读(215)
评论(0)
推荐(1)
摘要：
(从 逻辑结构 和 内存存储 方面分析)A 从逻辑结构来看A-1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。A-2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）B 从内存存储来看B-1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小B-2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦. 阅读全文
posted @ 2013-12-31 15:06
博园少主
阅读(126)
评论(0)
推荐(0)
摘要：
一，复杂度：O(n log n）基本思想：通过一趟排序讲待排序记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。#include int Partition(int *a, int low, int high){ int pivotkey = a[low]; //注意左右分别对应传入的low high while(low=pivotkey)//中枢要比右边的小 --high; a[low]=a[high];//发现一个比中枢小的，移到左边 ... 阅读全文
posted @ 2013-12-31 15:04
博园少主
阅读(180)
评论(0)
推荐(0)
摘要：
冒泡排序已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较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]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。优点：稳定，比较次数 阅读全文
posted @ 2013-12-31 14:05
博园少主
阅读(191)
评论(0)
推荐(0)
摘要：
选择排序已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。例如定义数组a[]= 阅读全文
posted @ 2013-12-31 14:03
博园少主
阅读(165)
评论(0)
推荐(0)
摘要：
插入排序：的基本思想是：每次将一个特排序的记录，按其关键字大小插入到前面已经拍好序的子文件中的适当位置，直到全部记录插入完成为止。两种排序的算法：直接插入排序：希尔排序:直接插入排序：直接插入排序（Straight Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。改进的方法 一种查找比较操作和记录移动操作交替地进行的方法。 具体做法： 将待插入记录R[i]的关键字... 阅读全文
posted @ 2013-12-31 14:02
博园少主
阅读(162)
评论(0)
推荐(0)
摘要：
这种快速排序的思路是：首先以a[start]为轴，不停得从数组的两端开始比较。从最右端开始，如果有比a[start]小的，那么赋值a[i]；从最左端开始，如果有比a[start]大的，那么赋值a[j]，以此往复，渐渐有序；注意的是递归跳出的条件，只有一个数就不需要排序，即start>=end#include#include#define N 1000000int array[N];void init_array(int a[],int n);void print_array(int a[],int n);void quick_sort(int a[],int start,int end) 阅读全文
posted @ 2013-12-31 14:01
博园少主
阅读(114)
评论(0)
推荐(0)
摘要：
快速排序的思路是:首先拿a[start]作为轴，将原数组中比a[start]小的放small数组，将原数组中比a[start]大的放big数组，最后在将small数组 和a[start]值和big数组中的数复制回原数组。以此递归，使数组逐渐有序。快速排序的平均时间复杂度是nlogn。#include#include#define N 1000000int array[N];int small[N];int big[N];void init_array(int a[],int n);void print_array(int a[],int n);void quick_sort(int a[],i 阅读全文
posted @ 2013-12-31 14:00
博园少主
阅读(141)
评论(0)
推荐(0)
摘要：
折半查找的前提是有序的，与中间值进行比较，如果有序的则返回；否则，改变始末位置，再进行查找实现方法：1 循环实现 2 递归实现1 循环实现#includeint binary_search(int *array,int n,int data);int main(){ int array[10]={ 1,2,3,4,5,6,7,8,9,10 }; printf("please input the number that you want search\n"); int num; scanf("%d",&num); int result=binary 阅读全文
posted @ 2013-12-31 13:56
博园少主
阅读(130)
评论(0)
推荐(0)
摘要：
1，复杂度：O (n log n)2路归并排序的基本思想：n个记录，看作n个有序子序列，每个子序列的长度为1，然后两两归并，得到n/2（向上取整）个长度为2或者1的有序子序列；再两两归并，......，如此重复，知道得到一个长度为n的有序序列位置。#include #include #include #include void merge(int array[], int low, int mid, int high){ int i, k; int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申请空间，... 阅读全文
posted @ 2013-12-31 13:53
博园少主
阅读(210)
评论(0)
推荐(0)
摘要：
1 http://www.cnblogs.com/zabery/archive/2011/07/26/2117103.html2 http://www.cnblogs.com/luchen927/archive/2012/03/08/2381446.html3 http://www.cnblogs.com/chenbin7/archive/2011/10/02/2197933.html 阅读全文
posted @ 2013-12-31 13:51
博园少主
阅读(106)
评论(0)
推荐(0)
摘要：
#include /*头文件*/#define M 100 /*定义常量*/int R[M]; /*定义数组*/int main(){ int i,j,temp,n; printf("input n size:");/*数组大小*/ scanf("%d",&n); printf("input number one by one:\n"); for(i=1;iR[j+1]) /*判断前一个数据元素是否比后一个大，大于则交换*/ { temp=R[j]; ... 阅读全文
posted @ 2013-12-31 13:22
博园少主
阅读(169)
评论(0)
推荐(0)
摘要：
一.直接插入排序（Straight Insertion Sort） 排序的过程如下：给定无需序列：（3，6，9，7，1，8，2，4） ① 3，6，9，7，1，8，2，4 （将6插入到有序序列3中） ② 3，6，9，7，1，8，2，4 （将9插入到有序序列3，6中） ③ 3，6，9，7，1，8，2，4 （将7插入到有序序列3，6，9中） ④ 3，6，7，9，1，8，2，4 （将1插入到有序序列3，6，7，9中） ⑤ 1，3，6，7，9，8，2，4 （将8插入到有序序列1，3，6，7，9中） ⑥ 1，3，6，7，8，9，2，4 （将2插入到有序序列1，3，6，7，8，9中） ⑦ 1，2，3，6，7 阅读全文
posted @ 2013-12-31 13:15
博园少主
阅读(249)
评论(0)
推荐(0)
摘要：
转载 http://www.cnblogs.com/Leo_wl/p/3382120.html让我有点以外的是在数据量达到1W~10W之间，希尔排序竟然比快速排序效率还要高。贴上完整代码！一，冒泡排序 冒泡排序的时间复杂度为O(n²),在数据比较小的情况下各个算法效率差不多。 //冒泡排序//////////////////////////////////////////////////////////////////////////void BubleSort(int a[],int n){ int temp; bool flag=false; for (int i=0;i... 阅读全文
posted @ 2013-12-31 13:09
博园少主
阅读(364)
评论(0)
推荐(0)
摘要：
//C++ 排序方法的总结#include #include using namespace std;/*采用插入法进行排序*/void InsertArray(int a[],int n, int* &b){int temp;int j;for(int i = 0;ia[j+1]) //后者小于前者，交换{temp = a[j];a[j] = a[j+1];a[j+1] = temp;if(j>0){j--;}}}b = a;}/*采用冒泡排序*/void SortArray(int a[], int n){int temp ;for (int i = 1;ia[j+1]){t 阅读全文
posted @ 2013-12-31 12:42
博园少主
阅读(153)
评论(0)
推荐(0)
摘要：
下面贴几个简易的代码吧直接插入排序#include#includeint main(){ int i,j,n; int a[1000]; while(scanf("%d",&n)!=EOF) { for(i=1;i#includeint dlta[4]={8,4,2,1};int n;void shellsort(int a[],int dk){ int i,j; for(i=dk+1;i0&&a[0]#includeint n;int partition(int a[],int low,int high){ int pivotkey; a[0]=a 阅读全文
posted @ 2013-12-31 12:38
博园少主
阅读(132)
评论(0)
推荐(0)
摘要：
排序算法常用的有：当数据量不大时 选择插入或者选择排序,不用冒泡排序;其次,当数据量大而又注重空间复杂性时选择快速排序或堆排序;再次,当数据量大而又允许使用较多附加空间时选择桶排序,最后,当要在已排序数据上增加若干新数据时选择插入排序.------- 摘自.C++数据结构原理与经典问题1、插入排序（直接插入排序、折半插入排序、希尔排序）；2、交换排序（起泡排序、快速排序）；3、选择排序（直接选择排序、堆排序）；4、归并排序； 5、基数排序；排序方法的分类 1．按是否涉及数据的内、外存交换分 在排序过程中，若整个文件都是放在内存中处理，排序时不涉及数据的内、外存交换，则称之为内部排序(简称... 阅读全文
posted @ 2013-12-31 12:34
博园少主
阅读(196)
评论(0)
推荐(0)
摘要：
#includeconst int N = 100;int a[N];/**算法导论第一部分，基础知识。P17 插入排序，复杂度O(n^2)*/void insertion_sort( int *a,int n){ for(int i = 1;i =0&&a[j]>key) { a[j+1]=a[j]; j--; } a[j+1] = key; }}int main(){ int n; while(scanf("%d",&n)!=EOF) { for(int ... 阅读全文
posted @ 2013-12-31 12:29
博园少主
阅读(105)
评论(0)
推荐(0)
摘要：
概述内排序顾名思义待排序元素总数相对与内存而言较小，整个排序过程可以在内存中进行。反之，如果待排序元素总数较多，不能全部放入内存，排序过程需要访问外存，称之为外排序。内排序算法有序多下面是较常见的几种排序算法：按照时间复杂度来划分的话，主要有两种：非线性时间复杂度，下面列举的排序算法的是基于关键字比较和移动两种操作实现的称为“比较排序”，《算法导论》证明过对于任何比较排序在最坏情况下的要Ω(nlgn)次比较来进行排序。1、简单选择排序算法2、直接插入排序算法3、冒泡排序4、快速排序5、两路合并排序6、堆排序线性时间排序，下面的三种算法的用非比较的一些操作来确定顺序。1、计数排序2、基数排序3、 阅读全文
posted @ 2013-12-31 11:47
博园少主
阅读(401)
评论(0)
推荐(0)
摘要：
//快速排序：#include #define MAX 500000int s[MAX];void Q_Sort(int start,int end){ int i,j,t; if ( start >= end ) return ; t = s[start]; i = start; j = end; while ( i = t && i #define MAX 500000int a[MAX];int b[MAX];void Merge(int left,int mid,int right){ int i,j,k; i = left; j ... 阅读全文
posted @ 2013-12-31 11:19
博园少主
阅读(201)
评论(0)
推荐(0)
摘要：
[实验内容]1、直接插入排序2、快速排序3、堆排序（要求了解原理） 【实验测试数据】 输入数据：｛49，38，65，97，76，13，27，49｝#include #define M 8typedef struct{ int key; int other_data;}RecordType;void InsSort(RecordType r[], int length);void QKSort(RecordType r[],int low, int high );int QKPass(RecordType r[],int left,int right);void In... 阅读全文
posted @ 2013-12-31 11:04
博园少主
阅读(164)
评论(0)
推荐(0)
摘要：
1. 相关知识介绍1.1. 稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。1.2. 内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序； 在排序过程中，只有部分数... 阅读全文
posted @ 2013-12-31 10:49
博园少主
阅读(161)
评论(0)
推荐(0)
浙公网安备 33010602011771号