关于15桥梁课程1&2的笔记以及待做事项的梳理

1.指针所占用的空间是固定的

2.void *malloc(sizeof(int)); （这玩意耗时间，老师说通过内存池解决）

　　free(p);free(p);   两次free()报错，正确的做法：

　　if（p!=NULL）{free(p);p=NULL;}

3.传值与传址的理解应转换为是否对其空间进行操作

4.函数指针：

　　作用：ex: 不同厂商设备函数不同，操作系统定义设备抽象 device结构体 实现函数跳转

　　通用形式： 返回类型 （* 函数指针变量）（形参列表）
　　只能指向………………

　　而指针函数 ：返回值为指针类型

　　

 #include<stdio.h>
   void fun1(int *a)
   {
           int i;
           for(i=;i<;i++)
                   printf("%d\n",a[i]);
   }
   void fun2(int *a)
   {
          int i;
          for(i=;i<;i++)
                  printf("%d\n",*a[i]);
  }
  void fun3(int *a,void (*f)(int *))
  {
          f(a);
  }
  int main()
  {
          int a[]={,,,,,,,,,};
  //      fun1(a);
  //      fun2(a);
          fun3(a,fun1);
          fun3(a,fun2);
          return ;
  }

5.数组与指针  (为何*(*(a+2)+1)有效)

int data[3][4]   data的type为int (*)[4]  *data的type为int*  data[1]的type为 int *

data++   data=data+1*sizeof(int)//wrong

int *p;
p=data;
for(;p<data+12;p++)
{
printf("%d",*p);
}

void fun(int a[][5])
b[5]/b[]
void fun(int *a,int m,int n)
{
}//a[i][j]______________*(a+i*sizeof(n)+j)
main()
{
int data[3][3]={};
fun(data);
}

参考链接：http://blog.sina.com.cn/s/blog_6b1695860100q84k.html   http://blog.sina.com.cn/s/blog_5c6f793801019t3t.html

6.单向链表相关（by myself）

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

 typedef struct node
 {
     int data;
     struct node *next;
 }Node;

 Node *Creat_link(Node*,int *,int);
 void Display(Node*);
 Node *FindPre(Node*,int);
 void Deleteone(Node*,int);
 void Deletemore(Node*,int);
 void Freeroom(Node*);
 Node *Reserve(Node*);
 void Addnode(Node*,int);
 Node *Combine(Node*,Node*);
 int main()
 {
     Node *head=NULL;
     Node *head2=NULL;
     Node *head3=NULL;
     int a[]={,,,,,};
     int b[]={,,,};
     head=Creat_link(head,a,);
 //    head2=Creat_link(head2,b,4);
 //    head3=Combine(head,head2);//合并
 //    Display(head3);
 //    Deleteone(head,a[1]);//删除一个
 //    Display(head);
 //    Deletemore(head,a[2]);//可删除重复
 //    Display(head);
 //    Addnode(head,5);//增加一个节点
 //    Display(head);
     Reserve(head);//倒序
     Display(head);
     Freeroom(head);
     return ;
 }

 Node *Creat_link(Node *h,int *a,int n)
 {
     int i;
     h=(Node *)malloc(sizeof(Node));

     if(h==NULL)
     {printf("Not enough memory\n");}

     h->next=NULL;
     Node *s=h;
     Node *p=NULL;
     for (i=n;i>;i--)
     {
         p=(Node *)malloc(sizeof(Node));
         p->next=h->next;
         h->next=p;
         p->data=a[i-];
     }
     return h;
 }

 void Display(Node *h)
 {
     Node *p=NULL;
     p=h;
     while(p->next!=NULL)
     {
     p=p->next;
     printf("%d ",p->data);
     }
     putchar('\n');
 }
 void Freeroom(Node *h)
 {
     Node *p=h->next;
     Node *tem=NULL;
     h->next=NULL;
     while(p!=NULL)
     {
     tem=p->next;
     if(tem!=NULL)
         {
         free(tem);
         tem=NULL;
         }
     p=tem;
     }
 }

 Node *Reserve(Node *h)
 {
     Node *p=NULL;
     Node *pnext=NULL;
     Node *q=NULL;
     if(h==NULL||h->next==NULL)
     return h;
     p=h->next;
     pnext=p->next;
     p->next=NULL;
     while(pnext!=NULL)
     {
         q=pnext->next;
         pnext->next=p;
         p=pnext;
         pnext=q;
     }
     h->next=p;
     return h;
 }
 Node *FindPre(Node *h,int n)
 {
     Node *p=h;
     while(p->next!=NULL&&p->next->data!=n)
     p=p->next;
     return p;
 }
 void Deleteone(Node *h,int n)
 {
     Node *p=FindPre(h,n);
     Node *temp=NULL;
     if(p->next!=NULL)
     {
         temp=p->next;
         p->next=temp->next;
         if(temp!=NULL){
             free(temp);
             temp=NULL;
         }

     }
     else
     {printf("Not find!\n");}
 }    

 void Deletemore(Node *h,int n)
 {
     Node *p=FindPre(h,n);
     Node *q=p->next;
     Node *temp=NULL;
     while(q->next!=NULL&&q->next->data==n)
     {
         temp=q;
         q=q->next;
         if(temp==NULL){
         free(temp);
         temp=NULL;}
     }
     p->next=q->next;
     if(q!=NULL){
         free(q);
         q=NULL;
     }
 }

 void Addnode(Node *h,int data)
 {
     Node *p=h;
     Node *new=(Node *)malloc(sizeof(Node));
     while(p->next!=NULL&&data>p->next->data)
     {p=p->next;}
     if(p->next==NULL)
     {
         p->next=new;
         new->next=NULL;
     }
     else
     {
         new->next=p->next;
         p->next=new;
     }
     new->data=data;
 }

 Node *Combine(Node *h1,Node *h2)
 {
     Node *p=h1;
     Node *q=h2;
     Node *temp1,*temp2,*temp3;
     Node *h3=(h1->next->data<h2->next->data)?h1:h2;
     while(q->next!=NULL&&p->next!=NULL)
     {
         temp2=q->next;
         while(q->next!=NULL&&q->next->data<=p->next->data)
         q=q->next;

         temp1=p->next;
         while(p->next!=NULL&&p->next->data<=q->next->data)
         p=p->next;

         temp1=p->next;
         p->next=temp2;
         temp2=q->next;
         q->next=temp1;
     }
     return h3;
 }

8.双向链表

 #include<stdio.h>
 #include<stdlib.h>
 typedef struct Node
 {
     int data;
     struct Node *front;
     struct Node *rear;
 }BNode;

 void create(BNode **head1,BNode **head2)
 {
     int m;
     scanf("%d",&m);
     BNode *p=NULL,*q=*head2;
     while(m>)
     {
         p=(BNode*)malloc(sizeof(BNode));
         p->data=m;
         p->front=NULL;
         p->rear=NULL;

         if(*head1==NULL)
         {
             *head1=p;
             *head2=p;
         }
         else
         {
             p->rear=*head1;
             p->front=NULL;
             (*head1)->front=p;
             *head1=p;
         }
         scanf("%d",&m);
     }
 }
 void display(BNode **head1)
 {
     BNode *h=*head1;
     while(h!=NULL)
     {
         printf("%d  ",h->data);
         h=h->rear;
     }
 }

 void addnode(BNode **head,int m)//插入m
 {
     BNode *p=*head;
     BNode *q=(BNode*)malloc(sizeof(BNode));
     q->data=m;
     while(p!=NULL&&p->data<m)
     {
 //        printf("%d__",p->data);
         p=p->rear;
     }
     if(p!=NULL)
     {
         q->rear=p;
         q->front=p->front;
         p->front->rear=q;
         p->front=q;
         ;
     }
 }
 int main()
 {
     BNode *head1=NULL,*head2=NULL;
     create(&head1,&head2);
     display(&head1);
     addnode(&head1,);
     printf("\n");
     display(&head1);
     return ;
 }

9. 栈 队列

//链栈
#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
    struct node *next;
    int data;
}Node;

typedef struct stack
{
    Node *top;
}Stack;

void Init(Stack *s)
{
    s->top=NULL;
}

void Push(Stack *s,int m)
{
    Node *p=(Node *)malloc(sizeof(Node));
    p->data=m;
    p->next=s->top;
    s->top=p;
}

int Pop(Stack *s,int *m)
{
    Node *p;
    if(s->top==NULL)
        return ;

    *m=s->top->data;
    p=s->top;
    s->top=p->next;
    free(p);
    return ;
}
int main()
{
    int m=;
    Stack *s;
    Push(s,);
    Push(s,);
    if(Pop(s,&m));
    {
        printf("%d\n",m);
    }
    getch();
    return ;
}

#include<stdio.h>//栈
#include<stdlib.h>

typedef struct node
{
    int top;
    int data[];
}Stack;

void Init(Stack *s)
{
    s->top=-;
}

int Push(Stack *s,int m)
{
    if(s->top>=) return ;
    s->data[++(s->top)]=m;
    return ;
}

int Pop(Stack *s,int *m)
{    

    if(s->top==-) return ;
    *m=s->data[s->top--];
    return ;
}
int main()
{
    int m=;
    Stack *s;
    Init(s);
    Push(s,);
    Push(s,);
    if(Pop(s,&m));
    {
        printf("+++%d+++\n",m);
    }
    if(Pop(s,&m));
    {
        printf("+++%d+++\n",m);
    }
    getch();
    return ;
}

10.通用链表

11.二叉树的遍历（递归与非递归）

 #include<stdio.h>
 #include<stdlib.h>
 typedef struct BTNode
 {
     int data;
     struct BTNode *Lchild;
     struct BTNode *Rchild;
 } BTNode;

 BTNode *CreateTree()//以递归的方式创建
 {
     int data;
     BTNode *T;

     printf("Please input a data.");
     scanf(" %d",&data);
     if(data=='#')
         T=NULL;
     else
         {
                 BTNode *P=(BTNode*)malloc(sizeof(BTNode));
                 P->data=data;
                 P->Rchild=CreateTree();
                 P->Lchild=CreateTree();
         }
     return T;
 }
 void Preorder(BTNode *T)//递归方式的前序遍历
 {
     if(T!=NULL)
     {
         printf("%d  ",T->data);
         Preorder(T->Lchild);
         Preorder(T->Rchild);
     }
 } int main()
 {
     BTNode *T=NULL;
     T=CreateTree();
     Preorder(T);

     return ;
 }

12.make file

　　参考链接：跟我一起写makefile http://blog.csdn.net/liang13664759/article/details/1771246

13.静态库  动态库

　　参考资料：http://blog.chinaunix.net/uid-23069658-id-3142046.html

14.哈希表