链表
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct Node
{
int data;
structNode *pNext;
}NODE,*PNODE;
PNODE create_list(void);
void tranvel_list(PNODE phead);
int main(void)
{
PNODE phead=NULL;
phead=create_list();
tranvel_list(phead);
return 0;
}
PNODE create_list(void)
{
int len;//节点的个数
int val;//存入的值
int i;
PNODE pHead=(PNODE) malloc(sizeof(NODE));
PNODE ptail=pHead;
ptail->pNext=NULL;
if(NULL==pHead)
{
printf("分配失败,程序终止");
exit(-1);
}
printf("please enter lenter len=:");
scanf("%d",&len);
for(i=0; i<len; ++i)
{
printf("请输入第%d个节点的值",i+1);
scanf("%d",&val);
PNODE pNew=(PNODE) malloc(sizeof(NODE));
if(NULL==pNew)
{
printf("分配失败,程序终止");
exit(-1);
}
pNew->data=val;
ptail->pNext=pNew;
ptail=pNew;
ptail->pNext=NULL;
}
return pHead;
}
void tranvel_list(PNODE phead)
{
PNODE p=phead->pNext;
while(p!=NULL)
{
printf("%d",p->data);
p=p->pNext;
}
printf("\n");
}
链表的增加和删除
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct Node
{
int data;
structNode *pNext;
}NODE,*PNODE;
PNODE create_list(void);
void tranvel_list(PNODE phead);
bool is_empty(PNODE phead);
int length_list(PNODE phead);
bool insert_list(PNODE phead,int pos,intval);
bool delete_list(PNODE,int,int *);
void sort_list(PNODE);
int main(void)
{
intpn=0;
PNODE phead=NULL;
phead=create_list();
tranvel_list(phead);
int n= length_list(phead);
printf("length:%d\n",n);
insert_list(phead,3,78);
tranvel_list(phead);
delete_list(phead,4,&pn);
tranvel_list(phead);
return 0;
}
bool delete_list(PNODE pnode,int pos,int*val)
{
PNODEp=pnode;
PNODEr=NULL;
for(inti=0;i<pos-1;i++)
{
p=p->pNext;
}
r=p->pNext;
p->pNext=p->pNext->pNext;
free(r);
returntrue;
}
bool insert_list(PNODE phead,int pos,intval)
{
PNODE p=phead;
PNODE ptemp=NULL;
PNODE pnew=(PNODE)malloc(sizeof(NODE));
pnew->data=val;
for(int i=0;i<pos;i++)
{
p=p->pNext;
}
ptemp=p->pNext;
p->pNext=pnew;
pnew->pNext=ptemp;
return true;
}
int length_list(PNODE phead)
{
int num=0;
PNODE pn=phead;
while(pn->pNext!=NULL)
{
pn=pn->pNext;
num++;
}
return num;
}
bool is_empty(PNODE phead)
{
if(phead->pNext==NULL)
{
return true;
}
else
{
return false;
}
}
PNODE create_list(void)
{
int len;//节点的个数
int val;//存入的值
int i;
PNODE pHead=(PNODE) malloc(sizeof(NODE));
PNODE ptail=pHead;
ptail->pNext=NULL;
if(NULL==pHead)
{
printf("分配失败,程序终止");
exit(-1);
}
printf("please enter lenter len=:");
scanf("%d",&len);
for(i=0; i<len; ++i)
{
printf("请输入第%d个节点的值",i+1);
scanf("%d",&val);
PNODE pNew=(PNODE) malloc(sizeof(NODE));
if(NULL==pNew)
{
printf("分配失败,程序终止");
exit(-1);
}
pNew->data=val;
ptail->pNext=pNew;
ptail=pNew;
ptail->pNext=NULL;
}
return pHead;
}
void tranvel_list(PNODE phead)
{
PNODE p=phead->pNext;
while(p!=NULL)
{
printf("%d\t",p->data);
p=p->pNext;
}
printf("\n");
}
数据结构:
栈:
一种可以实现‘先进后出’的存储结构,栈类似于箱子。
栈的分类:
静态栈
动态栈
动态栈:(内核是链表)
出栈
压栈
代码:
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct node{
int data;
struct node * pnext;
}NODE,*PNODE;
typedef struct stack{
PNODE top;
PNODE bottom;
}STACK,*PSTACK;
init(PSTACK);
push(PSTACK,int);
travel(PSTACK p);
pop(PSTACK p);
int main()
{
STACK s;
init(&s);
push(&s,2);
push(&s,3);
push(&s,4);
push(&s,5);
travel(&s);
pop(&s);
travel(&s);
return 0;
}
init(PSTACK p)
{
PNODE phead=(PNODE)malloc(sizeof(NODE));
p->bottom=phead;
p->top=phead;
phead->pnext=NULL;
}
push(PSTACK p,int val)
{
PNODE pnew=(PNODE)malloc(sizeof(NODE));
pnew->data=val;
pnew->pnext=p->top;
p->top=pnew;
//p->rear->next=pnew;
// p->rear=pnew;
}
pop(PSTACK p)
{
PNODEptemp=p->top;
p->top=ptemp->pnext;
free(ptemp);
ptemp=NULL;
}
travel(PSTACK p)
{
PNODEptemp=p->top;
while(ptemp->pnext!=NULL)
{
printf("%d",ptemp->data);
ptemp=ptemp->pnext;
}
}
队列:
先进先出的结构。
分类:
链式队列。
静态队列。
Font:头部
Rear:尾部
Top bottom//栈;
队列的链式存储:
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct node
{
intdata;
struct node *next;
}NODE,*PNODE;
typedef struct queue
{
PNODE front;
PNODE rear;
int size;
}QUEUE,*PQUEUE;
void initQueue(PQUEUE q)
{
q->front=NULL;
q->rear=NULL;
q->size=0;
}
bool link_empty(PQUEUE q)
{
if(q->front==q->rear)
{
return true;
}
}
void outQueue(PQUEUE p)
{
if(p->front==p->rear)
{
free(p->front);
p->front=NULL;
p->rear=NULL;
}
PNODEtemp=p->front;
p->front=p->front->next;
free(temp);
}
void inserQueue(PQUEUE p,int val)
{
PNODE pnew=(PNODE)malloc(sizeof(NODE));
pnew->data=val;
pnew->next=NULL;
if(p->front==NULL)
{
p->front=pnew;
p->rear=pnew;
}
else
{
p->rear->next=pnew;
p->rear=pnew;
}
}
void trallQueue(PQUEUE p)
{
while(p->front)
{
printf("%d",p->front->data);
p->front=p->front->next;
}
}
int main(void)
{
QUEUE p;
initQueue(&p);
inserQueue(&p,2);
inserQueue(&p,5);
inserQueue(&p,7);
outQueue(&p);
trallQueue(&p);
printf("hello");
return 0;
}
[cpp] view plaincopy
1. /*
2. * main.c
3. *
4. * Created on: 2012-10-21
5. * Author: china
6. */
7. #include <stdio.h>
8. #include <stdlib.h>
9. #include <assert.h>
10. /*链式队列的定义如下所示*/
11. typedef int datatype;
12. typedef struct SNode {
13. datatype data;
14. struct SNode* next;
15. } QNode,*LinkList;
16. typedef struct {
17. LinkList front; //队首结点(即删除点)
18. LinkList rear; //队尾结点(即插入点)
19. } LinkQueue;
20.
21. int creat_empty_linkqueue(LinkQueue* queue) {
22.
23. LinkList head = (LinkList) malloc(sizeof(QNode));
24. if (NULL == head)
25. return -2;
26. head->next = NULL;
27. queue->front = queue->rear = head;
28. return 1;
29. }
30. int linkqueue_empty(const LinkQueue* queue) {
31. return queue->front == queue->rear;
32. }
33. int linkqueue_length(const LinkQueue* queue) {
34. int len = 0;
35. LinkList p = queue->front;
36. while (p != queue->rear) {
37. p = p->next;
38. len++;
39. }
40. return len;
41. }
42. int linkqueue_get_top_element(const LinkQueue* queue, datatype* e) {
43.
44. if (linkqueue_empty(queue)) {
45. return -1;
46. }
47. *e = queue->front->next->data;
48. return 1;
49. }
50.
51.
52. //入列
53. int linkqueue_enter(LinkQueue* queue, datatype e) {
54.
55. LinkList q = (LinkList) malloc(sizeof(QNode));
56. if (NULL == q)
57. return -2;
58. q->data = e;
59. q->next = NULL;
60. queue->rear->next = q; //修改队尾节点的指针域,使其指向新的队尾结点
61. queue->rear = q; //修改队尾指针使其指向新的队尾结点
62. return 1;
63. }
64. //出列
65. int linkqueue_delete(LinkQueue* queue, datatype* e) {
66. //方法1,(不符合队列的删除特性只在表头进行删除,即只操作对首指针front)
67. if (linkqueue_empty(queue)) {
68. return -1; //空队列
69. }
70. LinkList q = queue->front->next; //q指向将要被删除的对首结点
71. queue->front->next = q->next; //使头结点的指针域指向被删除的下一个结点
72. //如果删除的是最后一个结点,需要让queue->rear指向链表头结点!!!!
73. if (NULL==q->next) {
74. queue->rear=queue->front;
75. }
76. *e = q->data; //返回被删除对首元素的值
77. free(q);
78. q = NULL;
79. return 1;
80. //方法2
81. /* LinkList p = queue->front;
82. queue->front = p->next;
83. free(p);
84. return queue->front->data;
85. */
86. }
静态队列:
用数组实现。
静态队列通常都必须是循环队列。
循环队列的讲解:
1.静态队列为什么必须是循环队列?
2.循环队列需要几个参数确定
3.循环队列各个参数的含义
4.循环队列的入队为算法
5.循环队列出对的伪算法。
出队列的时候,f一直往上移,不可能向下,所以造成了空间的浪费,。被删的一直用不了。
队列初始化
Font 和rear的值都是零
2)队列非空
Font代表是队列的第一元素,rear代表对列最后一个元素的下一个元素
3队列空
Font 和rear相等,但不一定是零。
计算r的位置,
错误的写法是r=r+1,不是循环的写法
正确的写法是r=(r+1)%数组的长度
出队是f出,
F=(f+1)%数组的长度
判断队列是否为空:
如果front和rear的值相等,改队列就为空。
如何判断对列是否已满:
两种方式:
1.多增加一个标示位
2.少用一个元素。
预备知识
Front 的值比rear大
也可能比rear小
当然也可能相等
If(r+1)%数组长度==f即为满。
非线性结构:
树的定义:
都是用递归搞定。
有且只用一个成为根的节点,有若干互不相交的子树,这些子树本身也是树。
树一定是节点和边组成
2,.每个节点只有一个父节点,但可以有多个子节点,
根节点例外他没有父节点。
树的专业术语:
节点:
父节点:
子孙;
堂兄弟
深度:从根节点到最低层节点的层数,称为深度。
叶子节点:没有子节点的节点,(非终端节点)
度。子节点的个数称为度
树的分类
一般树;
二叉树
森林
一般树:
任意一个节点的子节点的个数不受限制
二叉树:
任意一个节点的子节点的个数最多两个,且子节点的位置不可更改。
一般二叉树;
满二叉树
在不增加树的层次的前提下,无法再多增加
完全二叉树;
如果只是删除了满二叉树最底层最右边的连续若各个节点,这样形成的树就是完全二叉树。
森林:
N 个互不相交的树的集合;
二叉树的存储:
连续存储:
链式存储:
数据本身,左指针域,右指针域。
一般树的存储:
双亲表示法
孩子表示法
双亲孩子表示法
二叉树表示法
双亲表示法:
孩子表示
求父节点方便
示法:
双亲孩子表示法:
求父节点和子节点都方便。
一般树转换成二叉树:
具体转换方法:
设法保证:任意的一个节点的左指针域指向他的第一个孩子,
右指针域指向他的兄弟,只要能满足此条件,就能把一个普通树转化成二叉树。
一课普通的树转化成二叉树没有右子树。
森林要变成二叉树存储:
先把森林转换成二叉树
操作:
二叉树操作:
树的遍历:
先序遍历:
先访问根节点
再先序访问左子树
再先序访问右子树
abcdeflqmns
中序遍历
中序遍历左子树
再访问根节点
再中序遍历右字树
bdcealfnqm
后续遍历:(都是基于根来说的,先序,先访问根,中序,中间访问根,后序,是最后访问根)。
后序遍历:
先中序遍历左字树
在中序遍历右字树
在访问根节点
Bdmfleca
已知两种遍历求原始二叉树:
通过先序和中序或者中序和后序我们
可以还原出原始的二叉树
但是通过先序和后序是无法还原出原始的
二叉树
已知先序和中序求后序:
已知中序和后序求先序:
二叉树:
#include <stdio.h>
#include <malloc.h>
typedef struct ptnode{
char data;
struct ptnode *pleft;
struct ptnode *pright;
}PTNODE,*PPNODE;
PPNODE createBt();
travel(PPNODE);
int main()
{
PPNODEpp=createBt();
travel(pp);
return 0;
}
PPNODE createBt()
{
PPNODEpa=(PPNODE)malloc(sizeof(PTNODE));
PPNODEpb=(PPNODE)malloc(sizeof(PTNODE));
PPNODEpc=(PPNODE)malloc(sizeof(PTNODE));
PPNODEpd=(PPNODE)malloc(sizeof(PTNODE));
PPNODEpe=(PPNODE)malloc(sizeof(PTNODE));
pa->data='a';
pb->data='b';
pc->data='c';
pd->data='d';
pe->data='e';
pa->pleft=pb;
pa->pright=pc;
pb->pleft=pb->pright=NULL;
pc->pleft=pd;
pc->pright=NULL;
pd->pleft=NULL;
pd->pright=pe;
pe->pleft=pe->pright=NULL;
return pa;
}
travel(PPNODE pp)
{
if(pp!=NULL)
{
printf("%c",pp->data);
if(pp->pleft!=NULL)
{
travel(pp->pleft);
}
if(pp->pright!=NULL)
{
travel(pp->pright);
}
}
}
排序:
冒泡:
快速排序
快速排序:
#include <stdio.h>
void sort(int *,int,int);
int findPos(int *,int,int);
int main()
{
inti;
inta[6]={2,1,0,5,4,3};
sort(a,0,5);
for(i=0;i<6;i++)
{
printf("%d",a[i]);
}
return 0;
}
void sort(int *a,int low,int hight)
{
if(low<hight)
{
int pos=findPos(a,low,hight);
// printf("%d",pos);
sort(a,low,pos-1);
sort(a,pos+1,hight);
}
}
int findPos(int * a,int low,int hight)
{
int val=a[low];
while(hight>low)
{
while(a[hight]>val && low<hight)
{
hight-=1;
//--hight;
}
a[low]=a[hight];
while(a[low]<val && low <hight)
{
low+=1;
// ++low;
}
a[hight]=a[low];
}
a[hight]=val;
return low;
}
折半查找;
· · binarySearch(int a[], int n, int key){
· int low = 0;
· int high = n - 1;
· while(low<= high){
· int mid = (low +high)/2;
· int midVal = a[mid];
· if(midVal<key)
· low = mid + 1;
· else if(midVal>key)
· high = mid - 1;
· else
· return mid;
· }
· return -1;
· }
· · int main(){
· int i, val, ret;
· int a[8]={-32, 12, 16, 24,36, 45, 59, 98};
· for(i=0; i<8; i++)
· printf("%d\t", a[i]);
· · printf("\n请输人所要查找的元素:");
· scanf("%d",&val);
· · ret =binarySearch(a,8,val);
· · if(-1 == ret)
· printf("查找失败 \n");
· else
· printf ("查找成功 \n");
· · return 0;