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