数据结构
2015-11-25 15:49
579 查看
链表
#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;
<
f6ff
/p>
}
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;
#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;
<
f6ff
/p>
}
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;
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- javascript数据结构之双链表插入排序实例详解
- SQL笔记(2)_第二章 定义数据结构
- 学习数据结构与算法分析如何帮助您成为更优秀的开发人员
- javascript数据结构之二叉搜索树实现方法
- 《大话数据结构》之关键路径算法
- 数据结构关于AOV与AOE网的区别
- 严蔚敏 数据结构习题6.62
- 严蔚敏 数据结构习题 6.52
- 严蔚敏 数据结构习题 6.49
- 严蔚敏 数据结构习题6.47
- 严蔚敏 数据结构习题 6.41
- 数据结构 — 7.有向图的创建及出入度的计算
- 线索二叉树的遍历(数据结构)
- 模式-算法-数据结构
- 《数据结构与算法》学习之入门篇
- 数据结构实验之图论六：村村通公路
- javascript数据结构之二叉搜索树实现方法
- javascript数据结构之双链表插入排序实例详解
- 数据结构实验之链表八：Farey序列
- 数据结构实验之串三：KMP应用