4-17-堆、栈、队列、多线程

学习4-17期视频笔记

1、操作系统32位与64位区别

       int num = 1;//过程：从代码区的符号表里面读取，在寄存器里面产生，然后赋值给num
       int *p = #
       printf("%d", sizeof(p));//32位环境下为4，64位环境下为8

//指针由编译器决定，高位兼容低位。也与操作系统有关

//区别主要在于堆的拓展能力

//32位指针（4字节）

//0xFFFFFFFF    0x00000000    2^32=(2^4)^8

//64位指针（8个字节）

//0xFFFFFFFFFFFFFFFF

 

32位

内存地址4字节

寄存器地址8个16进制数

单个进程最大可被分配2Gb内存

 

 

64位

内存地址8字节

寄存器地址16个16进制数

单个进程最大可被分配1024Gb内存

 

       while (1)
       {
              malloc(1024 * 1024 * 1024);
//32位 进程最大可被分配2Gb内存
//64位 进程最大可被分配1024Gb内存
              Sleep(1000);
       }

 

2、栈与堆

autoint num; //栈   自动回收自动分配

1）栈 是由编译器维护，默认为1M，可以手动拓展栈的大小（配置属性->链接器->系统->堆栈保留大小）

2）每个线程都有自己独立的栈

 

void stack(intnuma){
       int numb = 10;
       printf("%p,%p", &numa,&numb);
       //断点
       numa = 1;
       numb = 2;
       //断点
       printf("\n");
}//当函数运行完成可以发现内存中的地址被回收（变红）

 

void*p=malloc(1024);//堆    手动分配，手动释放

1）32位堆的限制最大位2G，64位堆的最大限制位1024G

2）多线程，共享堆。而堆的大小是固定点。

 

3、数据结构堆栈

栈

（1）先进后出，后进先出

（2）顺序输出：一进一出；逆序输出：全部进入，依次出来

 

堆（二叉树）

父节点的值大于（或小于）子节点的值（大顶堆，小顶堆）

 

4、栈

#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
 
#define N 100
struct stack
{
       int data[N];
       int top;//栈顶
};
typedef structstack Stack;//Stack别名
 
void init(Stack*p)//初始化
{
       p -> top = -1;
       memset(p -> data, 0, sizeof(int)*N);
}
intisempty(Stack *p)//判定栈是否为空
{
       if (p->top == -1)
       {
              return 1;//1为空
       }
       else {
              return 0;
       }
}
int isfull(Stack*p)//判定栈溢出
{
       if (p->top == N - 1)
       {
              return 1;//溢出
       }
       else
       {
              return 0;//未满
       }
}
int gettop(Stack*p)//获取栈顶
{
       return p->data[p->top];
}
void push(Stack*p, int key)//插入数据
{
       if (isfull(p) == 1)
       {
              return;
       }
       else
       {
              p->top += 1;
              p->data[p->top] = key;//压入数据
       }
}
void pop(Stack*p)//吐出
{
       if(isempty(p)==1)
       {
              return;
       }
       else
       {
              p->top -= 1;//出栈
       }
}
void show(Stack*p)
{
       if (isempty(p) == 1)
       {
              return;
       }
       else
       {
              printf("\n栈的数据是\n");
              for (int i = 0; i <= p->top;i++)
              {
                     printf("%4d",p->data);
              }
       }
}
 
void main()
{
       int a[10] = { 1,2,3,4,5,6,7,8,9,0 };
       Stack mystack;
       init(&mystack);//初始化
       for (int i = 0; i < 10; i++)
       {
              push(&mystack, a[i]);
       }
       while (!isempty(&mystack))
       {
              printf("%d",gettop(&mystack));
              pop(&mystack);
       }
       system("pause");
}

 

5、交集与并集

交集

 

       int a[M] = {1,2,3,4,5,6,7,8,9,0,11,12,13,14,15,16,17,18,19,20 };
       int b[N] = {11,12,13,14,15,16,17,18,19,20,21,22,23,24,25 };
       int c[M] = {0};
       int ci = 0;
       for (int i = 0; i < N; i++)
       {
              int flag = 0;
              for (int j = 0; j < M; j++)
              {
                     if (b[i] == a[j])
                     {
                            flag = 1;
                            break;
                     }
              }
              if (flag != 0)
              {
                     c[ci] = b[i];
                     ci++;
              }
       }

并集

       int a[M] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
       int b[N] = {11,12,13,14,15,16,17,18,19,20,21,22,23,24,25 };
       int c[M+N] = {0};
       int ci = N;
       for (int i = 0; i < N; i++)
       {
              c[i] = b[i];
       }
       for (int i = 0; i < M; i++)
       {
              int flag = 0;
              for (int j = 0; j < N; j++)
              {
                     if (a[i] == b[j])
                     {
                            flag = 1;
                            break;
                     }
              }
              if (!flag)
              {
                     c[ci] = a[i];
                     ci++;
              }
       }

 

6、统计数据出现的次数

#include<stdio.h>
#include<stdlib.h>
#define N 20
int a[N] = {1,2,3,1,2,9,9,10,11,12,1,2,1,2,2,2,1,10,11,98 };
 
struct passwd
{
       int num;
       int ci;
};
struct passwdpass[N] = {0};
 
void main()
{
       for (int i = 0; i < N - 1; i++)
       {
              for (int j = 0; j < N - 1 - i;j++)
              {
                     if (a[j] > a[j + 1])
                     {
                            int temp = a[j];
                            a[j] = a[j + 1];
                            a[j + 1] = temp;
                     }
              }
       }//冒泡排序
       for (int i = 0; i < N; i++)
       {
              printf("%4d", a[i]);//排序后输出
       }
       printf("\n");
 
       int u = 0;
       for (int i = 0; i < N - 1; i++)
       {
              pass[u].num = a[i];
              int ci = 1;
              for (int j = i; j < N - 1 - i;j++)
              {
                     if (a[j] == a[j + 1])
                     {
                            ci++;//统计次数
                     }
                     else
                     {
                            i = j;//找第二个数
                            break;
                     }
              }
              pass[u].ci = ci;
              u++;
       }
       for (int i = 0; i < N; i++)
       {
              printf("%4d  %4d %4d\n", a[i],pass[i].num, pass[i].ci);
      
       system("pause");
}
 

7、台阶问题

//1，2，4，7
#include<stdio.h>
#include<stdlib.h>
#define N 10
 
int get(int n)//递归
{
       if (n == 1)
       {
              return 1;
       }
       else if (n == 2)
       {
              return 2;
       }
       else if (n == 3)
       {
              return 4;
       }
       else
       {
              return get(n - 1) + get(n - 2) +get(n - 3);
       }
}
void main(int n)
{
       int a[N] = { 1,2,4 };
       for (int i = 3; i < N; i++)//使用数组解决
       {
              a[i] = a[i - 1] + a[i - 2] + a[i -3];
       }
       printf("数组：%d",a[9]);//274
       //int f1 = 1;
       //int f2 = 2;
       //int f3 = 4;
       //int f4 = 0;
       //for (int i = 3; i < 10; i++)
       //{
       //     f4= f3 + f2 + f1;
       //     f1= f2;
       //     f2= f3;
       //     f3= f4;
       //}
       //printf("%d", f4);
 
       printf("递归：%d",get(10));//274
       system("pause");
}

使用栈模拟台阶

#include<stdio.h>
#include<stdlib.h>
#include"stack.h""
//#define N 10
 
void main()
{
       struct stack mystack;
       init(&mystack);
 
       int f1 = 1;
       int f2 = 2;
       int f3 = 4;
       int last = 0;
       for (int i = 3; i < 10; i++)
       {
              int f4 = 0;
              push(&mystack, f1);
              push(&mystack, f2);
              push(&mystack, f3);
              while (!isempty(&mystack))
              {
                     //f4 +=mystack.data[mystack.top];
                     f4 += gettop(&mystack);
                     pop(&mystack);
              }
 
              f1 = f2;
              f2 = f3;
              f3 = f4;
              last = f4;
       }
       printf("%d", last);
       system("pause");
}

 

8、队列

#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
 
#define N 100
struct queue
{
       int data[N];
       int head;
       int back;
};
 
typedef struct queueQueue;
 
void init(Queue*p)//初始化
{
       p->head = p->back = 0;//为空
       memset(p->data, 0, sizeof(int)*N);//数据清零
}
intisempty(Queue *p)//判断是否位空
{
       if (p->head == p->back)
       {
              return  1;
       }
       else
       {
              return 0;
       }
}
int isfull(Queue*p)//判断是否满
{
       if (p->back == N - 1)
       {
              return 1;
       }
       else
       {
              return 0;
       }
}
voidenqueue(Queue *p, int key)//进队
{
       if (isfull(p) == 1)
       {
              return;
       }
       else {
              if (isempty(p) == 1)
              {
                     p->data[0] = key;
                     p->back++;
              }
              else
              {
                     for (int i = p->back; i>0 ; i--)
                     {
                            p->data[i ] =p->data[i-1];
                     }
                     p->data[0] = key;
                     p->back++;
              }
       }
      
 
}
intgetlast(Queue *p)//获取弹出的数据
{
       return p->data[p->back - 1];
}
voiddequeue(Queue *p)//出队
{
       if (isempty(p))
       {
              return;
       }
       else {
              p->back--;
       }
}
void show(Queue*p)//显示
{
       printf("队列状态：");
       for (int i = 0; i < p->back; i++)
       {
              printf("%4d",p->data[i]);
       }
       printf("\n");
}
void main()
{
       struct queue myq;
       init(&myq);
       for (int i = 99; i < 108; i++)
       {
              enqueue(&myq, i);
              show(&myq);
       }
       while (!isempty(&myq))
       {
              printf("出队数据：%d",getlast(&myq));
              dequeue(&myq);
              show(&myq);
       }
       system("pause");
}
 

9、多线程

#include<stdio.h>
#include<stdlib.h>
#include<process.h>
void run(void*p)
{
       int *px = p;
       printf("线程编号：%d\n",*px);
 
}
void main()
{
       int a[10] = { 1,2,3,4,5,6,7,8,9,0 };
       for (int i = 0; i < 10; i++)
       {
        
         HANDLE hd=_beginthread(run, 0,&a[i]);  //异步执行（乱序输出）
              WaitForSingleObject(hd, INFINITE);//加上此句后，同步执行（顺序输出）
       }
       system("pause");
}
 
使用队列显示编号
struct queuemyq;
void run(void*p)
{
       int *px = p;
       printf("线程编号：%d\n",*px);
       enqueue(&myq, *px);
}
 
void main()
{
       init(&myq);
       int a[10] = { 1,2,3,4,5,6,7,8,9,0 };
       for (int i = 0; i < 10; i++)
       {
              HANDLE hd=_beginthread(run, 0,&a[i]);
       }
      
       system("pause");//此处不能注释，避免队列与多线程冲突
       show(&myq);
       system("pause");
}