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();
}