数据结构与算法

已于 2022-05-12 16:30:54 修改
阅读量344 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-29 20:10:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aukshduiw/article/details/124503467
版权

1、数据结构基础

  • day1

DS DataStructure 数据结构 + 算法 = 程序；
1、数据 ：分为 数值型 和 非数值型（图像，音频）
数据：是信息的载体
结构：是数据之间的关系
数据元素，数据项：
2、数据类型：
数据类型是对数据元素的取值范围和运算类型的限定
原子类型：不可再分的类型：如整型、实型、字符型等。
结构类型：由若干类型组成，可在分解的，如整型数组可分解成成多个整型数据。
3、数据关系 Structure：
作用：方便管理，分层分结构。避免冲突。
线性关系、层次关系、网状关系、集合。
逻辑结构：线性结构、非线性。
存储结构：（**顺寻存储、链式存储、）索引存储、散列存储。
数据运算：插入、删除、查找、排序。增、删、查、改、排。
4、算法：是一个有穷规则（指令，语句）的有序集合。
1、算法特性（如下）：
（1）有穷性：算法执行的步骤是有限的；
（2）确定性：每个计算步骤无二义性；
（3）可行性：每个计算步骤能够在有限的时间内完成；
（4）输入：算法有零个或者多个外部输入；
（5）输出：有一个或者多个输出；
2、时间复杂度，空间复杂度（判断时间好坏的因数）.
（1）O(n),T(n);
(2) 代码的可读性，易读，易移植，易调试；
3、计算时间复杂度的方法（程序执行的次数）
（1） 例：int i , j;
for(i = 0;i < n;i++)
{
for(j=i;j<n;j++)
printf(“i+j=%d\n”,i+j);
}
大致的执行次数：n*n=n^2; O(n)=n^2; 冒泡排序的时间复杂度；
（2）量级：
常量级，线性级，平方，立方，对数，指数级（递增排序）

顺序表的实现，代码有待更新

顺序表的实现，代码有待更新。

//list.h
#ifndef _LIST_H
#define _LIST_H
#define MAXLEN 100
typedef int DataType;

typedef struct 
{
    DataType data[MAXLEN];
    int length;
}SeqList;
void Menu();//menu
void List_Init(SeqList *L);//init
void Disp_List(SeqList *L);//display
int Creat_List(SeqList *L,int length);//create
int Insert_List(SeqList *L,int pos,DataType *x);//insert
void List_Pos_Value(SeqList *L,int pos);//seek position value
void List_Value(SeqList *L,int x);//seek value
void Chg_List(SeqList *L,int i);//change position value
void chg_value(SeqList *L,int i,int j);//change value
int Del_List_Value(SeqList *L,int pos);//delete position value
void seq_list(SeqList *L,int o);
#endif


//list.c
#include"list.h"
#include<stdio.h>
#include<string.h>

typedef int DataType;
//init list
void List_Init(SeqList *L)
{
    memset(L->data,0,sizeof(L->data));
    L->length=-1;
}
// 1  create a list
int Creat_List(SeqList *L,int length)
{
	if(length >=MAXLEN || length<=0){printf("input out of maxlen!");return -1;}
    int i=0;
    for(;i<length;i++)
    {
        L->data[i]=i+1;
        L->length = i;
    }
    return 1;
}
//judge empty
int empty(SeqList *L)
{
    if(L->length == -1) 
    { 
        printf("list empty!");
        return 0;
    }
    else
    {
        printf("data[%d]\n",L->length);
        return 1;
    }
}
//judge full
int full(SeqList *L)
{
    if(L->length == MAXLEN-1)
    {
        printf("list full!");
        return 0;
    }
    else
    {
        printf("data[%d]\n",L->length);
        return 1;
    }
}
//display list
void Disp_List(SeqList *L)
{
    int i=0;
    for(i=0;i<L->length+1;i++)
    {
        printf("L->data[%d]\t = %d\t \n",i,L->data[i]);
    }
    printf("\n");
}
// 2 insert list
/**L list
 * pos local
 * x,insert number
 * */
int Insert_List(SeqList *L,int pos,DataType *x)
{
    int i=0;
    if(NULL == L){return -1;}
    else if(L->length >= MAXLEN-1){return -1;}
    else if(pos < 0 || (pos > L->length + 1)) {return -1;}
    for(i = 0; i < L->length+1-pos;i++)
    {
        L->data[L->length+1-i] = L->data[L->length-i];
    }
    L->data[pos]=*x;
    L->length +=1;
    return 1;
}
//delete list
int Del_List_Value(SeqList *L,int pos)
{
    int i=0;
    if( (L->length == -1) || (NULL == L) || pos < 0 || pos>L->length)
    {
        printf("delete error!\n");
        return -1;
    }
    else
    {
        for(;i<L->length-pos+1;i++)
        {
            L->data[pos-1+i]=L->data[pos+i];
        }
        L->data[L->length]=0;
        L->length -=1;
    }
}
void Menu()
{
    printf("\n           顺序表的各种操作");
    printf("\n============================================================");
    printf("\n|           1---建立顺序表                                 |");
    printf("\n|           2---插入元素（从1开始）                        |");
    printf("\n|           3---删除元素（从0开始）                        |");
    printf("\n|           4---按位置查找元素0                            |");
    printf("\n|           5---按值查找元素                               |");
    printf("\n|           6---按位置修改元素的值0                        |");
    printf("\n|           7---按值修改元素 0                             |");
    printf("\n|           8---求顺序表的长度                             |");
    printf("\n|           9---排序                                       |");
    printf("\n|           0---退出                                       |");
    printf("\n============================================================");
    printf("\n请输入菜单号（0-6）：");
}
//findvalue
void List_Pos_Value(SeqList *L,int pos)
{
    if( (L->length == -1) || (NULL == L) || pos < 0 || pos>L->length)
    {
        printf("position error!\n");
    }
        printf("L->data[%d] = %d",pos,L->data[pos]);
}
void List_Value(SeqList *L,int x)
{
    int i=0;
    for(i=0;i<=L->length;i++)
    {
        if(x == L->data[i])
        {
            printf("L->data[%d]= %d\n",i,x);
        }
    }
}
//change data[i] position value
void Chg_List(SeqList *L,int i)
{
    int n;
    if(i<0 || i>L->length)
        printf("enter error!!\n");
    else
    {
        printf("input change num:");
        scanf("%d",&n);
        L->data[i] = n;
    }
}
//change value
void chg_value(SeqList *L,int i,int j)
{
    int n;
    for(n=0;n<=L->length;n++)
    {
        if(L->data[n] == i)
        {
            L->data[n]=j;
        }
    }
}
//paixu 
void seq_list(SeqList *L,int o)
{
	int i,j;
	for (i=0;i<L->length;i++)
	{
		for (j=0;j<L->length;j++)
		{
			if(0 == 0)
			{
				if(L->data[i]>L->data[j])
				{
					L->data[i] = L->data[i] + L->data[j];
					L->data[j] = L->data[i] - L->data[j];
					L->data[i] = L->data[i] - L->data[j];
				}
			}
			else
			{
				if(L->data[i] < L->data[j])
				{
					L->data[i] = L->data[i] + L->data[j];
					L->data[j] = L->data[i] - L->data[j];
					L->data[i] = L->data[i] - L->data[j];
				}
			}
		}
	}
}


#include"list.h"
#include<stdio.h>
int main()
{
    SeqList L;
    DataType x;
    int pos,k;
    int n;
    char ch1,ch2,a;

    ch1='y';
    while(ch1 == 'y' || ch1 == 'Y')
    {
        Menu();
        scanf("%c",&ch2);
        getchar();
        switch(ch2)
        {
            //create
            case '1':
                List_Init(&L);
                printf("number of list:");
                scanf("%d",&n);
                if(1 == Creat_List(&L,n))
                {
                	printf("CreatList is:\n");
                	Disp_List(&L);
                }
                break;
            //insert
            case '2':
                  printf("insert_position:");
                  scanf("%d",&pos);
                  printf("insert_value:");
                  scanf("%d",&x);
                  Insert_List(&L,pos,&x);
                  printf("then:\n");
                  Disp_List(&L);
                  break;
            //delete
            case '3':
                  printf("delete_position:");
                  scanf("%d",&k);
                  Del_List_Value(&L,k);
                  printf("then:\n");
                  Disp_List(&L);
                  break;
            //find_pos_value
            case '4':
                  printf("seek pos value:");
                  scanf("%d",&pos);
                  List_Pos_Value(&L,pos);
                  break;
            //find_value
            case '5':
                  printf("seek value:");
                  scanf("%d",&k);
                  List_Value(&L,k);
                  break;
            //change pos value
            case '6':
                  printf("change pos value:");
                  scanf("%d",&k);
                  Chg_List(&L,k);
                  printf("then:\n");
                  Disp_List(&L);
                  break;
            //change value
            case '7':
                  printf("input old value:");
                  scanf("%d",&pos);
                  printf("input new value:");
                  scanf("%d",&k);
                  chg_value(&L,pos,k);
                  printf("then:\n");
                  Disp_List(&L);
                  break;
            //length of list
            case '8':
                  printf("len=%d\n",L.length+1);
                  break;
            case '9':
            	printf("输入1升序0降序：");
            	scanf("%d",&k);
            	seq_list(&L,k);
            	printf("then:\n");
            	Disp_List(&L);
            	break;
            case '0':
                  ch1='n';
                  break;
            default:printf("输入有误，请重新输入！");
        }
        if(ch2 != '0')
        {
            printf("\n按回车键继续！\n");
            scanf("%c",&a);
            getchar();
            if(a != '\xA')
            {
                getchar();ch1='n';
            }
        }
    }
}

单链表

link.h

#ifndef _LINK_H_
#define _LINK_H_
typedef int datatype;
// 定义一个单链表   用typedef将struct list重命名为List,将List *命名为ListNode
typedef struct list{
	datatype data;
	struct list *next;
}link;
//init and create linklist
link * creat_list();

//jugde empty
int empty(link *head);

//get length of link list
//头结点的下一个是 从1开始的。
int getlen(link *head);

//insert 
/*
1、head 表
2、pos 位置
3、x 插入的值
*/
int insert(link *head,int pos,int x);
//display
void disp(link *head);
//delete
int Del(link *head,int pos);
//change
int change(link *head,int pos,int n);
void insert_head(link *head,int data);
void head_back(link *head);
#endif

link.c

#include "link.h"
#include<stdlib.h>
#include<stdio.h>
typedef int datatype;
/*1、构造 2、创建初始化 3、判空 4、求表长 5、增删查改 6、清除销毁*/
//创建和初始化一起，不需要
link *creat_list()
{
	link * head=(link *)malloc(8);
	if(head == NULL)return NULL;
	head->data=-1;
	head->next=NULL;
}
//jugde empty
int empty(link *head)
{
	if(NULL != head)
		return (head->next == NULL)?1:0;
}
//get length of linklist
int getlen(link *head)
{
	int count=0;
	link *p=head;
	while(p->next != NULL)
	{
		count++;
		p = p->next;
	}
	return count;
}
//&s 表示要插入的元素；
//pos 表示要插入的位置；
//x 要插入元素的值；
int insert(link *head,int pos,int x)
{
	int j=0;
	link *p=head;
	if(head == NULL)return -1;
	int len=getlen(head)+1;
	if(pos<1 || pos>len)return -1;
	while(p->next != NULL && j<pos-1)
	{
		p=p->next;
		j++;
	}
	link *s=(link *)malloc(8);
	s->data=x;
	s->next=NULL;
	s->next=p->next;
	p->next=s;

	return 1;
}
//display
void disp(link *head)
{
	int i=0;
	link *p=head;
	int len=getlen(head);
	for(i=0;i<=len;i++)
	{
		if(0 == i)//分开打印 先打印头节点
		{
			printf("head \t=%d\n",p->data);
			p=p->next;
		}
		else
		{
			printf("data[%d] \t= %d\n",i,p->data);
			p=p->next;
		}
	}
}
//delete
//数组下标 从0开始
int Del(link *head,int pos)
{
	link *p=head;
	if(head == NULL)return -1;
	int len=getlen(head)+1;
	if(pos<1 || pos>len)return -1;
	while(pos--)
		p=p->next;
	printf("%d\n",p->data);
	link *q;
	q=p->next;
	p->next=q->next;
	free(q);
}
// 按位置修改值
/*
pos 位置
n 修改的值
*/
int change(link *head,int pos,int n)
{
	link *p=head;
	if(head == NULL)return -1;
	int len=getlen(head)+1;
	if(pos<1 || pos>len)return -1;
	while(pos--)
		p=p->next;
	p->data=n;
	return 0;
}
//头插法 
void insert_head(link *head,int data)
{
	link * n=(link *)malloc(8);
	n->data=data;
	n->next=head->next;
	head->next=n;
}
//头插法逆序
void head_back(link *head)
{
	link *p=head->next;
	head->next = NULL;
	link *q = NULL;
	while(p != NULL)
	{
		q = p->next;
		/*head->next = NULL;*/
		p->next = head->next;
		head->next=p;
		p=q;
	}
}
void qingchu(link *head,int pos)
{
	1;
}

双链表

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

typedef int data_t;

//构造双向链表节点类型
typedef struct node{
	data_t data;//节点的值
	struct node *next;//保存下一个节点的地址
	struct node *prior;//保存前一个节点的地址
}dlinklist;//给 struct node 取别名为 dlinklist

//创建空双向链表
dlinklist *createDlinklist()
{
	dlinklist *head = (dlinklist *)malloc(sizeof(dlinklist));//给头节点开空间
	if(NULL == head)
		return NULL;
	head->data = -1;
	head->next = NULL;
	head->prior = NULL;

	return head;
}
//判空
int dlinklist_is_empty(dlinklist *head)
{
	if(NULL == head)
		return -1;
	else
		return ((head->next == head->prior)?1:0);
}

//求双向链表中的节点个数
int getLengthDlinklist(dlinklist *head)
{
	if(NULL == head)
		return -1;
	int num = 0;
	dlinklist *p = head->next;
	while(p != NULL)
	{
		num++;
		p = p->next;
	}
	return num;
}

//按位置在双向链表中添加节点
int insertDlinklistByPos(dlinklist *head, int pos, data_t data)
{
	if(NULL == head)
		return -1;
	int len = getLengthDlinklist(head);
	if(pos < 0 || pos > len)//判断位置是否合法
		return -1;
	//准备新节点
	dlinklist *new = (dlinklist *)malloc(sizeof(dlinklist));
	if(NULL == new)
		return -1;
	new->data = data;
	new->next = NULL;
	new->prior = NULL;

	dlinklist *p = head;
	while(pos--)//找到 pos-1 位置
		p = p->next;
	//判断添加位置
	if(p->next != NULL)//中间位置添加
	{
		new->next = p->next;
		new->prior = p;
		p->next = new;
		new->next->prior = new;
	}
	else//链表末尾添加节点
	{
		new->prior = p;
		p->next = new;

	}

	return 0;
}
//按位置删除双向链表中的节点
int deleteDlinklistByPos(dlinklist *head, int pos)
{
	if(NULL == head)
		return -1;
	int len = getLengthDlinklist(head);
	if(pos < 0 || pos > len-1)//判断位置是否合法
		return -1;
	if(dlinklist_is_empty(head))
		return -1;

	dlinklist *p = head;
	while(pos--)//找到 pos-1 位置
		p = p->next;

	dlinklist *q = NULL;
	//判断删除节点的位置
	if(p->next->next != NULL)//删除中间位置节点
	{
		q = p->next;//p保存的是要删除的节点的地址
		p->next = q->next;
		q->next->prior = p;
		free(q);
		q = NULL;
	}
	else //删除双向链表中最后一个节点
	{
		q = p->next;
		p->next = NULL;
		free(q);
		q = NULL;
	}

	return 0;
}



//打印双向链表中节点的data值
void printDlinklist(dlinklist *head)
{
	if(NULL == head)
		return ;
	dlinklist *p = head->next;
	while(p != NULL)
	{
		printf("%d ",p->data);
		p = p->next;
	}
	printf("\n");
	return ;
}

自己写的

#ifndef _LINK_H_
#define _LINK_H_

typedef struct node{
		struct node * r;
		struct node * l;
		int data;
}link;
//Create List 创建空表
link *create_list();
//Destroy List 摧毁头节点
void dist_list(link* &head);
//Jugde Empty 判断是否为空
bool empty(link *head);
//Get Length Of List 求表长
int getlen(link *head);
//Insert data 插入数据
bool insert(link *head,int pos,int num);
//显示
void disp(link *head);

//查找
int check(link *head,int pos);

//删除
int Del(link *head,int pos);

//修改
void change(link *head,int pos,int num);
#endif

#include<stdio.h>
#include"link.h"
#include<stdlib.h>
#include<string>
link * create_list()
{
	link *head=(link *)malloc(12);
	head->data=-1;
	head->l=NULL;
	head->r=NULL;

	return head;
}
//bool 函数引用头文件 stdbool.h
bool empty(link *head)
{
	if(head->l == head->r) return true;
	return false;
}
//getlen 双向链表求表长
int getlen(link *head)
{
	link *p=head;
	int n=0;
	while(p->r != NULL)
	{
		n++;
		p=p->r;
	}
	return n;
}
//distroy
void dist_list(link* &head)
{
	free(head);
}
//insert 
bool insert(link *head,int pos,int num)
{
	if(NULL == head)return false;
	int len =getlen(head);
	if(pos<0||pos>len)return false;
	link *p=head;
	link *s=(link *)malloc(12);
	s->l=NULL;
	s->r=NULL;
	s->data=num;
	while(p->r !=NULL)
	{
		p=p->r;
	}
	if(p->r==NULL)
	{
		s->l=p;
		p->r=s;
	}
	else
	{
		s->r=p->r;
		p->r->l=s;
		p->r=s;
		s->l=p;
	}
	return true;
}
//display list
void disp(link * head)
{
	link *p=head;
	int i=0;
	while(p != NULL)
	{
		printf("data[%d] = %d\n",i++,p->data);
		p=p->r;
	}
}
int check(link *head,int pos)
{
	if(NULL == head)return -1;
		int len=getlen(head);
	if(pos<0||pos>len)return -1;
		link *p=head;
		int n=0;
	while(pos--)
	{
		n++;
		p=p->r;
	}
	printf("你查找的元素data[%d] = %d\n",n,p->data);
	return p->data;
}
//delete
int Del(link *head,int pos)
{
	if(NULL == head)return -1;
		int len=getlen(head);
	if(pos<0||pos>len)return -1;
		link *p=head;
		while(pos--)
			p=p->r;
		link *q=NULL;
		if(p->r->r != NULL)
		{
			q = p->r;
			p->r=q->r;
			q->r->l=p;
			free(q);
			q = NULL;
		}
		else
		{
			q=p->r;
			p->r=NULL;
			free(q);
			q = NULL;
		}
		free(q);
		return 1;
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"link.h"
int main()
{
	link * head=create_list();
	if(NULL == head) return -1;
	printf("Create Success!\n");
	
	int i=0;
	for(;i<5;i++)
	{
		insert(head,i,i+1);
	}
	disp(head);
	printf("\n");
	Del(head,2);
	disp(head);
	getchar();
}

顺序栈

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef int datatype;
#define len 7
typedef struct {
	datatype data[len];
	int top;
}stack;
stack *creat_stack()
{
	stack *s=(stack *)malloc(8);
	if(NULL == s)return NULL;
	memset(s->data,0,4);
	return s;
}
bool empty(stack * s)
{
	if(s==NULL)
		return false;
	else
		return ((s->top==-1)?true:false);
}
bool full(stack * s)
{
	if(s->top+1==len)return true;
	else
		return false;
	if(NULL==s)return false;
}
int push(stack *s,int data)
{
	if(NULL ==s)return -1;
	if(full(s))
	{
		return -1;
	}
	else
	{
		s->data[s->top+1]=data;
		s->top+=1;
	}
	return 0;
}
int pop(stack *s)
{
	if(NULL==s)return -1;
	if(empty(s))return -1;
	int n=s->data[s->top];
	s->top-=1;
	return n;
}
int disp(stack * s)
{
	if(empty(s))return -1;
	int i=0;
	for(;i<7;i++)
	{
		printf("%d ",s->data[s->top]);
		s->top--;
	}
	printf("\n");
}
int main()
{
	stack *s=creat_stack();
	if(NULL ==s)return -1;
	int i=0;
	for(;i<7;i++)
	{
		push(s,i+1);
	}
	disp(s);
	printf("%d\n",pop(s));
	getchar();
	return 0;
}

队列

#include<stdio.h>
#include<string>
#define SIZE 4
typedef struct queue{
	int data[4];
	int front;
	int last;
}seq;
seq *creat_queue()
{
	seq* que=(seq*)malloc(sizeof(seq));
	if(NULL==que)return NULL;
	que->front=que->last=0;
	return que;
}
bool empty(seq *que)
{
	if(NULL == que)return false;
	return ((que->front==que->last)?true:false);

}
bool full(seq *que)
{
	if(NULL==que)return false;
	if(que->last > que->front)
		return ( (que->last - que->front==SIZE-1)?true:false);
	if(que->front>que->last)
		return ( (que->front-que->last==1)?true:false );
}

bool in_que(seq *que,int data)
{
	if( (NULL==que))return false;
	que->data[que->last] = data;
	que->last=(que->last+1)%SIZE;
	return true;
}
int out_que(seq*que)
{
	if( (NULL==que))return -1;
	int data = que->data[que->front];
	que->front=(que->front+1)%SIZE;
	return data;
}
int main()
{
	seq *q=creat_queue();
	/*if(NULL == q)
	{
		printf("内存不足!\n");
		exit(-1);
	}*/
	int i=0;
	for(;i<3;i++)
	{
		in_que(q,i+1);
	}
	printf("%d\n",out_que(q));
	printf("%d\n",out_que(q));
	getchar();
	return 0;
}

链式队列

#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node{
	datatype data;
	struct node *next;
}seq;
typedef struct{
	seq *f,*r;
}link;
/*创建 判空 盘满 进栈 出栈 求长度 显示*/
link* create_queue()
{
	link *lq=(link *)malloc(sizeof(link));//头节点分配空间
	if(NULL == lq)return NULL;
	//seq *f=(seq*)malloc(sizeof(link));
	lq->f = (seq *)malloc(sizeof(seq));//给链表头尾指针 开辟空间并且初始化
	lq->r = lq->f;
	lq->f->data = -1;
	lq->r->next = NULL;

	return lq;
}
bool empty(link *lq)
{
	if(NULL == lq)return false;
	return ((lq->f->next == lq->r->next)?true:false);

}
int getlen(link *lq)
{
	int len=0;
	seq* p = lq->f->next;
	while(p!=NULL)
	{
		len++;
		p=p->next;
	}
	return len;
}
bool in(link *lq,datatype data)
{
	if(NULL == lq)return false;
	seq *n=(seq *)malloc(sizeof(seq));
	n->data=data;
	n->next=NULL;

	lq->r->next=n;//新节点接入链表
	lq->r = n;
	return true;
}
int out(link * lq)
{
	if(NULL == lq)return -1;
	if(empty(lq))return -1;

	datatype data=lq->f->next->data;
	seq *p = lq->f->next;
	lq->f->next = p->next;
	
	free(p);
	return data;
}
int main()
{
	//printf("size = %d\n",sizeof(link));
	link *lq=create_queue();
	if(NULL == lq)
	{
		printf("内存不足！\n");
		exit(-1);
	}
	in(lq,1);
	in(lq,2);
	in(lq,3);
	printf("%d\n",out(lq));
	printf("%d\n",out(lq));
	printf("%d\n",out(lq));
	printf("%d\n",out(lq));
	getchar();
}
小码哥.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构和算法
慧有未来
01-20 306
简单算法时间复杂度分析： 1.大O描述的是算法的运行时间与输入数据的关系 2.渐进时间复杂度，描述的是n趋于无穷时时间复杂度 动态规划: 最短路径： 松弛操作： dijkstra单元最短路径：不能处理图中带有负权边，复杂度O（ELogV） Bellman-Ford单元最短路径：不能处理带有负权环，可以判断，复杂度O（EV） 拥有负权环的图，不再拥有最短路径 Floyed算法...
数据结构和算法的选择
weixin_30457465的博客
08-30 408
　　本部分总结前面介绍的数据结构和算法，并讨论在不同的情况下如何进行选择。 通用数据结构：数组、链表、树、哈希表专用数据结构：栈、队列、优先级队列排序：插入排序、希尔排序、快速排序、归并排序、堆排序图：邻接矩阵、邻接表外部存储：顺序存储、索引文件、B-树、哈希方法 1 通用数据结构 ...
数据结构及算法概述
最新发布
weixin_65477256的博客
07-27 1026
​ 所谓的数据结构指的是用于研究数据元素之间的逻辑关系和存储关系，在对数据结构的定义中需要表示整个数据结构中的数据元素集合和数据元素之间的关系集合；​ 其中：D 表示数据元素集合；R 表示数据元素之间的关系集合；注意：​ 在运算过程中，具体运算的实现：​ 运算逻辑由逻辑结构决定；​ 具体实现算法由存储结构决定。​ 所谓的算法（Algorithm），指的是一个有穷规则（或语句、指令）的有序集合。​ 它确定了解决某一问题的一个运算序列。
数据结构与算法（java版）
Lord_War的博客
12-28 7801
转自：http://blog.csdn.net/column/details/datastructureinjava.html 目录 （1）数据结构与算法概念解析 （2）数据结构之数组 （3）数据结构之栈 （4）数据结构之队列 （5）数据结构之链表 （6）数据结构之二叉树 （7）数据结构之霍夫曼树 （8）数据结构之红黑树（一）——基础分析 （9）数据结构之红黑树（二）——插入操作
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Python数据结构与算法分析（第2版）1
08-03
【Python数据结构与算法分析（第2版）】是一本专为Python程序员设计的书籍，旨在帮助读者深入了解数据结构和算法在Python环境中的应用。作者布拉德利·米勒和戴维·拉努姆以其丰富的实战经验，清晰地阐述了如何高效...
C++数据结构与算法 （第4版）
01-06
- 算法与数据结构的关系。 - **线性表**： - 顺序表与链表的概念及其优缺点。 - 链表操作（如插入、删除等）的具体实现。 - 循环链表和双向链表的特点及应用场景。 - **栈与队列**： - 栈的基本操作（如入栈、...
数据结构与算法.pdf
08-07
#资源达人分享计划#
leetcode题库-TopLeedcode:根据【LeetCode字节跳动企业题库高频算法】、【牛客网客户端高频算法】、【小码哥恋上数据结构
06-29
leetcode题库 说明: 该清单主要针对客户端大厂算法面试。题目是按照统计的算法出现频率来排序的。 清单总题目数为70题，其中相同题型大概有3道，类似题目也有几道，实际也就60多题。如果准备面试的时间比较短，建议优先学习出现频率>1次的题目，大概近40题。要达到大厂面试算法要求，要能够在leetcode或牛客网上默写所有算法，并且能够口述算法每一步的作用(大多数的题目我都有备注)。许多算法经典思想，也要做了解，搞不懂的多去leetcode题解区看看。 每道题都有很多种解法，我给出来的题解一般是推荐度比较高或比较经典的解法，题目是以swift实现的，欢迎补充其他语言版本。 推荐: 若你想系统学习算法知识，我推荐你先学习 若你需要系统准备iOS面试，我推荐你看看 数据来源: 算法题:
快速入门数据结构和算法
AlbenXie的博客
11-09 539
简介：有哪些常见的数据结构？基本操作是什么？常见的排序算法是如何实现的？各有什么优缺点？本文简要分享算法基础、常见的数据结构以及排序算法，给同学们带来一堂数据结构和算法的基础课。 一 前言 1 为什么要学习算法和数据结构？ 解决特定问题。 深度优化程序性能的基础。 学习一种思想：如何把现实问题转化为计算机语言表示。 2 业务开发要掌握到程度？ 了解常见数据结构和算法，沟通没有障碍。 活学活用：遇到问题时知道要用什么数据结构和算法去优化。 二 数据结构基础 1 什么是数据结构？ 数据结..
Java数据结构与算法深度解析
“数据结构与算法Java语言描述，全网最全的Java数据结构与算法详解，包括详细目录、书签和图像描述，适用于深入学习。” 本文主要探讨了数据结构与算法的重要性及其在Java编程中的应用。数据结构和算法是编程的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值