03-数据结构

于 2021-01-18 09:11:02 发布
阅读量125 收藏
点赞数
分类专栏： 笔记 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45304793/article/details/109065537
版权

1.基本概念

程序=数据结构+算法
时间复杂度：O
空间复杂度
时间复杂度时间复杂度O(n)
(1+n)*n/2—>O(1)
在这里插入图片描述1+longn+1=O(logn)
O(nn)是最大的
n3 + n2 + n = O(n3)

logn=y
2y = n

1.1算法特性

1.有穷性：算法是由若干条指令组成的有穷序列，总是在执行若干次后结束，不能永不停止。
2.确定性：针对特定的输入一定有准确的结果，每条语句都有确定的含义，无歧义。
3.可行性：算法在当前环境条件下可以通过有限次运算实现。
4.输入：
5.输出：

1.2 算法在计算机中的时间消耗

1.算法优化程度
2.数据的输入规模
3.编译器对代码的优化程度
4.计算机的处理速度
数组：增O(1)、删O(n) 、改O(1)、查O(n)、排O(n2)、遍历O(n)

1.3 数据结构(数据之间的关系)

  • 逻辑结构
    • 线性结构：线性表、队列、栈(数据元素之间的关系是一对一)
    • 非线性：树形、图形
    • 树形结构：一对多的关系
    • 图形结构：多对多的关系
  • 储存结果
    • 线性存储：空间连续(数组)
    • 链式存储：空间不连续(链表)
  • 数据运算

2.线性表：

线性机构，元素之间的关系是一对一的
数组的方式实现线性表：

#define MAX 1000
typedef int data_t;
typedef strust LinkList{
data_t arr[MAN];
int last;
}LinkList,*LinkList_p;

#seqlist.h
#ifndef SEQLIST_H__
#define SEQLIST_H__

#include <stdio.h>
#include <stdlib.h> //malloc
#include <string.h> //memset

#define MAX 20

typedef int data_t;
typedef struct seqlist{
    data_t arr[MAX];
    int last; //数组中实际存储的元素个数
}seq,*seq_p;

//判断表满
int is_full(seq_p s); 
//判断表空
int is_empty(seq_p s); 
//在线性表的pos位置前插入数据
int insert_pos(seq_p s,int pos,data_t data);
//查找data的位置下标
int find_data(seq_p s,data_t data);
//在线性表中删除data值
int delete_data(seq_p s,data_t data);
//按位置删除，将删除的值给到value
int delete_index(seq_p s,int pos,data_t*value);
//将表中data修改成newdata
int updata(seq_p s,data_t data,data_t newdata);
//对表进行排序
void bubsort(seq_p s); 
void selectsort(seq_p s); 
void swap(int* i,int* j); 
void quicksort(seq_p s,int low,int hight);
//清空数据
void delete_all(seq_p s);
//打印指定下标的值
void print(seq_p s,int pos);
//打印所有值
void print_all(seq_p s); 
//释放堆空间
void destory(seq_p* s); 
//暂停
void wait();

#endif  

#seqlist.c
#include "seqlist.h"

//判断表满
int is_full(seq_p s){                                                                                                                                                                                                                  
    if(s->last == MAX-1)
        return -1;
    return 0;
}
//判断表空
int is_empty(seq_p s){ 
    if(NULL == s)
        return -1;
    return 0;
}
//在线性表的pos位置前插入数据
int insert_pos(seq_p s,int pos,data_t data){
    int res = is_full(s);
    if(res < 0){ 
        printf("Is full\n");
        return -1; 
    }   
    if(pos <= s->last){
        int temp = s->last;
        while(temp >= pos){
            s->arr[temp] = s->arr[temp-1];
            temp--;
        }
        s->arr[pos-1] = data;
        (s->last)++;
    }else{
        s->arr[s->last] = data;
        s->last++;
    }   
}
//查找data的位置下标
int find_data(seq_p s,data_t data){
    int i=0;
    for(i=0;i<s->last;i++)
        if(s->arr[i] == data)
            return i;
    return -1; 
}
//在线性表中删除data值
int delete_data(seq_p s,data_t data){
    int res = find_data(s,data);                                                                                                                                                                                                       
    if(res < 0){ 
        printf("No find\n");
        return -1; 
    }   
    int i=s->last-1;
    while(res < s->last){
        s->arr[res] = s->arr[res+1];
        res++;
    }
    (s->last)--;
}
//按位置删除，将删除的值给到value
int delete_index(seq_p s,int pos,data_t*value){
    if(pos >= s->last){
        printf("pos error\n");
        return -1;
    }
    *value = s->arr[pos-1];
    while(pos < s->last){
        s->arr[pos-1] = s->arr[pos];
        pos++;
    }
    (s->last)--;
}
//将表中data修改成newdata
int updata(seq_p s,data_t data,data_t newdata){
    int res = find_data(s,data);
    if(res < 0){
        printf("No find\n");
        return -1;
    }
    s->arr[res] = newdata;
}
//对表进行排序
void bubsort(seq_p s){
    int i,j;
    for(i=0;i<s->last-1;i++){
        for(j=0;j<s->last-1-i;j++)
            if(s->arr[j] > s->arr[j+1]){                                                                                                                                                                                               
                int temp = s->arr[j];
                s->arr[j] = s->arr[j+1];
                s->arr[j+1] = temp;
            }
    }
}
void selectsort(seq_p s){
    int i,j,k;
    for(i=0;i<s->last-1;i++){
        k=i;
        for(j=i+1;j<s->last;j++)
            if(s->arr[k] > s->arr[j])
                k=j;
        if(k != i){
            int temp = s->arr[k];
            s->arr[k] = s->arr[i];
            s->arr[i] = temp;
        }
    }
}
void swap(int* i,int* j){
    int temp = *i;
    *i = *j;
    *j = temp;
}
void quicksort(seq_p s,int low,int hight){
    if(low >= hight){
        return;
    }
    int l=low,r=hight,k=s->arr[low];
    while(l<r){
        while(s->arr[r]>=k && l<r)
            r--;
        while(s->arr[l]<=k && l<r)
            l++;
        swap(&s->arr[l],&s->arr[r]);
    }
    swap(&s->arr[r],&s->arr[low]);
    if(low<hight){
        quicksort(s,low,r-1);
        quicksort(s,r+1,hight);
    }
}
//清空数据
void delete_all(seq_p s){
    s->last = 0;
}
//打印指定下标的值
void print(seq_p s,int pos){
    printf("%d\n",s->arr[pos]);
}
//打印所有值
void print_all(seq_p s){
    int i;
    for(i=0;i<s->last;i++)
        print(s,i);
}
//释放堆空间
void destory(seq_p* s){
    free(*s);
    *s = NULL;
    printf("destory succeed\n");
}
//暂停
void wait(){
    printf("Please enter continue!");
    getchar();
}

//seqlist_view.c
#include "seqlist.h"
void chose(seq_p list){
	while(1){
		system("clear");
		int chose;
		printf("******1.插入数据\n");
		printf("******2.删除data值\n");
		printf("******3.按位置删除\n");
		printf("******4.修改值\n");
		printf("******5.排序\n");
		printf("******6.打印\n");
		printf("******7.清空\n");
		printf("******8.退出\n");
		printf("******please chose > ");
		scanf("%d",&chose);
		while(getchar() != '\n');

		switch (chose){
		case 1:
			srand(time(0));
			int i,num;
			for(i=0;i<5;i++){
				num = rand()%100;
				printf("Please input number > %d\n",num);
				insert_pos(list,1,num);
			}
			break;
		case 2:
			printf("Please input delete data > ");
			scanf("%d",&num);
			while(getchar() != '\n');
			delete_data(list,num);
			break;
		case 3:
			printf("Please input where delete > ");
			scanf("%d",&i);
			while(getchar() != '\n');
			delete_index(list,i,&num);
			printf("delete %d\n",num);
			break;
		case 4:
			printf("Please intput olddata > ");
			scanf("%d",&i);
			while(getchar() != '\n');
			printf("Please input newdata > ");
			scanf("%d",&num);
			while(getchar() != '\n');
			updata(list,i,num);
			break;
		case 5:
			printf("----1.bubsort\n");
			printf("----2.selectsort\n");
			printf("----3.quicksort\n");
			printf("Please chose > ");
			scanf("%d",&i);
			while(getchar() != '\n');
			switch(i){
				case 1:
					bubsort(list);
					break;
				case 2:
					selectsort(list);
					break;
				case 3:
					quicksort(list,0,list->last-1);
					break;
				default:
					break;
			}
			break;
		case 6:
			print_all(list);
			wait();
			break;
		case 7:
			delete_all(list);
			break;
		case 8:
			return;
		default:
			printf("input error\n");
			wait();
			break;
		}
	}
}

#main.c
#include "seqlist.h"

int main(int argc, const char *argv[])
{
	seq_p list = (seq_p)malloc(sizeof(seq));
	if(NULL == list){
		printf("malloc error\n");
		return -1;
	}
	memset(list,0,sizeof(seq));
	
	chose(list);
	destory(&list);
	return 0;
}

3.链表

链表：线性表的链式存储结构

将线性表中的各元素分布在存储器的不同存储单元，称为结点，通过指针进行连接构成链式结构
头结点：一般不存放数据
链表优点：添加和删除数据方便，访问的时候比较复杂

//链表结构
typedef int data_t;
typedef struct linklist{
	data_t data;
	struct linklist* next;
}lk,*lk_p;

链式结构

#func.h
#ifndef FUNC_H__
#define FUNC_H__
typedef int data_t
typedef struct linklist{
	data_t data;
	struct linklist* next;
}lk,*lk_p;

//

循环链表

  • 单向循环链表：
    • 创建链表的时候的结构
    typedef struct linklist{
	data_t data;
	struct linklist* next;
}
    • 创建头结点
    lk_p head = (lk_p)malloc(sizeof(lk));
memset(head,0,sizeof(lk));
head->mext = head;
  • 双向循环链表
    • 创建链表的时候的结构
    typdef struct DouCirLinkList{
	data_t data;
	struct DouCirLinkList* front;
	struct DouCirLinkList* next;
}dl,*dl_p;
    • 创建头结点
    dl_p head = (dl_p)malloc(sizeof(dl));
memset(head,0,sizeof(dl));
head->front = head;
head->next = head;

1.单向循环链表代码

#linklist.h
#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>
#include <stdlib.h> //malloc
#include <string.h> //memset

typedef int data_t;
typedef struct linklist{
    data_t data;
    struct linklist* next;
}lk,*lk_p;

//判断链表是否为空
int is_empty(lk_p head);
//判断链表是否存在
int is_exist(lk_p head);
//在链表头部插入数据
int insert_head(lk_p head,data_t data);
//在链表尾部插入数据
int insert_end(lk_p head,data_t data);
//删除链表中匹配的data的结点
int delete_data(lk_p head,data_t data);
//查找data的结点
lk_p find_data(lk_p head,data_t data);
//打印链表单个结点
void print(lk_p node);
//打印整个链表
void print_all(lk_p head);
//释放链表
void distory(lk_p* head);
//排序
void sort(lk_p head);
#endif

2.双向循环链表代码

栈

1.顺序栈-seqstack

2.共享栈-sharestack

3.链式栈-linkstack

队列

1.循环顺序队列

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

#define MAX 20
typedef int data_t;
typedef struct queue{
	data_t arr[MAX];
	int front;
	int tail; 
}que,*que_p;

//入队
int queue_in(que_p p,data_t value){
	//满的情况
	if((p->tail+1)%MAX == p->front){
		printf("queue is full\n");
		return -1;
	}
	p->arr[p->tail] = value;
	p->tail = (p->tail+1)%MAX;
}
//出队
int queue_out(que_p p,data_t*data){
	//空队列情况
	if(p->front == p->tail){
		printf("queue is empty\n");
		return -1;
	}
	//赋值后front移动
	*data = p->arr[p->front];
	p->front = (p->front+1)%MAX;
	return 0;
}
//打印
void print_all(que_p p){
	int num = p->front;
	while(num%MAX != p->tail){
		printf("%d ",p->arr[num]);
		num = (num+1)%MAX;
	}
	putchar(10);
	return;
}

int main(int argc, const char *argv[])
{
	que_p p = (que_p)malloc(sizeof(que));
	memset(p,0,sizeof(que));
	int i=0;
	for(i=0;i<MAX-1;i++)
		queue_in(p,i+1);//入队
	print_all(p);

	int res;
	for(i=0;i<10;i++){
		queue_out(p,&res);//出队
		printf("%d ",res);
	}
	putchar(10);
	print_all(p);
	//释放堆空间
	free(p);
	p = NULL;
	return 0;
}

运行结果

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 
1 2 3 4 5 6 7 8 9 10 
11 12 13 14 15 16 17 18 19

2.链式队列

#include <stdio.h>
#include <stdlib.h> //malloc
#include <string.h> //memset

#define MAX 20
typedef struct linkqueue{
	int data;
	struct linkqueue* next;
}lq,*lq_p;

//入队列
int linkqueue_in(lq_p* front,lq_p* tail,int data){
	lq_p new = (lq_p)malloc(sizeof(lq));
	if(new == NULL){
		printf("malloc error\n");
		return -1;
	}
	new->data = data;
	new->next = NULL;
	if(!*front){
		*tail = new;
		*front = new;
	}else{
		(*tail)->next = new;
		*tail = new;
	}
	return 0;
}
//出队列
int linkqueue_out(lq_p* front,lq_p*tail,int* data){
	if(!(*front)){
		printf("linkqueue is empty\n");
		return -1;
	}
	*data = (*front)->data;
	lq_p temp = *front;
	*front = (*front)->next;
	free(temp);
	if(!(*front)){
		*tail = NULL;
	}
}
//打印一个
void print(lq_p front){
	printf("%2d ",front->data);
}
//打印所有
void print_all(lq_p front,lq_p tail){
	while(front != tail){
		print(front);
		front = front->next;
	}
	print(front);
}
//销毁
void destory(lq_p* front,lq_p* tail){
	if(*front == *tail && *front == NULL){
		printf("linkqueue is empty\n");
		return;
	}
	while(*front != *tail){
		lq_p temp = *front;
		*front = (*front)->next;
		free(temp);
	}
	free(*front);
	*front = NULL;
	*tail = NULL;
	printf("destory succeed\n");
}

int main(int argc, const char *argv[])
{
	lq_p front,tail;
	front = tail = NULL;
	
	int i=0;
	for(i=0;i<20;i++){
		linkqueue_in(&front,&tail,i+1);
	}
	print_all(front,tail);
	putchar(10);
	printf("**********************\n");
	
	int res;
	for(i=0;i<10;i++){
		linkqueue_out(&front,&tail,&res);
		printf("%2d ",res);
	}
	putchar(10);
	print_all(front,tail);
	putchar(10);
	printf("**********************\n");
	
	destory(&front,&tail);

	return 0;
}

运行结果

 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 
**********************
 1  2  3  4  5  6  7  8  9 10 
11 12 13 14 15 16 17 18 19 20 
**********************
destory succeed

树

树的根节点：有且仅有一个
树是由若干个结点(>=0)组成的，如果结点个数为0则表示一个空树
树的根节点由若干个子树组成
树的度：结点的子树个数，整个树的度是其中所有结点中最大的度
树的深度，根节点深度为1，依次向下，树的深度是以最大深度计算
树的叶子结点：没有子树的结点称为叶子结点

  • 二叉树
    定义：树的每个结点的度不超过二
  • 特殊的二叉树
    斜树：左斜树、右斜树
    满二叉树：除叶子结点外，每一层的度都为2
    完全二叉树：深度之间的差值不能大于1，叶子结点从左往右连续，空的结点一定从右往左连续
    • 满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树
      例如：红黑树
#tree.h
#ifndef TREE_H__
#define TREE_H__

#include <stdio.h>
#include <stdlib.h> //malloc
#include <string.h> //memset

typedef char data_t;
typedef struct tree{
	data_t data;
	struct tree* lchild;
	struct tree* rchild;
}t,*t_p;

//创建
void creat_tree(t_p* p);
//前序
void pre_print(t_p p);
//中序
void mid_print(t_p p);
//后序
void tai_print(t_p p);
//销毁
void destory(t_p* p);
#endif


#tree.c
#include "tree.h"
//创建
void creat_tree(t_p* p){
	*p = (t_p)malloc(sizeof(t));
	if(!(*p)){
		printf("malloc error\n");
		return;
	}
	printf("Please input value > ");
	(*p)->data = getchar();
	while(getchar() != '\n');
	//是否要创建左孩子
	printf("Do you creat %C leftchild(y/n) > ",(*p)->data);
	int flag= getchar();
	while(getchar() != '\n');
	if(flag == 'y' || flag == 'Y'){
		creat_tree(&(*p)->lchild);
	}else{
		(*p)->lchild = NULL;
	}
	//是否要创建右孩子
	printf("Do you creat %c rightchild(y/n) > ",(*p)->data);
	flag = getchar();
	while(getchar() != '\n');
	if(flag == 'y' || flag == 'Y'){
		creat_tree(&(*p)->rchild);
	}else{
		(*p)->rchild = NULL;
	}
}
//前序
void pre_print(t_p p){
	if(p != NULL){
		printf("%c ",p->data);
		pre_print(p->lchild);
		pre_print(p->rchild);
	}
}
//中序
void mid_print(t_p p){
	if(p != NULL){
		mid_print(p->lchild);
		printf("%c ",p->data);
		mid_print(p->rchild);
	}
}
//后序
void tai_print(t_p p){
	if(p != NULL){
		tai_print(p->lchild);
		tai_print(p->rchild);
		printf("%c ",p->data);
	}
}
//销毁
void destory(t_p* p){
	if(!(*p)){
		return;
	}
	destory(&(*p)->lchild);
	destory(&(*p)->rchild);
	printf("end %c\n",(*p)->data);
	free(*p);
	*p = NULL;
}

#main.c
#include "tree.h"
int main(int argc, const char *argv[])
{
	t_p tree;
	creat_tree(&tree);
	printf("******creat end******\n");
	pre_print(tree);
	putchar(10);
	printf("******pre print end******\n");
	mid_print(tree);
	putchar(10);
	printf("******mid print end******\n");
	tai_print(tree);
	putchar(10);
	printf("******tai print end******\n");
	destory(&tree);
	return 0;
}
胖胖的小达
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值