算法导论代码笔记(一)

最新推荐文章于 2024-05-13 03:24:23 发布
最新推荐文章于 2024-05-13 03:24:23 发布
阅读量705 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_W1997/article/details/54579832
版权 

插入排序

int i,key;
    for(i=1;i<MAX;++i)
    {
        key = a[i];
        int j;
        for(j=i-1;j>=0&&a[j]>key;--j)
        {
            a[j+1] = a[j];
        }
        a[j+1] = key;
    }


选择排序 

int key;
    for(int i=0;i<MAX;++i)
    {
        for(int j=i+1;j<MAX;++j)
        {
            if(a[i] > a[j])
            {
                int temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
    }


冒泡排序

for(int i=0;i<MAX;++i)
    {
        for(int j=MAX-1;j>=1;--j)
        {
            if(a[j]<a[j-1])
            {
                int temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }

归并排序

int b1[1000];
int b2[1000];
void Merge(int *p, int l, int h1, int h2)
{
	int k = 0,n1 = h1 - l + 1,n2 = h2 - h1;
	for (int i = l; i <= h1; ++i)
		b1[k++] = p[i];
	b1[n1] = MAX_INT;
	k = 0;
	for (int i = h1 + 1; i <= h2; ++i)
		b2[k++] = p[i];
	b2[n2] = MAX_INT;
	k = l;
	for (int i = 0, j = 0; k<=h2;++k)
	{
		if (b1[i] < b2[j])
			p[k] = b1[i++];
		else
            p[k] = b2[j++];
	}


}


void merge_sort(int *p, int l, int h)
{


    if (l < h)
	{
		int n = (h + l) / 2;
        merge_sort(p, l, n);
        merge_sort(p, n + 1, h);


		Merge(p, l, n, h);
	}
}

思考题2-4 
int Merge(int *p, int l, int h1, int h2)
{
    int ans = 0;

	int k = 0,n1 = h1 - l + 1,n2 = h2 - h1;
	for (int i = l; i <= h1; ++i)
		b1[k++] = p[i];
	b1[n1] = MAX_INT;
	k = 0;
	for (int i = h1 + 1; i <= h2; ++i)
		b2[k++] = p[i];
	b2[n2] = MAX_INT;
	k = l;
	for (int i = 0, j = 0; k<=h2;++k)
	{
		if (b1[i] <= b2[j])
			p[k] = b1[i++];
		else
        {
            p[k] = b2[j++];
            ans += n1 - i;
        }
	}

    return ans;
}

int merge_sort(int *p, int l, int h)
{

    int ans = 0;
    if (l < h)
	{
		int n = (h + l) / 2;
        	ans += merge_sort(p, l, n) + merge_sort(p, n + 1, h);

		ans += Merge(p, l, n, h);
	}
	return ans;
}

快速排序

void quick_sort(int *a,int l,int h)
{
    if(l < h)
    {
        int x = l,temp;
        int i=x+1,j=x+1;
        for(;i<=h;++i)
        {
            if(a[i] < a[x])
            {
                temp = a[j];
                a[j++] = a[i];
                a[i] = temp;
            }
        }
        temp = a[j-1];
        a[j-1] = a[x];
        a[x] = temp;

        quick_sort(a,l,j-1);
        quick_sort(a,j,h);


    }
}



随机数优化快速排序 
int Rand(int l,int h)
{
    srand(time(NULL));
    return (rand()%(h-l+1))+l;
}
void Swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void quick_sort(int *a,int l,int h)
{
    if(l < h)
    {
        int x = Rand(l,h);
        Swap(&a[x],&a[l]);
        int i=l+1,j=l+1;
        for(;i<=h;++i)
        {
            if(a[i] < a[l])
            {
                Swap(&a[i],&a[j]);
                ++j;
            }
        }
        Swap(&a[j-1],&a[l]);
        quick_sort(a,l,j-1);
        quick_sort(a,j,h);
    }
}


堆排序

#include <stdio.h>
#include <stdlib.h>

void swap (int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

MinHeapFixDown(int *a,int i,int n)
{
    int j,temp;
    temp = a[i];
    j = 2 * i + 1;
    while(j < n)
    {
        if(j + 1 < n && a[j+1] < a[j])
            ++j;
        if(a[j] >= temp)
            break;
        a[i] = a[j];
        i = j;
        j = 2 * i + 1;
    }
    a[i] = temp;
}
MinHeapFixUp(int *a,int i,int n)
{
    int temp = a[i],j = 2*i+1;
    while(j < n)
    {
        if(j + 1 < n &&a[j+1] > a[j])
            ++j;
        if(a[j] <= temp)
            break;
        a[i] = a[j];
        i = j;
        j = 2 * i + 1;
    }
    a[i] = temp;
}

BuildMinHeap (int *a,int n)
{
    int i;
    for(i = (n / 2) - 1;i>=0;--i)
    {
        MinHeapFixDown(a,i,n);
    }
}

BuildMaxHeap(int *a,int n)
{
    int i = (n / 2) - 1;
    for(;i>=0;--i)
        MinHeapFixUp(a,i,n);
}

DownHeapSort(int *a,int n)
{
    int i;
    BuildMinHeap (a,n);
    for(i = n-1;i>=0;--i)
    {
        swap(&a[i],&a[0]);
        MinHeapFixDown(a,0,i);
    }
}
UpHeapSort(int *a,int n)
{
    BuildMaxHeap(a,n);
    int i = n-1;
    for(;i>=0;--i)
    {
        swap(&a[0],&a[i]);
        MinHeapFixUp(a,0,i);
    }
}
int main()
{
    int a[10] = {32,324,23,24,235,4,34,45,32,36};

    UpHeapSort(a,10);

    int i;
    for(i = 0;i<10;++i)
        printf("%d ",a[i]);

    return 0;
}


计数排序

int a[] = {100,4,2,5,5,6,22,325,666,4};
int b[10];
int c[1000];
void count_sort(int *a,int *b,int l,int h)
{
    memset(c,0,sizeof(c));
    int k = -1;
    for(int i=l;i<=h;++i)
    {
        k = (k>=a[i]?k:a[i]);
        ++c[a[i]];
    }
    for(int i=1;i<=k;++i)
    {
        c[i] = c[i-1] + c[i];
    }
    for(int i=h;i>=l;--i)
    {
        b[--c[a[i]]] = a[i];
    }
}
基数排序 

int a[] = {0x0fff,0x0f0f,0x0ff0,0x000f,0x00ff,0x0f0f,0x00f0,0xffff,0x0000,0x00ff};
int c[256];
void count_sort(int basic,int off,int *a,int *b,int l,int h)
{
    memset(c,0,sizeof(c));
    int k = -1,t;
    for(int i=l;i<=h;++i)
    {
        t = (a[i]&basic)>>(4*off);
        //printf("basic:%x  t:%x\n",basic,t);
        k = (k>=t?k:t);
        ++c[t];
    }
    for(int i=1;i<=k;++i)
    {
        c[i] = c[i-1] + c[i];
    }
    for(int i=h;i>=l;--i)
    {
        t = (a[i]&basic)>>(4*off);
        b[--c[t]] = a[i];
    }
}
//数组初始化为16位 bits=16
void basic_sort(int bits,int *a,int l,int h)
{
    int times = bits / 4;
    int **b = (int**)malloc(times * sizeof(int*));
    for(int i=0;i<times;++i)
    {
        b[i] = (int*)malloc(sizeof(int) * (h-l+1));
    }
    int basic = 0x000f;
    count_sort(basic,0,a,b[0],0,MAX-1);
    /*for (int i = 0; i<MAX; ++i)
		printf("%x ",b[0][i]);
    cout<<endl;
    count_sort(basic<<(4*1),1,b[0],b[1],0,9);
    for (int i = 0; i<MAX; ++i)
		printf("%x ",b[1][i]);*/
    for(int i=1;i<times;++i)
    {
        count_sort(basic<<(4*i),i,b[i-1],b[i],0,9);
    }
    for (int i = 0; i<MAX; ++i)
		cout << b[times-1][i] << " ";
}

查找第i小

int Rand(int l,int h)
{
    srand(time(NULL));
    return (rand()%(h-l+1))+l;
}
void Swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
int random_select(int *a,int l,int h,int f)
{
    if(l < h)
    {
        int x = Rand(l,h);
        Swap(&a[x],&a[l]);
        int i=l+1,j=l+1;
        for(;i<=h;++i)
        {
            if(a[i] < a[l])
            {
                Swap(&a[i],&a[j]);
                ++j;
            }
        }
        Swap(&a[j-1],&a[l]);
        cout<<"tt"<<x<<" "<<j-1<<endl;
        if(f == j-1)
            return a[f];
        else if(f < j-1)
            return random_select(a,l,j-1,f);
        else
            return random_select(a,j,h,f);
    }
}
int select(int *a,int l,int h,int f)
{
    return random_select(a,l,h,f-1);
}

Mr_W1997
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论 学习笔记.pdf
05-04
算法导论学习笔记 本资源是对《算法导论》的学习笔记，涵盖了算法的基础知识、算法分析、函数的增长、递归式等方面的内容。 一、算法基础知识 算法是指将输入转换为输出的一系列计算步骤，目的是为了有效利用...
算法导论中C语言代码,算法导论-学习笔记与进度
weixin_29660659的博客
05-24 366
算法导论 阅读进度第一部分 基础知识第一章 计算中算法的角色 Done1.1 算法输入与输出算法可以解决哪些问题数据结构技术一些比较难的问题1.2 作为一种技术的算法效率算法和其他技术第二章 算法入门 Done2.1 插入排序伪代码如下：INSERTION_SORT(A)for j = 2 to length[A]do key = A[j]i = j-1// 将其与已经排好序的数组进行...
《算法导论》中KMP算法的实现——源码
JAN6055的博客
01-10 351
《算法导论》中KMP算法的源代码
2024年C C++最全算法导论代码 第10章 基本数据结构_void ( p)(struct key key)，如果不想35岁被淘汰这篇文章必看
最新发布
2401_84976207的博客
05-13 930
*哑元结点，用来代替NULL */(img-V38dvkoJ-1715541840844)](img-s3PCeOYi-1715541840845)]/*num比要存放在队列中的元素个数多一，是为了区分队列满和空的状态 */printf(“查找关键字:%d的结果:%s\n”, k,“成功” : “失败”);printf(“删除关键字:%d的结果:\n”, k);带哨兵的环形双向链表。
算法导论-----排序的9种实现(C/C++)
麦田里的码农
11-23 2160
目录 A、冒泡排序 B、选择排序 C、插入排序 D、折半插入排序 E、归并排序 F、快速排序 G、希尔排序 堆排序、基数排序、桶排序后续补充。。。。。A、冒泡排序冒泡排序有很多种实现方式。下面总结常见的几种，并对冒泡排序进行改进。 冒泡排序1//冒泡升序排序1，强烈推荐，好记 void BubbleSort(int arr[],int length) { int tmp; in
《算法导论》24.3-Dijkstra(迪杰斯特拉)算法（含C++代码）
Toby的博客
10-03 2290
本文为《算法导论》24.3-Dijkstra(迪杰斯特拉)算法（含C++代码），欢迎参考！
算法导论期末详细归纳总结(含习题和完整算法代码)
xtreallydance的博客
01-03 6037
2021新年似旧年，第一篇牛年博客！ 4号算法导论期末考试，这篇文章帮助各大学子备考期末，冲刺高分 一: 各种算法时间复杂度 (一) 排序算法: 直接插入排序: O(n2n^2n2)、稳定 shell排序: O(n1.3n^{1.3}n1.3）、不稳定 归并排序: O(nlgnlgnlgn)、稳定 堆排序: O(nlgnlgnlgn)、不稳定 快速排序: O(nlgnlgnlgn)、不稳定 基数排序: O(d(n+kn+kn+k))、稳定 平方阶有: 直接选择排序、冒泡排序、直接插入排序；线性..
算法导论的笔记
10-10
通过这份笔记，我们可以了解到算法导论课程的基本框架和核心内容。从课程信息、算法分析的重要性到具体的排序算法（如插入排序），这些内容为学习者提供了全面的视角来理解算法设计和分析的基础知识。特别是插入排序...
麻省理工学院算法导论笔记.pdf
01-19
麻省理工学院算法导论笔记.pdf 本资源摘要信息是根据麻省理工学院算法导论笔记.pdf所生成的知识点，涵盖算法导论的基本概念、算法设计和分析、排序算法等方面的知识点。 算法导论 * 算法的定义：算法是解决问题的...
算法导论 黑皮书 期末复习笔记
01-10
《算法导论》是计算机科学领域的一本经典著作，它深入浅出地介绍了各种重要的算法和数据结构。这本书被广泛用作大学本科和研究生课程的教材，同时也是许多专业人士自我提升的首选读物。期末复习笔记通常会涵盖书中的...
算法导论代码
01-17
算法导论博客配套代码，供各位参考。 密码是：c.itcast.cn
算法导论源码
06-13
算法导论源码，学习研究用
算法导论第三版各种数据结构的c/c++源代码
02-13
请参考算法导论第三版英文版Introduction to Algorithms 3rd Edition，本程序为第10章到第14章常用数据结构的c/c++实现。 IDE环境为vc++ 6.0。 主要包括： 队列 双向链表 哈希表 二叉搜索树
算法导论代码集（一）
dlphay的博客
12-18 1578
算法一：插入排序 #include "iostream" using namespace std; // date : 2017.12.18 By:dlphay // INSERTION_SORT_DLY int main() { int A[6] = {31, 41, 59, 26, 41, 58}; int i = 0; int j = 0; int value = 0;
算法导论代码部分实现二
qq_45289233的博客
05-19 575
第二次上机 矩阵链乘 /* 1． Matrix-chain product. The following are some instances. a) <3, 5, 2, 1,10> b) <2, 7, 3, 6, 10> c) <10, 3, 15, 12, 7, 2> d) <7, 2, 4, 15, 20, 5> */ #include<iostream> #include<algorithm> #define INF1 0x
算法导论笔记：伪代码、分治与概率分析
《算法导论笔记》是一份针对2019年面试准备的资料，主要聚焦于Thomas H. Cormen等作者编写的经典教材《算法导论》第三版。这份笔记详尽地涵盖了算法的基础概念，从伪代码的运用、算法的正确性证明及复杂度分析，到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值