精华内容
下载资源
问答
  • c语言实现C编译器c语言实现C编译器

    热门讨论 2010-06-13 08:27:00
    c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器c语言实现C编译器
  • c语言实现万年历

    2018-03-27 09:44:30
    c语言实现万年历c语言实现万年历c语言实现万年历c语言实现万年历c语言实现万年历c语言实现万年历c语言实现万年历
  • HMM的C语言实现HMM的C语言实现HMM的C语言实现
  • C语言实现简单动画,C语言实现简单动画C语言实现简单动画
  • 算法:C语言实现

    2018-05-10 07:55:35
    算法:C语言实现算法:C语言实现算法:C语言实现算法:C语言实现
  • c语言实现计算器

    2018-01-24 22:07:44
    c语言实现计算器
  • 2D格斗游戏,C语言实现

    千次下载 热门讨论 2013-11-16 13:21:15
    一个类似于《热血格斗》的2D格斗游戏,使用C语言实现,内附源代码。
  • 二叉树的建立及其递归遍历(C语言实现)

    万次阅读 多人点赞 2018-06-22 22:58:03
    ,我在这里展示的是二叉树的递归建立方式 //我在这里实现的是,二叉树的前序遍历方式创建,如果要使用中序或者后序的方式建立二叉树,只需将生成结点和构造左右子树的顺序改变即可 void CreateBiTree(BiTree *T) { ...
    最近在学习数据结构中树的概念,迟迟不得入门,应该是自己的懒惰和没有勤加练习导致的,以后应该多加练习

    以下是我对二叉树的一些总结内容
    二叉树的特点有:

    • 每一个节点最多有两棵子树,所以二叉树中不存在度大于2的节点,注意,是最多有两棵,没有也是可以的
      左子树和右子树是有顺序的,次序不能颠倒,这点可以在哈夫曼编码中体现, 顺序不同编码方式不同

    -即使树中某个节点中只有一个子树的花,也要区分它是左子树还是右子树
    二叉树一般有五种形态
    1.空二叉树
    2.只有一个根节点
    3.根结点只有左子树
    4.根节点只有右子树
    这里写图片描述这里写图片描述

    二叉树的性质
    1:在二叉树的第i层上最多有2^(i-1)个节点
    2:深度为K的二叉树之多有2^(k-1)个节点

    注:这里的深度K意思就是有K层的二叉树

    3:对于任何一棵二叉树T,如果其终端节点有No个,度为2的节点数有N2,则No=N2+1
    4: 具有n个节点的完全二叉树的深度为[log2n]+1([x]表示不大于x的最大整数)

    1,二叉树的存储结构(二叉链表)

    //二叉树的存储结构,一个数据域,2个指针域
     typedef struct BiTNode
    {
         char data;
         struct BiTNode *lchild,*rchild;
      }BiTNode,*BiTree;
    
    

    2,首先要建立一个二叉树,建立二叉树必须要了解二叉树的遍历方法。,我在这里展示的是二叉树的递归建立方式

    //我在这里实现的是,二叉树的前序遍历方式创建,如果要使用中序或者后序的方式建立二叉树,只需将生成结点和构造左右子树的顺序改变即可
     void CreateBiTree(BiTree *T)
      {
          char ch;
          scanf("%c",&ch);
          if(ch=='#')
              *T=NULL;
          else
         {
             *T=(BiTree  )malloc(sizeof(BiTNode));
             if(!*T)
                 exit(-1);
              (*T)->data=ch;
              CreateBiTree(&(*T)->lchild);
             CreateBiTree(&(*T)->rchild);
          }
     }
    
    

    这里写图片描述
    3。二叉树的遍历方式(递归建立)

    void PreOrderTraverse(BiTree T)//二叉树的先序遍历
    {
        if(T==NULL)
            return ;
        printf("%c ",T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
    void InOrderTraverse(BiTree T)//二叉树的中序遍历
    {
       if(T==NULL)
           return ;
       InOrderTraverse(T->lchild);
        printf("%c ",T->data);
       InOrderTraverse(T->rchild);
    }
    void PostOrderTraverse(BiTree T)//后序遍历
    {
        if(T==NULL)
            return;
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c ",T->data);
    }
    

    4.完整代码

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct BiTNode
    {
        char data;
        struct BiTNode *lchild,*rchild;
    }BiTNode,*BiTree;
    void PreOrderTraverse(BiTree T)//二叉树的先序遍历
    {
        if(T==NULL)
            return ;
        printf("%c ",T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
    void InOrderTraverse(BiTree T)//二叉树的中序遍历
    {
       if(T==NULL)
           return ;
       InOrderTraverse(T->lchild);
        printf("%c ",T->data);
       InOrderTraverse(T->rchild);
    }
    void PostOrderTraverse(BiTree T)//后序遍历
    {
        if(T==NULL)
            return;
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c ",T->data);
    }
    void CreateBiTree(BiTree *T)
    {
        char ch;
        scanf("%c",&ch);
        if(ch=='#')
            *T=NULL;
        else
        {
            *T=(BiTree  )malloc(sizeof(BiTNode));
            if(!*T)
                exit(-1);
            (*T)->data=ch;
            CreateBiTree(&(*T)->lchild);
            CreateBiTree(&(*T)->rchild);
        }
    }
    int main()
    {
        BiTree T;
        CreateBiTree(&T);
        PreOrderTraverse (T);
        InOrderTraverse(T);
        PostOrderTraverse(T);
        return 0;
    }
    
    

    对知识点的补充:
    (1)建立二叉树时,这里是以前序遍历的方式,输入的是扩展二叉树,也就是要告诉计算机什么是叶结点,否则将一直递归,当输入“#”时,指针指向NULL,说明是叶结点。

    如图为扩展二叉树:(前序遍历为:ABDG##H###CE#I##F##)
    这里写图片描述

    展开全文
  • 二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
  • C语言实现的websocket

    2020-11-18 16:16:47
    该资源用C语言实现的简易websocket测试程序,并附有web端的html页面辅助调试,供websocket学习者下载使用,理解websocket协议
  • C语言实现矩阵运算

    万次阅读 多人点赞 2019-09-04 21:28:06
    最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之 一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵; 矩阵的结构体: typedef struct...

    最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之
    首先声明该代码在Ubuntu18.04下运行通过, 如若在windows下运行失败请考虑编译器版本问题

    一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵;
    矩阵的结构体:

    typedef struct 
    {
    	int row,line;			//line为行,row为列
    	double *data;
    }Matrix;
    

    这样在创建一个矩阵的时候只需要分配row,line和data的内存就好.
    然后…好像也没啥好说的… 直接根据所学矩阵的基本运算只是写代码就好…

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    double value[] = {1,2,3,4,5,6,7,8,9};
    double value2[] = {9,8,7,6,5,4,3,2,1};
    
    typedef struct 
    {
    	int row,line;		//line为行,row为列
    	double *data;
    }Matrix;
    
    Matrix* InitMatrix(Matrix *matrix,int row,int line);		//初始化矩阵
    void ValueMatrix(Matrix *matrix,double *array);				//给一个矩阵赋值
    int SizeMatrix(Matrix *matrix);								//获得一个矩阵的大小
    void FreeMatrix(Matrix *matrix);							//释放一个矩阵
    void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B);		//复制一个矩阵的值
    void PrintMatrix(Matrix *matrix);							//打印一个矩阵
    
    //矩阵的基本运算
    Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的加法
    Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的乘法
    void TransMatrix(Matrix *matrix);			//条件为方阵
    
    int main(int argc,char* argv[])
    {
    	Matrix *matrix1 = InitMatrix(matrix1,3,3);
    	Matrix *matrix2 = InitMatrix(matrix2,3,3);
    
    	ValueMatrix(matrix1,value);
    	// CopyMatrix(matrix1,matrix2);	//复制赋值
    	ValueMatrix(matrix2,value2);
    
    	printf("矩阵1 乘以 矩阵2: \n");
    	Matrix *matrix3 = MulMatrix(matrix1,matrix2);	//乘法
    	PrintMatrix(matrix3);	
    	printf("矩阵1 加上 矩阵2: \n");
    	Matrix *matrix4 = AddMatrix(matrix1,matrix2);	//加法
    	PrintMatrix(matrix4);
    	printf("矩阵1进行转置: \n");
    	TransMatrix(matrix1);					//转置
    	PrintMatrix(matrix1);
    	
    	return 0;
    }
    
    Matrix* InitMatrix(Matrix *matrix,int row,int line)				//初始化一个矩阵
    {
    	if (row>0 && line>0)
    	{
    		matrix = (Matrix*)malloc(sizeof(Matrix));
    		matrix->row = row;
    		matrix->line = line;
    		matrix->data = (double*)malloc(sizeof(double)*row*line);
    		memset(matrix->data,0,sizeof(double)*row*line);
    		return matrix;
    	}
    	else 
    		return NULL;
    } 
    
    void ValueMatrix(Matrix *matrix,double *array) 		//给矩阵赋值
    {
    	if (matrix->data != NULL)
    	{
    		memcpy(matrix->data, array, matrix->row*matrix->line*sizeof(double));
    	}
    }
    
    int SizeMatrix(Matrix *matrix)
    {
    	return matrix->row*matrix->line;
    }
    
    void FreeMatrix(Matrix *matrix)
    {
    	free(matrix->data);		//释放掉矩阵的data存储区
    	matrix->data = NULL;
    	printf("释放成功\n");
    }
    
    void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B)
    {
    	matrix_B->row = matrix_A->row;
    	matrix_B->line = matrix_A->line;
    	memcpy(matrix_B->data, matrix_A->data, SizeMatrix(matrix_A)*sizeof(double));
    }
    
    void PrintMatrix(Matrix *matrix)
    {
    	for (int i=0;i<SizeMatrix(matrix);i++)
    	{
    		printf("%lf\t", matrix->data[i]);
    		if ((i+1)%matrix->line == 0)
    			printf("\n");
    	}
    			
    }
    //加法
    Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B)
    {
    	if (matrix_A->row == matrix_B->row && matrix_A->line == matrix_B->line)
    	{
    		Matrix *matrix_C = InitMatrix(matrix_C,matrix_A->row,matrix_A->line);
    		for (int i=0;i<matrix_A->line;i++)
    		{
    			for (int j=0;j<matrix_A->row;j++)
    			{
    				matrix_C->data[i*matrix_C->row + j] = \
    				matrix_A->data[i*matrix_A->row + j] + matrix_B->data[i*matrix_A->row + j];
    			}
    		}
    		return matrix_C;
    	}
    	else 
    	{
    		printf("不可相加\n");
    		return NULL;
    	}
    }
    
    //乘法
    Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B)
    {
    	if (matrix_A->row == matrix_B->line)		//列==行
    	{
    		Matrix *matrix_C = InitMatrix(matrix_C,matrix_B->row,matrix_A->line);
    		// matrix_C->line = matrix_A->line;		//A行
    		// matrix_C->row = matrix_B->row;			//B列
    		for (int i=0;i<matrix_A->row;i++)
    		{
    			for (int j=0;j<matrix_B->line;j++)
    			{
    				for (int k=0;k<matrix_A->line;k++)
    				{
    					matrix_C->data[i*matrix_C->line + j] += \
    					matrix_A->data[i*matrix_A->line + k] * matrix_B->data[k*matrix_B->row + j];
    				}
    			}
    		}
    		return matrix_C;
    	}
    	else
    	{
    		printf("不可相乘\n");
    		return NULL;
    	}
    }
    
    //矩阵转置
    void TransMatrix(Matrix *matrix)			//条件为方阵
    {
    	if (matrix->row == matrix->line)
    	{
    		Matrix *matrixTemp = InitMatrix(matrixTemp, matrix->row,matrix->line);       	//创建一个临时矩阵
    		CopyMatrix(matrix,matrixTemp);	//将目标矩阵的data复制给临时矩阵
    
    		for (int i=0;i<matrix->row;i++)
    		{
    			for (int j=0;j<matrix->line;j++)
    			{
    				matrix->data[i*matrix->row + j] = matrixTemp->data[j*matrix->row + i];
    			}
    		}
    	}
    	else
    	{
    		printf("转置的矩阵必须为方阵\n");
    	}
    }
    
    

    恩…都是代码…尽情享用吧!

    展开全文
  • dbus经典库rain开源作品中人气最旺c语言实现,是学习c语言的最好代码,强烈推荐品中人气最旺c语言实现,是学习c语言的最好代码,强烈推荐品中人气最旺c语言实现,是学习c语言的最好代码,强烈推荐rain开源作品中人气...
  • C语言实现https客户端

    2020-09-04 10:36:53
    C语言实现openssl的https客户端post方法使用,可以传入json字符串的格式,测试的例子,可以使用
  • 哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
  • C语言实现鼠标

    2014-08-26 20:05:03
    C语言实现鼠标
  • C语言实现傅里叶变换

    2019-03-31 12:30:53
    通过C语言实现定点和浮点傅里叶变换,包含一般傅里叶变换和快速傅里叶变换。
  • c语言实现循环buffer

    2019-01-08 18:32:54
    linux c语言实现的循环buffer机制,可以在多线程之间传递共享buffer队列
  • 循环队列–C语言实现–数据结构

    万次阅读 多人点赞 2017-06-22 16:36:45
    循环队列–C语言实现–数据结构目录循环队列C语言实现数据结构目录 一 要求 二 循环队列 三 循环队列的算法设计 1 建立循环队列 2 置空队列 3 入队 4 出队 5 打印队 四 程序 1 程序的结构 2 程序源码 五 程序测试 1 ...

    循环队列–C语言实现–数据结构


    目录


    (一) 要求

    假设以数组sequ[m]存放循环队列的元素,同时设变量rear和quelen 分别指示循环队列中队尾元素的位置和内含元素的个数。编写实现该循环队列的入队和出队操作的算法。提示:队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (二) 循环队列

    定义:为充分利用向量空间,克服”假溢出”现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现, 当然也可以利用顺序表来实现。顺序表就是我们熟悉的数组 eg. sun[]
    回顾:我们再来回顾一下关于顺序队列的重要知识点。队列通常与栈对应,栈是一种后进先出的单端(尾端)处理的数据结构;那么与之对应的队列是一种先进先出的双端(头尾两端)的数据结构。队列的特点就是在一段进行入队(存储数据)操作,在另一端进行出队(删除数据)操作。
    为什么设计循环队列:大家在处理队列的时候,会遇到如下情况。例如说:我们的队列空间能够容纳1000个元素。首先,格格入队1000个元素,队列上溢,此时为“真溢出”。那么现在我们进行出队操作,我们一直出队,一直出队, 知道1000个元素全部被删除,此时我们发现队列仍然处于“上溢”状态,why? 其实原因很简单,在非循环队列当中,无论我们的front指(偏移)到哪里,只要我们的rear指(偏移)向上阙,那么队列就是“满溢”的。这就造成了空间明明还被占据着,但是队列却已经无用武之地的窘境。对于空间有限的计算机来说,这无疑是一种浪费。也不是一个优秀的程序猿想要看到的。所以在这种情况下,循环队列诞生了。循环队列当中的“满溢”只有一种情况,那就是所有数据空降都被占领了。而不会存在非循环队列当中的“假溢出”现象。


    我们所常见的顺序循环队列通常有两种数据结构。

    结构一

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  front,rear;
        //front表示队列头的偏移量,rear表示队列的尾的偏移量
    }qu;//qu是队列(queue)的缩写

    这里写图片描述

    结构二

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  rear, quelen;
        //rear表示队列的尾的偏移量,quelen表示的是队列中元素的个数
    }qu;//qu是队列(queue)的缩写

    那通过观察这两种机构我们能够很容易的发现,数据结构并不是固定的。我们觉得那种算法比较更合理,我们觉得哪种数据结构方便我们设计算法,那么我们就建立哪种数据结构。在本文当中,我们采用第二种数据结构。显而易见的是,当我们采用第二种数据结构时,我们建立的一个队列指针(qu*sq)队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (三) 循环队列的算法设计


    在上面我们了解了循环队列的数据机构,但是仅仅学会了数据结构还远远不够。我们设计数据结构的目的是为了更好的存储数据,并利用数据。下面我们来看一看关于循环队列我们要掌握哪些最基本的算法(利用数据机构)。


    3.1 建立循环队列

    //建立队
    qu* creatqueue();//函数声明
    qu* creatqueue()//函数实现
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }

    3.2 置空队列

    //置空队
    void setnull(qu*);//函数声明
    void setnull(qu *sq)//函数实现
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }

    3.3 入队

    //入队
    void enqueue(qu*, datatype);//函数声明
    void enqueue(qu*sq, datatype x)//函数实现
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }

    **算法流程图**


    3.4 出队

    //出队
    datatype *dequeue(qu*);//函数声明
    datatype *dequeue(qu*sq)//函数实现
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    

    **算法流程图**


    3.5 打印队

    //打印队
    void print(qu*);//函数声明
    void print(qu*sq)//函数定义
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }

    (四) 程序


    下面我们来设计一个程序测试我们的数据机构与算法


    4.1 程序的结构

    **程序结构**


    4.2 程序源码

    注意:该程序由Microsoft Visual Studio Enterprise 2015编译器进行调试。受制于编译器品牌及版本不同等不可抗因素造成的编译失败,请自行调整。

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #define m 5
    
    //循环队列的结构类型定义
    typedef int datatype;
    typedef struct
    {
        datatype sequ[m];
        int  rear, quelen;
    }qu;
    
    //函数声明
    qu* creatqueue();
    void setnull(qu*);
    void enqueue(qu*, datatype);
    datatype *dequeue(qu*);
    void print(qu*);
    
    //主函数
    void main()
    {
        qu *sq= creatqueue();
    
        datatype x, *p;
        int key;
    
        setnull(sq);
        do
        {
            printf("1.Enter Queue   2.Delete Queue   3.clc display   4.print queue   -1.Quit:");
            scanf_s("%d", &key);
            switch (key)
            {
            case 1:  printf("Enter the Data:"); scanf_s("%d", &x);
                enqueue(sq, x);  break;
            case 2:  p = dequeue(sq);
                if (p != NULL) printf("%d\n", *p);
                break;
            case 3:system("cls"); break;
            case 4:print(sq); break;
            case -1: exit(0);
            }
        } while (1);
    }
    
    //建立队
    qu* creatqueue()
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }
    //置空队
    void setnull(qu *sq)
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }
    
    //入队
    void enqueue(qu*sq, datatype x)
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }
    
    
    //出队
    datatype *dequeue(qu*sq)
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    
    //打印队列
    void print(qu*sq)
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }
    
    

    (五) 程序测试


    5.1 入队列

    **入队列及上溢检测**


    5.2 出队列

    出队列及下溢检测


    5.3 打印队列

    前面已经用到了打印队列,所以格格不再赘述,大家由5.2&5.3可知打印队列是成功的。


    (六) 源程序及封装软件下载

    下载地址


    格格是一枚智能专业的本科在校生,很愿意和各位大佬交流。如果大家有愿意交朋友的,可以加格格的QQ:446019725,声明是CSDN即可。



    展开全文
  • 经典算法 C语言实现

    2009-04-16 21:31:36
    经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现经典算法 C语言实现
  • C语言实现PI

    2013-03-28 15:33:32
    C语言,PI控制控制的C语言实现的源代码。
  • 控制方法的C语言实现

    2016-03-01 16:44:07
    控制系统的数学模型及其C语言实现;PID控制及其C语言实现;工业常用智能算法及其C语言实现;实例设计之电源仿真软件
  • C语言实现HashMap

    万次阅读 2017-07-21 21:18:09
    C语言实现HashMap在做算法题时,需要使用到HashMap提高效率,虽然高级语言中大豆实现了这种数据结构,但是高级语言的效率低,于是打算自己实现HashMap,加深理解,使用C语言实现了HashMap的创建(CreateHashMap)、取...

    C语言实现HashMap

           在做算法题时,需要使用到HashMap这种数据结构,虽然高级语言中大都实现了这种数据结构,但是为了理解HashMap的底层原理,于是打算自己实现HashMap,使用C语言实现了HashMap的创建(CreateHashMap)、取键值对(Get)、插入键值对(Put)、输出(PrintHashMap)以及销毁(DestoryHashMap),具体程序如下:

    1.结点类型定义:

    typedef struct{
    	int key;  //键
    	int val;  //值
    }DataType; //对基本数据类型进行封装,类似泛型
    typedef struct{
    	DataType data;
    	struct HashNode *next;  //key冲突时,通过next指针进行连接
    }HashNode;
    typedef struct{
    	int size;
    	HashNode *table;
    }HashMap,*hashmap;
    

    2.HashMap基本操作:

    ①CreateHashMap

    //f1_createHashMap
    //将给定的整形数组构建为HashMap,size为数组长度
    HashMap *CreateHashMap(int *nums,int size){
    	//分配内存空间
    	HashMap *hashmap=(HashMap*)malloc(sizeof(HashMap));
    	hashmap->size=2*size;
    	//hash表分配空间
    	hashmap->table=(HashNode *)malloc(sizeof(HashNode)*hashmap->size);
    	//初始化
    	int j=0;
    	for(j=0;j<hashmap->size;j++){
    		hashmap->table[j].data.val=INT_MIN;
    		hashmap->table[j].next=NULL;
    	}
    	int i=0;
    	//建立HashMap
    	while(i<size){
    	    //根据数组元素的值计算其在hashMap中的位置
    		int pos=abs(nums[i])%hashmap->size;
    		//判断是否冲突
    		if(hashmap->table[pos].data.val==INT_MIN){
    		    //不冲突
    		    //把元素在数组中的索引作为key
    			hashmap->table[pos].data.key=i;
    			//把元素值作为value
    			hashmap->table[pos].data.val=nums[i];
    		}
    		//冲突
    		else{
    		    //给当前元素分配一个结点,并为结点复制
    			HashNode *lnode=(HashNode*)malloc(sizeof(HashNode)),*hashnode;
    			lnode->data.key=i;
    			lnode->data.val=nums[i];
    			lnode->next=NULL;
    			//从冲突位置开始,遍历链表
    			hashnode=&(hashmap->table[pos]);
    			while(hashnode->next!=NULL){
    				hashnode=hashnode->next;
    			}
    			//将当前结点连接到链表尾部
    			hashnode->next=lnode;
    		}
    		//处理下一个元素
    		i++; 	
    	}
    	//处理完成,返回HashMap
    	return hashmap;
    }
    

           对于hashmap->size=2*size; hashmap中table的长度为什么是给定数组长度的2倍?这涉及到hash表的装填因子,详细可以参考严蔚敏《数据结构》中第九章查找的哈希表章节,这里做简单介绍:

    哈希的装填因子:

            其中n 为关键字个数,m为表长.

           装填因子是表示Hsah表中元素的填满的程度。加载因子越大,填满的元素越多,空间利用率提高,但冲突的机会加大了。反之,加载因子越小,填满的元素越少,冲突的机会减小了,但空间浪费多了。冲突的机会越大,则查找的成本越高。反之,查找的成本越小.因而,查找时间就越小.因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡。

    ②Get

    //f2_GetHashNode
    int Get(HashMap hashmap,int value){
        //根据元素值,计算其位置
    	int pos=abs(key)%hashmap.size;
    	HashNode *pointer=&(hashmap.table[pos]);
    	//在当前链表遍历查找该结点
    	while(pointer!=NULL){
    			if(pointer->data.value==value) 
    	            return pointer->data.key;
    	        else
    	        	pointer=pointer->next;
    		} 
    	//未找到,返回-1
    	return -1;
    }
    

    ③Put

    //f3_Put,与建立HashMap时插入元素的方法相同
    int Put(HashMap hashmap,int key,int value){
         int pos=abs(value)%hashmap.size;
         HashNode *pointer=&(hashmap.table[pos]);
         if(pointer->data.val==INT_MIN) 
            {
             pointer->data.val=value;
             pointer->data.key=key;
            }
    	else{
            while(pointer->next!=NULL)
                 pointer=pointer->next;
            HashNode *hnode=(HashNode *)malloc(sizeof(HashNode));
            hnode->data.key=key;
            hnode->data.val=value;
            hnode->next=NULL;
            pointer->next=hnode;
       } 
       return 1;
    }	
    

    ④PrintHashMap

    //f4_PrintHashMap 
    void PrintHashMap(HashMap* hashmap){
        printf("%===========PrintHashMap==========\n");
    	int i=0;
    	HashNode *pointer;
    	while(i<hashmap->size){
    		pointer=&(hashmap->table[i]);
    		while(pointer!=NULL){
                if(pointer->data.val!=INT_MIN)
                  printf("%10d",pointer->data.val);
    			else 
                  printf("        [ ]");
    			pointer=pointer->next;
    		}
            printf("\n---------------------------------");
    		i++;
    		printf("\n");
    	}
        printf("===============End===============\n");
    }
    

    ⑤DestoryHashMap

    //f5_DestoryHashMap
    void DestoryHashMap(HashMap *hashmap){
        int i=0;
        HashNode *hpointer;
        while(i<hashmap->size){
            hpointer=hashmap->table[i].next;
            while(hpointer!=NULL){
                
                hashmap->table[i].next=hpointer->next;
                //逐个释放结点空间,防止内存溢出
                free(hpointer);
                hpointer=hashmap->table[i].next;
                }
            //换至下一个结点
            i++;
        }
        free(hashmap->table);
        free(hashmap);
        printf("Destory hashmap Success!");
    }
    

    3.运行示例

    主函数如下:

    int main(int argc, char **argv)
    {
    		int nums[]={34,54,32,32,56,78};
    		//创建HashMap
       	    HashMap *hashmap=CreateHashMap(nums,6);
        	PrintHashMap(hashmap);
        	//查找元素
        	printf("%d\n",Get(*hashmap,78));
    
        	DestoryHashMap(hashmap);
        	getchar();
    		return 0;
    }
    

    运行结果:

    HashMap运行结果

    展开全文
  • MD5加密c语言实现

    热门讨论 2011-05-12 10:22:53
    MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现MD5加密c语言实现
  • c语言实现容器

    千次阅读 2019-02-13 10:35:43
    为了实现了解docker容器底层实现原理,特地用C语言实现了一个简单的Demo--ContainerC,放到了github中地址,仅供参考学习。在实现ContainerC的时候参考iproute2源代码。...
  • C语言实现FIR滤波

    千次阅读 2019-12-02 17:09:27
    C语言实现FIR滤波
  • linux c语言实现websocket

    2017-09-21 17:41:31
    linux c语言实现websocket编程,亲测可以运行,linux下直接编译就可以。代码中文件较多,结构比较清晰,未加注解。若有疑问请留言。
  • 哈希算法C语言实现

    2016-02-17 12:56:54
    哈希算法C语言实现
  • C语言实现蛇形矩阵

    万次阅读 多人点赞 2017-12-19 21:37:14
    c语言实现蛇形矩阵
  • BP神经网络C语言实现

    万次阅读 多人点赞 2018-09-07 14:00:01
    BP神经网络C语言实现 山人 BP神经网络应用广泛,大概是今年的五月份左右,我需要做一个多元函数的拟合,所以写了这个BP神经网络。为什么要使用C语言来写呢?因为我的程序需要在单片机上跑,所以不得不使用C语言。 ...
  • Hilbert的C语言实现

    2018-09-10 18:26:54
    利用C语言实现Hilbert变换,以cos()函数为例,对其进行hilbert变换,计算相角

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 646,995
精华内容 258,798
关键字:

c语言实现

c语言 订阅