算法导论第二章

插入排序源码:

 1 #include <iostream>
 2 #include <cstdio>
 3
 4 using namespace std;
 5
 6 void insert_sort(int a[])
 7 {
 8     for(int j=1;j<10;j++)
 9     {
10         int key=a[j];
11         int i=j-1;
12         while(i>=0 && a[i]>key)
13         {
14             a[i+1]=a[i];
15             i--;
16         }
17         a[i+1]=key;
18     }
19 }
20
21 int main()
22 {
23     int a[10];
24     int i;
25     for(i=0;i<10;i++)
26         scanf("%d",&a[i]);
27     insert_sort(a);
28     for(i=0;i<10;i++)
29         printf("%3d",a[i]);
30     puts("");
31     return 0;
32 }

逆序输出:

 1 #include <iostream>
 2 #include <cstdio>
 3
 4 using namespace std;
 5
 6 void insert_sort(int a[])
 7 {
 8     for(int j=1;j<10;j++)
 9     {
10         int key=a[j];
11         int i=j-1;
12         while(i>=0 && a[i]<key)
13         {
14             a[i+1]=a[i];
15             i--;
16         }
17         a[i+1]=key;
18     }
19 }
20
21 int main()
22 {
23     int a[10];
24     int i;
25     for(i=0;i<10;i++)
26         scanf("%d",&a[i]);
27     insert_sort(a);
28     for(i=0;i<10;i++)
29         printf("%3d",a[i]);
30     puts("");
31     return 0;
32 }

分治法:合并排序

对于两堆以排好序的,最底层的运行逻辑:

 1 #include <iostream>
 2 #include <cstdio>
 3 #define inf 1e9
 4 using namespace std;
 5
 6 void merge_sort(int a[],int p,int q,int r)
 7 {
 8     int n1=q-p+1;
 9     int n2=r-q;
10     int i,j;
11     int L[n1+1],R[n2+1];
12     for(i=0;i<n1;i++)
13         L[i]=a[p+i];
14     for(i=0;i<n2;i++)
15         R[i]=a[q+i+1];
16
17     L[n1]=inf;R[n2]=inf;
18     i=0;j=0;
19     for(int k=p;k<=r;k++)
20     {
21         if(L[i]<=R[j])
22         {
23             a[k]=L[i];
24             i++;
25         }
26         else
27         {
28             a[k]=R[j];
29             j++;
30         }
31     }
32 }
33
34
35 int main()
36 {
37     int i;
38     int a[10];
39     for(i=0;i<10;i++)
40         scanf("%d",&a[i]);
41     merge_sort(a,0,4,9);
42     for(i=0;i<10;i++)
43         printf("%3d",a[i]);
44     puts("");
45     return 0;
46 }

时间: 2024-08-03 22:28:54

算法导论第二章的相关文章

算法导论 第二章

2014-12-02 20:21:40 http://www.cnblogs.com/sungoshawk/p/3617652.html 上面链接指向算法导论第二章的预习博客,很值得一看,很详细. 插入算法: 1 #include <iostream> 2 3 using namespace std; 4 void insert_sort(int *datas, int length); 5 int main() 6 { 7 int a[10]={1,2,4,35,6,1,4,7,9,7};

算法导论第二章C++实现归并算法排序

归并算法排序的思想算法导论中讲的还算比较清楚. #include<iostream> using namespace std; void guibing(int *_array,int p,int q,int r); void merge_sort(int *_array,int p,int r); int main() { int a[8]={2,4,5,7,1,2,3,6}; int j1=0; int j2=7; merge_sort(a,j1,j2); int i=0; for(;i&

算法导论 第二章作业

//作业2. 1-2 template<class T> void insert(T* A, int  n) { for (int j = 1; j < n; ++j) { T key = A[j]; int i = j - 1; while (i >= 0 && key > A[i]) { A[i + 1] = A[i]; --i; } A[i + 1] = key; } } //2. 1-3 template<class T> void fin

【算法导论第二章】算法基础

2.1插入排序 扑克牌这个栗子不错.以后得多用扑克牌来形象化思考排序问题. 根据伪代码用java实现插入排序 package com.panjn.java; /** * Created by panjianning on 2016/7/10. */ public class InsertionSort { public static void main(String[] args) { int[] array = new int[]{1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

算法导论--第二章、插入排序

1. 插入排序类似于整理扑克牌(排列好顺序的扑克和待排序的扑克): 2. 插入排序(INSERTION-SORT)参数是一个数组A[1..n]共n个数,输入的各个数字原地排序(sorted in place),分为排好序的和待排序的,每次取一个待排序元素,找到插入的位置,插入已排好序的部分中.元素取完程序结束,复杂度为O(n^2): 3. 伪代码如下: INSERTION-SORT(A) for j <- 2 to length(A) do key <- A[j] //Insert A[j]

算法导论 第一章

算法导论 第一章,为了让自己基本功更加的扎实,从今天起开始学习算法导论. 我以一位学长的博客为学习的参考资料,开始我的学习吧! 附上一句话: Having a solid base of algorithm knowledge and technique is one characteristic that separates the truly skilled programmers from the novices. 是否具有扎实的算法知识和技术基础,是区分真正熟练的程序员与新手的一项重要特

补基础:自学:计算机科学导论 第二章 数字系统

2.2 位置化数字系统 在数字中符号所占据的位置决定了其表示的值.在该系统中,数字这样表示: +-(Sk-1  --S2S1S0 --S-l)b 它的值是: n = +-(Sk-1 * bk-1 + -- + S1 * b 1 + S0 * b0 + S-1 * b-1 + -- + S-l * b-l) S是一套符号集,:b是底(或基数),它等于S符号集中的符号总数. 2.2.1 十进制系统(以10为底) 十进制(decimal)来源于拉丁词根decem. 在该系统中,底b = 10, 并且用

算法导论第九章中位数和顺序统计量(选择问题)

本章如果要归结成一个问题的话,可以归结为选择问题,比如要从一堆数中选择最大的数,或最小的数,或第几小/大的数等, 这样的问题看似很简单,似乎没有什么可研究的必要,因为我们已经知道了排序算法,运用排序+索引的方式不就轻松搞定了?但细想,排序所带来的时间复杂度是不是让这个问题无形之中变得糟糕.那算法研究不就是要尽可能避免一个问题高复杂度地解决,让那些不敢肯定有无最优解的问题变得不再怀疑,这也是算法研究者所追求的一种极致哲学.既然排序让这个问题解决的性能无法确定,那我们就抛开排序,独立研究问题本身,看

MIT算法导论——第二讲.Solving Recurrence

本栏目(Algorithms)下MIT算法导论专题是个人对网易公开课MIT算法导论的学习心得与笔记.所有内容均来自MIT公开课Introduction to Algorithms中Charles E. Leiserson和Erik Demaine老师的讲解.(http://v.163.com/special/opencourse/algorithms.html) 第二节-------渐近符号.递归及解法 Solving Recurrence 第二节课的内容比较偏数学化,没有算法方面的知识.但尽管