2017-03-28 13:39:09 zhongcanw 阅读数 225
  • 图解Java数据结构和算法

    1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题: 1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了 2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级  3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴 3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容: 本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。 学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    3967 人正在学习 去看看 佟刚


将十进制整数转换为k进制数,在此过程中,k进制数是从低到高位产生的,但最后得到的k进制数是从高位到低位读出

的,与生成过程正好相反。因为可以利用一个栈s,按k进制各位的生成顺序进栈,最后再从栈中逐个读取各位数字。

	void  exchange(int value,int n)
	{
		stack<int> s;
		while(value>0)
		{
			s.push(value%n);
			value=value/n;
		}
		while(!s.empty())
		{
			
			cout<<s.top();
			s.pop();
		}
	}

2018-08-18 15:39:39 qq_41420747 阅读数 2399
  • 图解Java数据结构和算法

    1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题: 1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了 2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级  3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴 3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容: 本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。 学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    3967 人正在学习 去看看 佟刚

看完小王八老师的数据结构栈的课程,我觉得有必要联系进制转换,写下来记录一下。

数据结构练习——栈(进制转换)C语言实现

首先模拟栈

使用字符串模拟栈,用动态创建的方法模拟栈结构比较好,但是我是数据结构小白,所以见笑了。

下面贴上我的c工程里的头文件中栈的代码:

//定义栈
struct Stack
{
    char mData[100];
    int mLen;
};


//初始化栈
void InitStack(struct Stack *S)
{
    S->mLen = -1;
}
//元素入栈
void Push(struct Stack *S,char item)
{
    S->mData[++S->mLen] = item;
}
//元素出栈
char Pop(struct Stack *S)
{
    return S->mData[S->mLen--];
}
//返回栈顶元素
char  Top(struct Stack *S)
{
    return S->mData[S->mLen];
}
//清空栈
void Clear(struct Stack *S)
{
    int i;
    for(i = 0;i<=S->mLen;i++)
    {
        Pop(S);
    }
}
//是否为空 是空返回1 否则返回0
int StackEmpty(struct Stack *S)
{
    if(S->mLen == -1)
        return 1;
    else
        return 0;
}

 接下来贴图说明一下,几种进制转换实现方法:

十进转八进:

void converse_Dec_to_Oct()   //十进制转八进制
{
    int N;
    char e;
    struct Stack S;
    InitStack(&S);
    printf("Decimal to Octonary(8) please input data:\n");
    scanf("%d",&N);
    //转换
    while(N)
    {
        Push(&S,(char)(N%8+48));
        N = N/8;
    }
    //输出
    printf("converse:");
    while(!StackEmpty(&S))
    {
        e = Pop(&S);
        printf("%c",e);
    }

}

 二进制转十进制:

void converse_bin_to_Dec()  //二进制转换十进制,使用一个栈
{
    struct Stack s;
    InitStack(&s);
    char str[100];
    int outcome=0;    //记录结果
    int i;

    printf("binary to Decimal(10) please input data:\n");
    scanf("%s",str);
    // 压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,str[i]);
    }
    //转换
    for(i=0;!StackEmpty(&s);i++)
    {
        outcome += (int)(Pop(&s)-48)*pow(2,i);  //字符转int
    }
    //输出
    printf("converse:");
    printf("%d",outcome);
}

 二进制转换八进制:

 可以看到,二进制的3位转换为8进制的1位,所以将二进制串按照3为一个组,转换为8进制的一位压入8进制栈中。

而且此处体现出栈的特点FILO(First In Last Out),转换完成后输出8进制栈的时候正好是各位顺序正确的8进制数。

 注意有时候会有不足二进制栈剩余三位的情况,需要稍微处理一下,上代码:

void converse_bin_to_Oct()  //二进制转换八进制,使用两个栈
{
    struct Stack s,t;
    int temp=0;
    char str[100];
    InitStack(&s);InitStack(&t);
    int i;

    printf("binary to octonary(8) please input binary data:\n");
    scanf("%s",str);
    // binary元素压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,str[i]);
    }
    //转换
    while(!StackEmpty(&s))
    {
        temp=0; //每次循环执行时temp置0
        for(i=0;i<3&&!StackEmpty(&s);i++)   //当读取三位binary或者binary栈为空时跳出
        temp += (int)(Pop(&s)-48)*pow(2,i);

        Push(&t,(char)(temp+48));  //转换后的8进制数压入8进制栈
    }
    //输出8进制栈
    printf("converse:");
    while(!StackEmpty(&t))
    {
        printf("%c",Pop(&t));
    }
}

二进制转换十六进制:

原理和8进制一样,不赘述了,但是注意十六进制使用A-F表示10-15:

void converse_bin_to_Hex()  //二进制转换十六进制,使用两个栈
{
    struct Stack s,t;
    int temp=0;
    char str[100];
    InitStack(&s);InitStack(&t);
    int i;

    printf("binary to Hexadecimal(16) please input data:\n");
    scanf("%s",str);
    // binary元素压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,(int)(str[i]-48));
    }
    //转换
    while(!StackEmpty(&s))
    {
        temp=0; //每次循环执行时temp置0
        for(i=0;i<4&&!StackEmpty(&s);i++)   //当读取三位binary或者binary栈为空时跳出
        temp += Pop(&s)*pow(2,i);
        if(temp<=9)
            Push(&t,(int)(temp+48));  //转换后的8进制数压入8进制栈
        else
        {
            switch(temp)
            {
                case 10:Push(&t,'A');break;
                case 11:Push(&t,'B');break;
                case 12:Push(&t,'C');break;
                case 13:Push(&t,'D');break;
                case 14:Push(&t,'E');break;
                case 15:Push(&t,'F');break;
            }
        }
    }

    //输出16进制栈
    printf("converse:");
    while(!StackEmpty(&t))
    {
        printf("%c",Pop(&t));
    }
}

 

下面贴上整个main.c代码,头文件在上面贴出来了。

#include <stdio.h>
#include <stdlib.h>
#include "head.h"
#include <math.h>
#include <string.h>

// 栈使用字符串模拟
void converse_Dec_to_Oct()   //十进制转八进制
{
    int N;
    char e;
    struct Stack S;
    InitStack(&S);
    printf("Decimal to Octonary(8) please input data:\n");
    scanf("%d",&N);
    //转换
    while(N)
    {
        Push(&S,(char)(N%8+48));
        N = N/8;
    }
    //输出
    printf("converse:");
    while(!StackEmpty(&S))
    {
        e = Pop(&S);
        printf("%c",e);
    }

}

void converse_bin_to_Dec()  //二进制转换十进制,使用一个栈
{
    struct Stack s;
    InitStack(&s);
    char str[100];
    int outcome=0;    //结果
    int i;

    printf("binary to Decimal(10) please input data:\n");
    scanf("%s",str);
    // 压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,str[i]);
    }
    //转换
    for(i=0;!StackEmpty(&s);i++)
    {
        outcome += (int)(Pop(&s)-48)*pow(2,i);  //字符转int
    }
    //输出
    printf("converse:");
    printf("%d",outcome);
}

void converse_bin_to_Oct()  //二进制转换八进制,使用两个栈
{
    struct Stack s,t;
    int temp=0;
    char str[100];
    InitStack(&s);InitStack(&t);
    int i;

    printf("binary to octonary(8) please input binary data:\n");
    scanf("%s",str);
    // binary元素压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,str[i]);
    }
    //转换
    while(!StackEmpty(&s))
    {
        temp=0; //每次循环执行时temp置0
        for(i=0;i<3&&!StackEmpty(&s);i++)   //当读取三位binary或者binary栈为空时跳出
        temp += (int)(Pop(&s)-48)*pow(2,i);

        Push(&t,(char)(temp+48));  //转换后的8进制数压入8进制栈
    }
    //输出8进制栈
    printf("converse:");
    while(!StackEmpty(&t))
    {
        printf("%c",Pop(&t));
    }
}

void converse_bin_to_Hex()  //二进制转换十六进制,使用两个栈
{
    struct Stack s,t;
    int temp=0;
    char str[100];
    InitStack(&s);InitStack(&t);
    int i;

    printf("binary to Hexadecimal(16) please input data:\n");
    scanf("%s",str);
    // binary元素压入栈
    for(i=0;i<strlen(str);i++)
    {
        Push(&s,(int)(str[i]-48));
    }
    //转换
    while(!StackEmpty(&s))
    {
        temp=0; //每次循环执行时temp置0
        for(i=0;i<4&&!StackEmpty(&s);i++)   //当读取三位binary或者binary栈为空时跳出
        temp += Pop(&s)*pow(2,i);
        if(temp<=9)
            Push(&t,(int)(temp+48));  //转换后的8进制数压入8进制栈
        else
        {
            switch(temp)
            {
                case 10:Push(&t,'A');break;
                case 11:Push(&t,'B');break;
                case 12:Push(&t,'C');break;
                case 13:Push(&t,'D');break;
                case 14:Push(&t,'E');break;
                case 15:Push(&t,'F');break;
            }
        }
    }

    //输出16进制栈
    printf("converse:");
    while(!StackEmpty(&t))
    {
        printf("%c",Pop(&t));
    }
}

int main()
{
    int choose=0;
    printf("which conversion do want to choose:\n10 ot 8:1\n2 to 10:2\n2 to 8: 3\n2 to 16:4\n\ninput: ");
    scanf("%d",&choose);
    fflush(stdin);
    switch(choose)
    {
        case 1:converse_Dec_to_Oct();
        case 2:converse_bin_to_Dec();
        case 3:converse_bin_to_Oct();
        case 4:converse_bin_to_Hex();
    }

    printf("\nHello world!\n");
    return 0;
}

 数据结构小白,有不对的地方,请大佬指出,谢谢!

 

2016-08-05 16:09:25 jsrcdjcyy 阅读数 942
  • 图解Java数据结构和算法

    1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题: 1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了 2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级  3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴 3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容: 本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。 学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    3967 人正在学习 去看看 佟刚

栈的应用有很多,其中它可以被应用于数制转换,其算法原理如下:

十进制数N和其他n进制数的转换,如果用栈来实现,那将会非常简单。其中一个简单的算法可以基于如下数学原理

N=(N div n)×n+N mod n(其中:div为整除运算,mod为求余运算,N为非负十进制整数)

举个例子,例如,十进制的1348,转换成八进制后其值应为2504

N N div 8 N mod 8
1348 168 4
168 21 0
21 2 5
2 0 2

由于上述计算过程是从低位到高位顺序产生八进制数的各个数位,而打印输出,一般来说应该从高位到低位进行,恰好和计算过程相反。因此,若将计算过程中得到的八进制数的各位顺序进栈,然后按出栈序列打印输出,所得到的数值就是与输入对应的八进制数。

编译软件:VC++6.0 

测试用例结果截图如下:



源代码如下:

/********************************** 
栈的数制转换运用和实现(十进制数N转换成其他n进制数。完整代码,C实现)
Author:大地在我腳下 
Date:2016-7-29
Email:jsrcdjcyy@163.com 
**********************************/  
#include <stdio.h>
#include <stdlib.h>

typedef struct Node
{int data;
struct Node* next;
}Node,*NStack;


typedef struct LNode
{NStack Top;
 NStack Bottom;
}LNode,*LStack;

LStack InitStack();
void conversion(LStack,int,int);
void Push(LStack,int);
void Pop(LStack,int*);
bool Empty(LStack);

void main()
{int N,n;
 LStack pStack=InitStack();
 printf("Please input the number and its radix:");
 scanf("%d%d",&N,&n);//十进制数N转换成其他n进制数
 printf("\n");
 printf("Now the %d radix is:",n);
 conversion(pStack,N,n);
}

LStack InitStack()
{NStack p=(NStack)malloc(sizeof(Node));
 LStack q=(LStack)malloc(sizeof(LNode));
 if(!p||!q)
 {printf("Malloc failed!");
 exit(-1);
 }
 q->Top=q->Bottom=p;
 p->data=0;
 q->Bottom->next=NULL;
 return q;
}

void conversion(LStack S,int N,int n)
{int d; 
while(N)
 {Push(S,N%n);
  N=N/n;
 }
while(!Empty(S))
{ Pop(S,&d);
  printf("%d",d);
}
printf("\n");      
}

void Push(LStack S,int e)
{NStack p=(NStack)malloc(sizeof(Node));
if(!p)
 {printf("Malloc failed!");
 exit(-1);
 }
 p->data=e;
 p->next=S->Top;
 S->Top=p;
}

void Pop(LStack S,int* e)
{NStack q,p=S->Top;
q=p->next;
*e=p->data;
free(p);
S->Top=q;
}

bool Empty(LStack S)
{if(S->Top->next) return false;
else return true;
}


2015-09-16 11:00:33 B08370108 阅读数 480
  • 图解Java数据结构和算法

    1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题: 1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了 2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级  3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴 3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容: 本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。 学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    3967 人正在学习 去看看 佟刚

栈的基本操作-数制转换,其实就是余数部分先存起来,倒序输出

为了简单,就不考虑16之类的需要转换ABCDEF的,就简单的比如十进制转二进制之类的转化

简单例代码:

#include<stdio.h>
#include<string.h>
#include<malloc.h>

#define InitStackSize 1000

typedef struct SqStack
{
	int *base,*top;
	int stacksize;
}SqStack;

void InitSqSatck(SqStack &s)
{
	s.base=s.top=(int*)malloc(InitStackSize*sizeof(int));
	s.stacksize=InitStackSize;
}

void PushSqStack(SqStack &s,int e)
{
	*s.top=e;
	s.top++;
}

void Conversion(SqStack &s,int n,int b)
{
	while(n)
	{
		PushSqStack(s,n%b);
		n=n/b;
	}
}

void DisplaySqStack(SqStack s)
{
	while(s.top!=s.base)
	{
		s.top--;
		printf("%d",*s.top);
	}
	printf("\n");
}

int main()
{
	SqStack stack;
	int n,b;
	printf("Print the num you want to convert:\n");
	while(scanf("%d",&n)!=EOF)
	{
		InitSqSatck(stack);
		printf("Input the conversion num b:");
		scanf("%d",&b);
		Conversion(stack,n,b);
		printf("After convert :\n");
		DisplaySqStack(stack);
	}
	return 0;
}


2019-03-30 20:28:52 lingzniao 阅读数 240
  • 图解Java数据结构和算法

    1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题: 1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了 2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级  3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴 3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容: 本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。 学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    3967 人正在学习 去看看 佟刚

栈的应用,进制转换问题
算法很简单,除X取余法,用栈来把余数存起来,再出栈即可
上代码…

/* 进制转换(seqsatck, 测试ok) */
/*
* author: Qian Jipeng
* date: 2019-3-23
* satus: done
*/

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

#define maxsize 10

typedef struct 
{
    int data[maxsize];
    int top;
}seqstack, *pseqstack;


pseqstack init_stack(){
    pseqstack s = (pseqstack)malloc(sizeof(seqstack));
    if(s){
        s -> top = -1;
    }
    return s;
}

void push_stack(pseqstack s, int e){
    if (!s || s -> top > maxsize -1){
        printf("入栈失败!\n");
        //return 0;
    }
    else{
        s -> top ++;        /*一定要先把TOP加一,否则top 原来是-1,导致第一个元素入栈失败(bug fixed!) */
        s -> data[s -> top] = e;
        //return 1;
    }
}

int pop_stack(pseqstack s, int *x){
    if (!s || s -> top == -1){
        printf("出栈失败!\n");
        return -1;
    }
    else{
        *x = s -> data[s -> top];
        s -> top --;
        return *x;
    }
}

/* 输出栈的每一个元素 */
void print_each(pseqstack s){
    int top0 = s->top;
    while(top0 != -1){
        printf("%d\n", s->data[top0]);
        top0 --;
    }
    
}

/*进制转换,x是十进制de 数,y 是待转换进制*/
void transfer(pseqstack s, int x, int y){
    
    int res;
    /*  整除后不等于0, 执行循环 */
    while(x != 0){
        push_stack(s, (x%y));
        x = x / y;
    }

    //printf("%d\n", s->top);

    /* 加上输出功能 */
    
    while(s-> top != -1){
        pop_stack(s, &res);
        printf("%d", res);
        if (s->top == -1){
            printf("\n");
        }
    }
    
}



int main(){
    
    int num;        // 十进制数
    int scale;      // 要转换的进制数
    printf("输入十进制数字,进制数: ");
    scanf("%d %d", &num, &scale);

    pseqstack S = init_stack();
    transfer(S, num, scale);
    
    //print_each(S);
    
}


没有更多推荐了,返回首页