数据结构上机实验(3)

xhao 2020-06-20

1、实现顺序栈的各种基本运算算法

数据结构上机实验(3)

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define Max_Size 100
typedef char ElemType;
typedef struct 
{
    ElemType data[Max_Size];
    int top;
}SeqStack;

//初始化栈
static void init_stack(SeqStack *&s) 
{
    s = (SeqStack *)malloc(sizeof(SeqStack));
    s->top = -1;
}
//销毁顺序栈
static void destroy_stack(SeqStack *&s)
{
    free(s);
}
//判断栈空否
static bool stack_empty(SeqStack *s)
{
    return (s->top == -1);
}
//进栈
static bool push(SeqStack *&s,ElemType e)
{
    if(s->top==(Max_Size-1))   //栈满的情况,栈上溢出
        return false;
    s->top++;
    s->data[s->top]=e;
    return true;
}
//出栈
static bool pop(SeqStack *&s,ElemType &e)
{
    if(s->top==-1)   //栈为空的情况,即栈下溢出
        return false;
    e=s->data[s->top];
    s->top--;
    return true;
}
//取栈顶元素
static bool get_top(SeqStack *s,ElemType &e)
{
    if(s->top==-1)
        return false;
    e=s->data[s->top];
    return true;
}

int main()
{
    ElemType e;
    SeqStack *s;

    printf("顺序栈s的基本运算如下:\n");
    printf("  (1)初始化栈s\n");
    init_stack(s);
    printf("  (2)栈为%s\n",(stack_empty(s) ? "空" : "非空"));
    printf("  (3)依次进栈元素a,b,c,d,e\n");
    push(s, ‘a‘);
    push(s, ‘b‘);
    push(s, ‘c‘);
    push(s, ‘d‘);
    push(s, ‘e‘);
    printf("  (4)栈为%s\n",(stack_empty(s) ? "空" : "非空"));
    printf("  (5)出栈序列:");
    while(!stack_empty(s))
    {
        pop(s, e);
        printf("%c ", e);
    }
    printf("\n");
    printf("  (6)栈为%s\n",(stack_empty(s) ? "空" : "非空"));
    printf("  (7)释放栈\n");
    destroy_stack(s);
}

数据结构上机实验(3)

2、实现链栈的各种基本运算的算法

数据结构上机实验(3)

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

typedef char ElemType;
typedef struct linknode
{
    ElemType data;
    struct linknode *next;
}LinkStNode;

//初始化链栈
static void init_stack(LinkStNode *&s) 
{
    s = (LinkStNode *)malloc(sizeof(LinkStNode));
    s->next = NULL;
}
//销毁链栈
static void destroy_stack(LinkStNode *&s)
{
    LinkStNode *p = s->next;
    while(p != NULL)
    {
        free(s);
        s = p;
        p = p->next;
    }
    free(s);   //s指向尾结点,释放其空间
}
//判断链栈空否
static bool stack_empty(LinkStNode *s)
{
    return (s->next == NULL);
}
//进栈
static void push(LinkStNode *&s,ElemType e)
{
    LinkStNode *p;
    p=(LinkStNode *)malloc(sizeof(LinkStNode));
    p->data=e;
    p->next=s->next;
    s->next=p;
}
//出栈
static bool pop(LinkStNode *&s,ElemType &e)
{
    LinkStNode *p;
    if(s->next==NULL)
        return false;
    p=s->next;
    e=p->data;
    s->next=p->next;   //删除首节点
    free(p);
    return true;
}
//取栈顶元素
static bool get_top(LinkStNode *s, ElemType &e)
{
    if(s->next==NULL)
        return false;
    e=s->next->data;   //提取首节点值
    return true;
}

int main()
{
    ElemType e;
    LinkStNode *s;

    printf("链栈s的基本运算如下:\n");
    printf("   (1)初始化栈s\n");
    init_stack(s);
    printf("   (2)栈为%s\n", (stack_empty(s) ? "空" : "非空"));
    printf("   (3)依次进栈元素a,b,c,d,e\n");
    push(s, ‘a‘);
    push(s, ‘b‘);
    push(s, ‘c‘);
    push(s, ‘d‘);
    push(s, ‘e‘);
    printf("   (4)栈为%s\n", (stack_empty(s) ? "空" : "非空"));
    printf("   (5)出栈序列:");
    while(!stack_empty(s))
    {
        pop(s, e);
        printf("%c ", e);
    }
    printf("\n");
    printf("   (6)栈为%s\n", (stack_empty(s) ? "空" : "非空"));
    printf("   (7)释放栈\n");
    destroy_stack(s);
}

数据结构上机实验(3)

3、实现环形队列各种基本运算算法

数据结构上机实验(3)

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define MAX_SIZE 100

typedef char ElemType;
typedef struct
{
    ElemType data[MAX_SIZE];
    int queue_front;   //队首指针
    int queue_rear;    //队尾指针
}SeqQueue; 


//初始化队列
static void init_queue(SeqQueue *&q) 
{
    q = (SeqQueue *)malloc(sizeof(SeqQueue)); // 动态分配存储空间
    q->queue_front = q->queue_rear = 0;   //空
}
//销毁队列q
static void destroy_queue(SeqQueue *&q)
{
    free(q);
}
//判断队列q是否空
static bool queue_empty(SeqQueue *q)
{
    return (q->queue_front == q->queue_rear);
}
//入队
static bool en_queue(SeqQueue *&q, ElemType e)
{
    if((q->queue_rear + 1) % MAX_SIZE == q->queue_front)   //队满,上溢出,返回假
        return false;
    q->queue_rear = (q->queue_rear + 1) % MAX_SIZE;   //计算队尾指针
    q->data[q->queue_rear] = e;   //将元素e入队
    return true;
}
//出队
static bool de_queue(SeqQueue *&q, ElemType &e)
{
    if(q->queue_front == q->queue_rear)   //队空,下溢出,返回假
        return false;
    q->queue_front = (q->queue_front + 1) % MAX_SIZE;   //计算队首指针
    e = q->data[q->queue_front];   //提取队列中的元素
    return true;
}

int main()
{
    ElemType e;
    SeqQueue *q;

    printf("环形队列基本运算如下:\n");
    printf("   (1)初始化队列q\n");
    init_queue(q);
    printf("   (2)依次进队元素a、b、c\n");
    if(!en_queue(q, ‘a‘))
        printf("\t提示:队满,不能入队\n");
    if(!en_queue(q, ‘b‘))
        printf("\t提示:队满,不能入队\n");
    if(!en_queue(q, ‘c‘))
        printf("\t提示:队满,不能入队\n");
    printf("   (3)队列为%s\n", (queue_empty(q) ? "空" : "非空"));
    if(!de_queue(q, e))
        printf("队空,不能出队\n");
    else
        printf("   (4)出队一个元素%c\n", e);

    printf("   (5)依次进队元素d、e、f\n");
    if(!en_queue(q, ‘d‘))
        printf("\t提示:队满,不能入队\n");
    if(!en_queue(q, ‘e‘))
        printf("\t提示:队满,不能入队\n");
    if(!en_queue(q, ‘f‘))
        printf("\t提示:队满,不能入队\n");

    printf("   (6)出队列序列: ");
    while(!queue_empty(q))
    {
        de_queue(q, e);
        printf("%c ", e);
    }
    printf("\n");
    printf("   (7)释放队列\n");
    destroy_queue(q);
}

数据结构上机实验(3)

4、实现链队的各种基本运算的算法

数据结构上机实验(3)

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define MAX_SIZE 100

typedef char ElemType;
typedef struct DataNode
{
    ElemType data;
    struct DataNode *next;
}DataNode; 
typedef struct
{
    DataNode *queue_front;   //队头指针
    DataNode *queue_rear;   //队尾指针
}LinkQuNode; 


//初始化队列
static void init_queue(LinkQuNode *&q)
{
    q = (LinkQuNode *)malloc(sizeof(LinkQuNode)); 
    q->queue_front = q->queue_rear = NULL;
}
//销毁队列q
static void destroy_queue(LinkQuNode *&q)
{
    DataNode *p = q->queue_front;   //p指向队头数据结点
    DataNode *r;

    if(p != NULL)
    {
        r = p->next;   //r指向队列中第一个数据结点
        while(r != NULL)
        {
            free(p);
            //p,r同步后移一个结点
            p = r;
            r = p->next;
        }
    }
    free(p);
    free(q);
}
//判断队列q是否空
static bool queue_empty(LinkQuNode *q)
{
    return (q->queue_rear == NULL);
}
//入队
static void en_queue(LinkQuNode *&q, ElemType e)
{
    DataNode *p;   //创建新结点p
    p = (DataNode *)malloc(sizeof(DataNode)); 
    p->data = e;
    p->next = NULL;
    // 若链队为空,则新结点既是队首结点又是队尾结点
    if(q->queue_rear == NULL)
        q->queue_front = q->queue_rear = p;
    else
    {
        //将新结点p链到队尾,并将queue_rear指向它
        q->queue_rear->next = p;
        q->queue_rear = p;
    }
}
//出队
static bool de_queue(LinkQuNode *&q, ElemType &e) 
{
    DataNode *t;
    if(q->queue_rear == NULL)   //队列为空
        return false;
    t = q->queue_front;   //t指向第一个数据结点
    if(q->queue_front == q->queue_rear)   //队列中只有一个结点时
    {
        q->queue_front = q->queue_rear = NULL;
    }
    else   //队列中有多个结点时
    {
        q->queue_front = q->queue_front->next;   //队首指针后移一个结点
    }
    e = t->data;   //从t结点中提取数据元素
    free(t); 
    return true;
}

int main()
{
    ElemType e;
    LinkQuNode *q;

    printf("链队的基本运算如下:\n");
    printf("  (1)初始化链队q\n");
    init_queue(q);
    printf("  (2)依次进链队元素a、b、c\n");
    en_queue(q, ‘a‘);
    en_queue(q, ‘b‘);
    en_queue(q, ‘c‘);
    printf("  (3)链队为%s\n", (queue_empty(q) ? "空" : "非空"));

    if(!de_queue(q, e))
        printf("\t提示:队空,不能出队\n");
    else
        printf("  (4)出队一个元素%c\n", e);
    printf("  (5)依次进链队元素d、e、f\n");
    en_queue(q, ‘d‘);
    en_queue(q, ‘e‘);
    en_queue(q, ‘f‘);
    printf("  (6)出链队序列: ");
    while(!queue_empty(q))
    {
        de_queue(q, e);
        printf("%c ", e);
    }
    printf("\n");
    printf("  (7)释放链队\n");
    destroy_queue(q);
}

数据结构上机实验(3)

5、用栈求解迷宫问题的所有路径及最短路径程序

数据结构上机实验(3)

数据结构上机实验(3)

//本题书上代码有误，运行后为死循环输出不了所有路径
//本题代码学习于CSDN作者- 不想悲伤到天明
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std ;
const int MAX = 105 ;
int mg[MAX][MAX] ={
{1,1,1,1,1,1},
{1,0,0,0,1,1},
{1,0,1,0,0,1},
{1,0,0,0,1,1},
{1,1,0,0,0,1},
{1,1,1,1,1,1}
 
};//迷宫地图
 
struct Point{
	int x ;// 路径横坐标
	int y ;// 路径纵坐标 ;
	int di ;// 方向
};
typedef struct{
	int top ;
	Point data[MAX] ;
}Stack;
class STACK{
	
	public:
		void InitStack(Stack *&s);
		bool StackEmpty(Stack *&s);
		bool Push(Stack *&s ,Point &e);
		bool Pop(Stack *&s ,Point &e);
		bool GetTop(Stack *&s ,Point &e);
};
void STACK::InitStack(Stack *&s)
{
	s = (Stack *)malloc(sizeof(Stack)) ;
	s->top = -1  ;
	return ;
}
bool STACK::StackEmpty(Stack *&s)
{
	return (s->top ==-1) ;
}
bool STACK::Push(Stack *&s ,Point &e)
{
	if(s->top == MAX -1)
	{
		return false ;
	}
	s->top++ ;
	s->data[s->top] = e ;
	return true ;
}
bool STACK::Pop(Stack *&s ,Point &e)
{
	if(s->top ==-1)
	{
		return false ;
	}
	e = s->data[s->top] ;
	s->top-- ;
	return true ;
	
}
bool STACK::GetTop(Stack *&s ,Point &e)
{
	if(s->top ==-1)
	{
		return false ;
	}
	e = s->data[s->top ] ;
	return true ;
}

int count = 1  ; // 记录路径数目
int minlen = 0x3f3f;   //最短路径长度，先设为最大 
Point path[MAX] ;
void dfs(Point start ,Point end)
{
	bool find ;
	Point head ;
	STACK a ;
	Stack *s ;
	a.InitStack(s);
	start.di = -1 ;// 开始点,且还没有尝试 ;
	a.Push(s,start);
	mg[start.x][start.y] = -1 ;
	while(!a.StackEmpty(s))
	{
		head;// 栈顶元素
		a.GetTop(s,head) ;
		if(head.x == end.x && head.y == end.y)
		{
			count++ ;
			printf("Map   %d :\n",count-1);
			for(int k = 0 ;k<=s->top ;k++)
			{
				printf("(%d ,%d) ",s->data[k].x,s->data[k].y);
				
				if((k+1)%5==0)   //输出上更好直观判断最短路径
				cout<<endl;
			}
			
			printf("\n\n");
			if(s->top+1 <minlen)
			{
				for(int k = 0 ;k<=s->top ;k++)
				{
					path[k] = s->data[k] ;
				}
				// 更新最短路径
				minlen = s->top+1 ;
			}
			// 退栈,重新走
			mg[s->data[s->top].x][s->data[s->top].y] = 0 ;
			s->top--;
			head.x = s->data[s->top].x ;
			head.y = s->data[s->top].y ;
			head.di = s->data[s->top].di ;
			
		}
		find = false ;
	
		while(head.di<4 && !find)
		{
			head.di++ ;
			switch(head.di){
				
				case 0:head.x=s->data[s->top].x -1 ;head.y =s->data[s->top].y;break;//上面
 
                case 1:head.x=s->data[s->top].x ;head.y =s->data[s->top].y+1;break;//右边
 
                case 2:head.x=s->data[s->top].x +1 ;head.y =s->data[s->top].y;break;//下面
 
                case 3:head.x=s->data[s->top].x  ;head.y =s->data[s->top].y-1;break;//左边
			}
				
			if(mg[head.x][head.y]==0)
			{
				find = true ;
			}
 
		}
		
		if(find)
		{
			//如果有路
			s->data[s->top].di = head.di ; // 修改原来栈顶的方向值
			s->top++;
			s->data[s->top].x = head.x ;// 入栈
			s->data[s->top].y = head.y ;
			s->data[s->top].di = -1 ;// 此点还没有进行过尝试
			mg[head.x][head.y] = -1 ;//访问过了
		}
		else
		{
			//回溯
			mg[s->data[s->top].x][s->data[s->top].y] = 0 ;
			s->top --;
		}
	
	}
		
		printf("最短路径长度为 :%d\n",minlen);
		printf("最短路径 :");
		for(int k = 0 ;k <minlen ;k++)
		{
			printf("(%d,%d)",path[k].x,path[k].y) ;
		}
		cout<<endl;
	
}
int main()
{
	Point start ,end ;
	start.x = 1 ;
	start.y = 1 ;
	end.x = 4 ;
	end.y = 4 ;
	dfs(start,end);
}

数据结构上机实验(3)

6、求解栈元素排序问题

数据结构上机实验(3)

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

#define MAX_SIZE 100

typedef char ElemType;
typedef struct
{
    ElemType data[MAX_SIZE];
    int top;   //栈顶指针
}SeqStack; 

//初始化顺序栈
static void init_stack(SeqStack *&s) 
{
    s = (SeqStack *)malloc(sizeof(SeqStack));
    s->top = -1;
}

//销毁顺序栈
static void destroy_stack(SeqStack *&s)
{
    free(s);
}

//判断栈空否
static bool stack_empty(SeqStack *s)
{
    return (s->top == -1);
}

//进栈
static bool push(SeqStack *&s, ElemType e)
{
    if(s->top == (MAX_SIZE - 1))   //栈满的情况,栈上溢出
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

//出栈
static bool pop(SeqStack *&s, ElemType &e) 
{
    if(s->top == -1)   //栈为空的情况,即栈下溢出
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

//取栈顶元素
static bool get_top(SeqStack *s, ElemType &e)
{
    if(s->top == -1)   //栈为空的情况,即栈下溢出
        return false;
    e = s->data[s->top];
    return true;
}

//对栈中元素排序
/**
*   功能:对栈st中元素排序
*   @param st:要排序的栈
*   思路:
*       采用一个额外的栈tmpst存放临时数据。
*       处理st栈的某个栈顶元素e，出栈元素e，将其存放在tmpst中。若临时栈tmpst为空，直接
*   将e进入tmpst中；若tmpst栈不空，将它的元素退栈(放入st栈中)直到tmpst栈顶元素小于e，再
*   将tmp进入到tmpst中，进行这样的过程直到st为空，而tmpst中元素从栈底到栈顶是递增的。再
*   将tmpst中所有元素退栈并进栈到st中。
*/
static void sort(SeqStack *&st)
{
    SeqStack *tmpst;   //临时栈
    ElemType e, e1;
    init_stack(tmpst);   //初始化临时栈
    while(!stack_empty(st))   //st栈不空循环
    {
        pop(st, e);   //出栈元素e
        printf("    st:出栈%c=> ", e);
        while(!stack_empty(tmpst))   //tmpst栈不空循环
        {
            get_top(tmpst, e1);   //取栈顶元素e1
            printf("tmpst:取栈顶元素%c", e1);
            if(e1 > e)
            {
                printf("因%c>%c ", e1, e);
                printf("tmpst:退栈%c ", e1);
                pop(tmpst, e1);
                printf("s:进栈%c ", e1);
                push(st, e1);
            }
            else
            {
                printf("因%c<%c,退出循环", e1, e);
                break;
            }
        }
        push(tmpst, e);
        printf("tmpst:进栈%c\n", e);
    }
    while(!stack_empty(tmpst))
    {
        pop(tmpst, e);
        push(st, e);
    }
    destroy_stack(tmpst); 
}    

int main()
{
    ElemType e;
    SeqStack *s;

    init_stack(s);
    printf("(1)依次进栈元素1,3,4,2\n");
    push(s, ‘1‘);
    push(s, ‘3‘);
    push(s, ‘4‘);
    push(s, ‘2‘);
    printf("(2)栈s排序过程:\n");
    sort(s);
    printf("(3)栈s排序完毕\n");
    printf("(4)s的出栈序列:");
    while(!stack_empty(s))
    {
        pop(s, e);
        printf("%c ", e);
    }
    printf("\n");
    destroy_stack(s);
}

数据结构上机实验(3)

7、用栈求解n皇后问题

数据结构上机实验(3)

//学习于CSDN作者- _奶酪
#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100

int n,num=1;//num定义为全局变量
typedef struct node {
    int col[maxn];//col[i]表示第i个n皇后的列数，（i，col[i])即为坐标
    int top;
}stacktype;

void display(stacktype st)
{
    printf("    第%d个解为：",num++);
    for(int i=1;i<=n;i++)
        printf("(%d,%d) ",i,st.col[i]);
    printf("\n");
}

bool place(stacktype st,int k,int j)
{
    int i=1;
    if(k==1) return true;   //第一个皇后直接放入，没有任何冲突
    while(i<=k-1)   //遍历前k-1个皇后，判断第k个皇后是否可以放在（k,j）处
    {
        if((st.col[i]==j)||(abs(st.col[i]-j)==abs(i-k)))
            return false;
        i++;
    }
    return true;
}
void queen(int n)
{
    int k;
    bool find;
    stacktype st;
    st.top=1;
    st.col[st.top]=0;
    while(st.top!=0)
    {
        k=st.top;   //记录栈顶皇后的个数
        find=false;
        for(int j=st.col[k]+1;j<=n;j++)   //回溯时要遍历当前列后面的列数，且下一个皇后的初始化列数为0
            if(place(st,k,j))
            {
                st.col[k]=j;
                find=true;
                break;   //找到第一个可以放入的位置
            }
        if(find)
        {
            if(k==n)
            {
                display(st);   //每次能放完n个皇后都要输出
            }
            else
            {
                st.top++;
                st.col[st.top]=0;
            }
        }
        else st.top--;   //回溯，最后while结束时是当第一个皇后放在（1，n)位置时无法将n个皇后都放下，st.top=0
    }
    if(num==1)
        printf("  此%d皇后问题无解!\n",n);
}
int main()
{
    printf("n皇后问题求解:n=");
    scanf("%d",&n);
    if(n>20) printf("n必须小于20\n");
    else
    {
        printf(" %d皇后问题的求解情况如下:\n",n);
        queen(n);
    }
}

数据结构上机实验(3)

xhao

xhao

相关推荐

详解Redis数据结构之跳跃表

我们先不谈Redis，来看一下跳表。还要支持输入道具名称的精确查询和不输入名称的全量查询。拍卖行商品列表是线性的，最容易表达线性结构的是数组和链表。每个元素均关联一个double类型的score，Redis 根据score进行从小到大排序；这个是 Redi

koushr / 0评论 2020-11-12

数据结构之利用PHP实现二分搜索树

二叉树具有天然的递归结构，每个节点的左儿子或右儿子也是 二叉树。二叉树不一定是满的，可能只有左儿子或又儿子。

KAIrving / 0评论 2020-10-25

泛型和元编程的模型：Java, Go, Rust, Swift, D等

在程序设计的时候，我们通常希望使用同样的数据结构或算法，就可以处理许多不同类型的元素，比如通用的List或只需要实现compare函数的排序算法。在本文中，我将带你领略不同语言中的泛型系统以及它们是如何实现的。我将从C这样的不具备泛型系统的语言如何解决这个

zhangxiafll / 0评论 2020-11-13

万能Python的秘诀：操纵数据的内置工具

本文转载自公众号“读芯术”。Python可谓是如今最流行的编程语言，甚至孩子们也可以从它开始学习趣味编程。Python类似英语的简单语法使它成为一种通用语言，已在全世界各个领域被广泛使用。Python的万能之处正在于其内置的数据结构，它使编码变得简单，不受

kikaylee / 0评论 2020-10-31

Java实现单链表、栈、队列三种数据结构

它里面的数据元素是以结点为单位，每个结点是由数据元素的数据和下一个结点的地址组成，在java集合框架里面 LinkedList、HashMap等等的底层都是用链表实现的。添加效率高：添加一个元素时，先找到插入位置的前一个，只需要将1，2个元素的连接断开，将

范范 / 0评论 2020-10-28

Map和Set两种数据结构在ES6的作用

什么又是字典呢？每个元素有一个称作key 的域，不同元素的key 各不相同。它们之间又有什么区别呢？大多数主流编程语言都有多种内置的数据集合。然而 JavaScript 直到ES6的发布之前，只拥有数组和对象这两个内建的数据集合。Set中的元素只会出现一次

MILemon / 0评论 2020-10-22

「算法与数据结构」带你看回溯算法之美

我对回溯算法有一定理解：回溯算法建立在DFS基础之上的，但不同的是在搜索的过程中，达到结束条件后，恢复状态，回溯上一层，再次搜索，因此我们可以这样子理解，回溯算法与DFS的区别就是有无状态重置。如果你还不了解什么是回溯算法，或者知道一些，但是对于它具体是如

hugebawu / 0评论 2020-10-12

比较JavaScript中的数据结构（数组与对象）

在编程中，如果你想继续深入，数据结构是我们必须要懂的一块， 学习/理解数据结构的动机可能会有所不同，一方面可能是为了面试，一方面可能单单是为了提高自己的技能或者是项目需要。无论动机是什么，如果不知道什么是数组结构及何时使用应用字们，那学数据结构是一项繁琐

LauraRan / 0评论 2020-09-28

学c++需要先学c语言吗？

看需求，如果是底层开发，就必须学习C语言。如果只是应用开发，可以直接从C++开始学习。实际上这两个语言是平等的，只是在语法上C++尽量与C兼容，但仍然有很多不同的地方。1) C++不是C的超集。2) 如果你选择了一本好书，学C++之前完全没有必要学C，即使

shenwenjie / 0评论 2020-09-24

动图演示：手撸堆栈的两种实现方法！

正式开始之前，先和各位朋友聊聊公众号后期的一些打算，后面的文章计划写一些关于数据结构和算法的内容，原因很简单「底层结构决定上层建筑嘛」，对于框架满天飞的今天，我们不止要学习如何使用框架，更要了解它的原理以及底层数据结构，只有这样我们才能更好的应用它。当然，

omyrobin / 0评论 2020-09-23

技术人员思维和认知升级

今天这篇文章准备整理下我原来谈过的和技术人员相关的思维方面的话题，整个内容实际上包括两个方面。其一是我们可以从开发和技术中借鉴哪些思维方式；其二是技术人员本身不要受限于技术中，而应该跳出盒子培养价值驱动下的经营思维。结构化思维是架构思维必须具备的，最常用的

guangcheng / 0评论 2020-09-22

python的链表基础知识点

python中的链表是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。链表有两种类型：单链表和双链表。一个单独的列表元素叫做一个节点。这些节点不像数组一样都按顺序存储在内存当中，相反，你可以通过一个节点指向另外一个

qiangde / 0评论 2020-09-13

数据结构 4

//顺序表的插入操作 bool ListInsert { if//判断i的范围是否合法 return false if//存储空间是否满了 return false; //开始插入元素 for{ L.data[j] = L.dat

hanyujianke / 0评论 2020-08-18

HBase/TiDB都在用的数据结构：LSM Tree，不得了解一下？

LSM Tree广泛应用在HBase，TiDB等诸多数据库和存储引擎上，我们先来看一下它的一些应用：。这么牛X的名单，你不想了解下LSM Tree吗？装X之前，我们先来了解一些基本概念。设计数据存储系统可能需要考虑的一些问题有：ACID，RUM。读性能体现

晨曦之星 / 0评论 2020-08-14

编写更简洁的Python代码的5个技巧

许多人刚开始学习编程时会选择Python。Python确实是初学者友好的。当您按照其官方网站上的下载和安装说明进行操作时，很快就可以编写" Hello World"程序。当您了解更多关于Python的知识时，您可能会着迷于它使用不同方

xiesheng / 0评论 2020-08-06

盘点 Python 10 大常用数据结构（下篇）

上篇文章中4种数据结构相信大家都已经比较熟悉，因此我言简意赅的介绍一遍。接下来再详细的介绍下面6种数据结构及各自使用场景，会列举更多的例子。基本用法 deque 双端队列，基于list优化了列表两端的增删数据操作。实现原理：cpython实现deque使用

KAIrving / 0评论 2020-08-02

盘点 Python 10 大常用数据结构（上篇）

如果你还处于Python入门阶段，通常只需掌握list、tuple、set、dict这类数据结构，做到灵活使用即可。因为相比于list, tuple实例更加节省内存，这点尤其重要。并且set内允许增删元素，且效率很高。但是值得注意，dict占用字节数是li

xiesheng / 0评论 2020-08-02

图解！24张图彻底弄懂九大常见数据结构！ 原创 Amazing10 业余码农 5月24日

数据结构想必大家都不会陌生，对于一个成熟的程序员而言，熟悉和掌握数据结构和算法也是基本功之一。数据结构本身其实不过是数据按照特点关系进行存储或者组织的集合，特殊的结构在不同的应用场景中往往会带来不一样的处理效率。常用的数据结构可根据数据访问的特点分为线性结

范范 / 0评论 2020-07-30

什么是hash?

这个特定的算法就叫hash算法，hash算法并不是一个固定不变的算法。只要是能达到这个目的的算法都可以说hash算法。例如MD5,SHA，String.hashcode()都是hash算法。另外不同的输入可能会得出相同的hash值，那么这种现象称为hash

chenfei0 / 0评论 2020-07-30

数据结构--二叉树（Java）

文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！能提高数据存储，读取的效率, 比如利用 二叉排序树，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。如果该二叉树的所有叶子节

waitwolf / 0评论 2020-07-30

可持久化数据结构（线段树，trie树）

又称主席树，因为发明这一算法的人的名字缩写为HJT。通过下图主席树的结构进行一下理解，黑色部分是普通的线段树，有颜色部分为每次的修改。看一下实现过程。「区间第k小」给定 n 个整数构成的序列 a，将对于指定的闭区间 [l,r] 查询其区间内的第 k 小值。

Dyancsdn / 0评论 2020-07-28

数据结构C语言实现----图

for //初始化数组，输入各结点数据

lebronchen / 0评论 2020-07-28

java数据结构与算法一：稀疏数组

因为二维数组的很多值是默认值0，因此记录了很多没有意义的数据，可采用稀疏数组解决此问题。当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。稀疏数组中第一行依次存放着总行数、总列数、 不同值的个数，其他行则依次存放着值所在的行

mingyunxiaohai / 0评论 2020-07-28

数据结构与算法（23）——表达式解析

读入‘+‘，当前节点设置为+，创建右子节点，当前节点下降。创建一个栈来跟踪父节点：当前节点下降时，将下降前的节点push入栈 当前节点需要上升到父节点时，上升到pop出栈的节点即可！由前述对子表达式的描述，可从树的底层子树开 始，逐步向上层求值，最终得到整

妖怪哪里跑 / 0评论 2020-07-26

数据结构 &amp; Java中的内存

顺序表 ，将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示。链表 ，将元素存放在通过链接构造起来的一系列存储块中。ArrayList 的 本质是对 数组Object[ ] 的封装，将该数组作为它的一个属性。对 ArrayLis

mingyunxiaohai / 0评论 2020-07-19

重新整理数据结构与算法(c#)——算法套路k克鲁斯算法[三十]

每次选择最小的边。但是会遇到一个小问题，就是会构成回路。比如说第四步中，最小边是CE，但是没有选择CE，因为CE会形成回路。判断两个点的终点，是否一致。是这样子的，如何两个点可以共同到达任何一个点，那么他们之间一定是通的，这一点是肯定的，如果他们本来就是通

natloc / 0评论 2020-07-19

数据结构之栈

class Stack: def __init__: self.stack=[] def push: self.stack.append def pop: return self.stack.pop() def peek: if len >=1

Masimaro / 0评论 2020-07-19

数据结构C语言实现----入队列操作

New_node = malloc;//创建一个队列元素的结点

ding0 / 0评论 2020-07-18

重新整理数据结构与算法(c#)——算法套路贪心算法[二十八]

贪心算法，记得学的时候还是大学的时候，再次来总结一下吧。贪心算法并不是指具体的固定代码，而是指一种思路，加入我们每次都选最好的选择，那么很大可能会得到最好的结果。思路，加入把k1到k5轮询一遍，发现k1、k2、k3可以覆盖范围最多，随便取一个，假设取k1。

Eduenth / 0评论 2020-07-17

scala 数据结构（四）：列表 List

Scala中的List 和Java List 不一样，在Java中List是一个接口，真正存放数据是ArrayList，而Scala的List可以直接存放数据，就是一个object，默认情况下Scala的List是不可变的，List属于序列Seq。5)如果

shenwenjie / 0评论 2020-07-07

scala 数据结构（五）：队列 Queue

1）队列是一个有序列表，在底层可以用数组或是链表来实现。2）其输入和输出要遵循先入先出的原则。后存入的要后取出。3）在Scala中，由设计者直接给我们提供队列类型使用。//补充操作符重载...按照队列的算法，会将数据添加到队列的最后。

muhongdi / 0评论 2020-07-07

Java数据结构与算法之冒泡排序、选择排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。从而减少不必要的比较。如果我们发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序。

风吹夏天 / 0评论 2020-07-07

scala 数据结构（八 ）：-map映射操作

在Scala中可以通过map映射操作来解决：。将集合中的每一个元素通过指定功能（函数）映射（转换）成新的结果集合这里其实就是所谓的将函数作为参数传递给另外一个函数,这是函数式编程的特点。def map[B]: HashSet[B] //map函数的签名。1

waitwolf / 0评论 2020-07-08

算法学习路线

算法学习是一条漫长而又苦涩的道路。之所以漫长，是因为有关算法的学习是无穷无尽的，如果你不想经历程序员的35岁之劫难，那就要不断地学习算法，提高自己的不可替代性。之所以是苦涩，是因为算法更像是数学题，对智力是有一定要求的，学习算法的过程中总是会质疑自己，相较

Cypress / 0评论 2020-07-08

scala 数据结构（九）：-filter、化简

上面的问题当然可以使用遍历list方法来解决，这里我们使用scala的化简方式来完成。4) 然后继续和下一个元素运行，将得到的结果继续返回给第一个参数，继续..

yunfenglee / 0评论 2020-07-08

scala 数据结构（七 ）：集 Set

集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。Set不可变集合的创建。val set = Set //不可变。2 集 Set-可变集合的元素添加和删除。set02 -= 2 // 操作符形式。set02.remove // 方法的形式，scala

yunfenglee / 0评论 2020-07-08

scala 数据结构（六）：映射 Map

1) Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对映射，Scala中不可变的Map是有序的，可变的Map是无序的。即创建包含键值对的二元组， 和第一种方式等价，只是形式上不同而已。对偶元组 就是只含有两个数据的元组。2) 如

kekeromer / 0评论 2020-07-08

scala 数据结构（一）：数据结构简介

3）Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。4）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变和不可变两种类型。1）不可变集

匆匆那些年 / 0评论 2020-07-07

数据结构-队列

线性表 —> 用数组或是链表来实现。若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素总，否则无法存入数据。* front指向第一个元素的！比如指向10，实际：下标10就是队尾

OldBowl / 0评论 2020-07-06

数据结构-栈

栈是LIFO结构，后进先出。限制了线性表的插入和删除位置，始终在栈顶进行。比如数字元素1、2、3依次进栈，出栈顺序可能是 1、2、3 / 1、3、2 / 2、1、3 / 2、3、1 / 3、2、1. 对于空间性能，顺序栈需要事先确定一个固定的长

niushao / 0评论 2020-07-06

数据结构-栈

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。Stack CreateStack{ //初始化最大容量为MaxSize的空栈。判断栈是否满了，可以根据栈顶位置与最大容量的关系。栈的链式存储结构实际上就是一个单链表，叫做链栈。因为是

hanyujianke / 0评论 2020-07-05

数据结构-二叉树

有几种特殊的二叉树，分别是斜二叉树、完全二叉树和满二叉树。对任何非空二叉树T，若n0表示叶结点的个数，n2是度为2的非叶结点的个数，那么二者满足关系n0=n2+1. 对于一般二叉树，我们也可以采取这种结构，但是会造成空间浪费，所以二叉树普遍采用链式存储。

Jasmineyaoyao / 0评论 2020-07-05

组件和状态设计能力

state数据结构设计 -----用数据描述所有内容。　　　　　　　　　　 数据要结构化，易于程序操作。　　　　　　　　　　 数据要可扩展，以便增加新功能。从功能上拆分层次。尽量让组件原子化。容器组件& UI组件

freedomfanye / 0评论 2020-07-04

[数据结构] 二叉树

{ //二叉树结点类定义。t->rChild : NULL; } //返回右子女。bool IsEmpty() { return root == NU

hanyujianke / 0评论 2020-07-04

数据结构——树与二叉树的遍历

树是学习数据结构的时候非常重要的一个数据结构，尤其是二叉树更为重要。就使用了红黑树，而Mysql的索引就使用到了B+树。恰好最近刷leetcode碰到了不少的有关。二叉树的题目，今天想着写个总结。其中每一个集合又是一棵树，并且称之为根的子树。分支节点：度不

roseying / 0评论 2020-07-04

《数据结构与算法之美》15——散列表（二）如何实现工业级别的散列表

通过上一节的学习，我们知道，散列表的查询效率并不能简单说成是O。它跟散列函数、装载因子、散列冲突等地都有关系。今天我们来学一下，如何设计一个可以应对各种异常情况的工业级散列表，来避免在散列冲突的情况下，散列表性能的急剧下降，并且能抵抗散列碰撞攻击？过于复杂

范范 / 0评论 2020-07-04

《数据结构和算法》之数据结构和算法的介绍（2）

}问：试写出用单链表标识的字符串类及字符串节点类的定义，并以此实现它的构造函数、以及计算传长度、串赋值、判断两串相等、求子串、两串连接　　、求子串在串中位置等7个成员函数。　　3）线性结构常见的有：数组、队列、链表和栈。　　非线性结构包括：二维数组、多维数

只能做防骑 / 0评论 2020-06-28

数据结构第7章小结

查找表是由同一类型的数据元素构成的集合。在查找的同时对表做修改操作，相应的表称之为动态查找表，否则称为静态查找表。平均查找长度是为确定记录在查找表中的位置，需和给定值进行比较的关键字个数的期望值。缺点是平均查找长度较大，当n很大时，不适合用顺序查找。对不同

xhao / 0评论 2020-06-29

数据结构第七章学习小结

其中，Pi为查找表中第i个记录的概率，且∑ P = 1；Ci为找到表中其关键字与给定值相等的第i个记录时，和给定值已进行过比较的关键字个数。提高二叉排序树的查找效率，就是尽量让二叉排序树的形状均衡；左子树和右子树的深度之差的绝对值不超过1；③正确率是评估捕

Dyancsdn / 0评论 2020-06-28

Java数据结构系列（2）——List集合

我们已经在Java数据结构系列——Collection中讲解了Collection接口，接下来看看Collection的子类——List集合。　　java.util.List 接口继承自Collection 接口，是单列集合的一个重要分支，习惯性地会将实现

范范 / 0评论 2020-06-28