本文主要向大家介绍了C/C++知识点之C指针（4）——数据结构中指针的应用（程序讲解），通过具体的内容向大家展示，希望对大家学习C/C++知识点有所帮助。

5-1动态内存分配，分配的是堆内存的空间

分配内存函数 (都集中在库函数 stdlib.h  中)
1
2
3
void *malloc (unsigned int num_bytes); //指定分配内存空间大小，大小为 num_bytes字节，其值是随机值。
void *calloc (unsigned num ,unsigned size);  //参数包含元素的数量和每个元素的字节数，内存空间为num*sie
void *realloc(void *ptr,size_t size);  //调用该函数对内存空间进行重新分配，ptr指向已有的内存空间，size用来指定重新分配后所得整个空间大小
　   在使用动态分配之前，首先要判断是否分配成功。

内存的释放函数原型:
1
void free(void *ptr);   //动态分配的内存使用结束后，要及时释放，
　　内存释放后建议把指针指向NULL

5-2队列（初始化，入队，出队，判断空，判断满）

单向队列
循环队列  （队头和队尾有两种情况会指向同一位置，一是队列空了，二是队列满了）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#define QueueSize_UartLen 8
typedef struct
{
  int front;   //队头
  int rear;    //队尾
  int counter;   //记录队列元素的个数
  int uart_data[QueneSize_UartLen];  //定义数组用来存储队列的元素
}CIRQUEUE_UART;    //定义结构体，用typedef把结构体重新命名为CIRQUEUE_UART
 
void InitQueue(CIRQUEUE_UART *queue) //初始化形参，CIRQUEUE_UART类型的指针变量queue，队列的初始化
{
  queue->front=0;   //->与指向结构体变量的指针相连，表示指向结构体变量指针的成员（左边为指针，注意与 . 的区别）
  queue->rear=0;
  queue->counter=0;
}
 
int Inqueue(CIRQUEUE_UART *queue,int data)  //入队
{
  if(QueueFull(queue))   //队满判断
   {
      return 0;         //输出队满提示
   }
   else
   {
      queue->uart_data[queue->rear]=data;    //queue->rear指向队尾待插入数据位置
      queue->counter++;                      //计数器加1
      queue->rear=(queue->rear+1)%QueueSize_UartLen;  //然后指queue->rear向下一个待插入数据的位置
      return 1;
   }
}
 
int OutQueue(CIRQUEUE_UART *queue,int *p_data)    //出队  通过指针p_data取出队的数据
{
  if(QueueEmpty(queue))
    {
     return 0;
     }
   else
     {
      *p_data=queue->data(front);         //先把出队的数据元素取出放在p_data
      queue->counter--;                   //计数器减1
      queue->front=(queue->front+1)%QueueSize_UartLen;   //然后指queue->front向下一个位置
      return 1;
      }
}
 
int QueueEmpty(CIRQUEUE_UART *queue)  //判断队空
{
  return queue->count==0;
}
 
int QueueFull(CIRQUEUE_UART *queue)   //判断队满
{
  return queue->counter==QueueSize_UartLen;
}
链式队列 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
typedef struct LinkNode_t
{
  int data;
  struct LinkNode_t *next;
}LinkNode;
typedef struct LinkPoint_t
{
  struct LinkNode_t *front;
  struct LinkNode_t *rear;
}LinkQueue;
LinkQueue *queue;
LinkNode *node;
 
LinkQueue LinkQueueInit()   //初始化
{
  queue_t=(LinkQueue)malloc(sizeof(LinkQueue));
  node=(LinkQueue)malloc(sizeof(LinkNode));
  node->front=queue->rear->next;
  queue_t->front=queue->rear->node;
  return queue_t;
}
 
void InlinkQueue(LinkQueue *queue,int data)  //进队
{
  node=(LinkNode)malloc(sizeof(LinkNode));
  node->data=data;
  node->next=queue->rear->next;
  queue->rear->next=node;
  queue->rear=node;
}
 
void OutQueue(LinkQueue *queue)  //出队
{
  int data;
  if(!LQEmpty(queue))
  {
    node=queue->front->next;
    queue->front->next=node->next;
    data=node->data;
    if(node==queue->rear)
      {
         queue->rear=queue->front;
      }
     free(node);
     return data;
  }
}
 
int LQEmpty(LinkQueue *queue)   //对空判断
{
   if(queue->front==queue->rear)
    {
      return 1;
    }
    else
    {
      return 0;
    }
}
　　

5-3堆栈（初始化，进栈，出栈，栈空的判断，栈满的判断，取栈顶元素）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
1.采用指向栈顶、栈底两个指针时：
typedef struct
{
  int top;
  int data[10];
  int bottom;
}stack_rf;
stack_rf *p_rf_data;  //
 
p_rf_data->top-p_rf_data->bottom==10; //判断栈是否为满
p_rf_data->top-p_rf_data->bottom==0;  //判断栈是否为空
 
*(p_rf_data->top-1)  //栈顶元素
*(p_rf_data->bottom) //栈底元素
 
2.只采用栈顶一个指针时：
#define Len_Uart 10;
typedef struct
{
  int top;
  int uart_data[Len_Uart];
}stack_uart;
 
void InitStack(stack_uart *stack)
{
  stack->top=0;      //栈的初始化
}
 
int PushStack(stack_uart *stack,int data) //进栈
{
  if(StackFull(stack))
  {
    //输出栈满提示
    return(0);
  }
  else
  {
    stack->uart_data[stack->top]=data;
    stack->top++;
    return(1);
  }
}
 
int PopStack(stack_uart *stack)  //出栈
{
  int data;
  if(StackEmpty(stack))
  {
    return 0;  //输出栈空提示
  }
  else
  {
    stack->top--;
    data=stack->data[stack->top];
    return data;
  }
}
 
int StackEmpty(stack_uart *stack)  //栈空判断
{
  return(stack->top==0);
}
 
int StackFull(stack_uart *stack)   //栈满判断
{
  return(stack->top==Len_Uart);
}
 
int StackTop(stack_uart *stack,int *p_topdata)  //取栈顶元素
{
  if(StackEmpty())
  {
    //输出栈空提示
    return 0;
  }
  else
  {
   *p_topdata=stack->uart_data[stack->top-1];
   return 1;
   }
}
　　

5-4链表（链表建立，链表初始化，链表插入，链表删除）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
typedef struct LinkNode
{
  int data;
  struct LinkNode *next;
}*List;
 
List InitList(void)   //链表初始化
{
  List linknode_t;
  linknode_t=(list)malloc(sozeof(list));
  if(!linknode_t)
   {
     //输出失败提示
    return 0;
   }
   else
   {
     linknode_t->next=linknode_t;
     return linknode_t;
   }
}
 
List g_DebiList;
int main(void)   //在main中调用InitList()函数
{
  g_DevList=InitList();
  return 0;
}
 
链表的操作
typedef struct DEVICE_PROPERTY_t
{
  int data;
  struct DEVICE_PROPERTY_t *next;
}DEVICE_PROPERTY_t;
typedef unsigned char uint8_t;
#define DEVICELIST_MAX 5;
DEVICE_PROPERTY_t g_RegDeviceList[DEVICELIST_MAX];
DEVICE_PROPERTY_t *g_LastRegDevice;
uint8_t g_DeviceCnt=0;
 
voide DevListInit(void)      //链表初始化
{
  uint8_t i;
  for(i=0;i<DEVICELIST_MAX;i++)
  {
   g_RegDeviceList[i].next=NULL;
  }
   g_lastRegDevice=NULL;
   g_DeviceCnt=0
}
 
DEVICE_PROPERTY_t *FindVacancy(void)  //寻找插入点
{
  uint8_t i;
  if(g_DeviceCnt<DEVICELIST_MAX)
  {
    for(i=0;i<EEVICELIST_MAX;i++)
    {
       if(g_RegDeviceList[i].next==NULL)
         {
           return(&g_RegDeviceList[i]);
         }
     }
    return 0;
  }
   else
   {
    return(NULL);
   }
}
 
uint8_t Insert(uint8_t data)     //链表插入
{
  DEVICE_PROPERTY_t *tempptr,*ptr;
  temptr =FindVacancy();
  if(tempptr!=null)
   {
     tempptr->data=data;
       if(!g_DeviceCnt)
        {
          tempptr->next=tmpptr;
          g_ListRegDevice=tempptr;
        }
        else
        {
           ptr=g_LastRegDevice->next;
           g_LastRegDevice->next=tempptr;
           tempptr->next=ptr;
         }
         g_DeviceCnt++;
         return 1;
   }
   return 0;
}
 
uint8_t DeleteDevicefromlist(uint8_t data)  //链表删除
{
  uint8_t i,j;
  DEVICE_PROPERTY_t *nextdevice;
  for(i=0;i<g_DeviceCnt;i++)
  {
    if(g_LastRegDevice->data==data)
      {
        nextdevce=g_ListRegDevice->next;
        g_LastRegDevice->next=NULL;
        g_DeviceCnt--;
        g_LastRegDevice=nextdevice;
        if(g_DeviceCnt)
         {
           for(j=0;j<g_DeviceCnt-1;j++)
             {
                g_ListRegDevice->next=nextdevice;
              }
              g_ListRegDevice->next=nextdevice;
          }
         return 1;
      }
     g_LastRegDevice=g_LastRegDevice->next;
   }
  return 0;
}    

本文由职坐标整理并发布，了解更多内容，请关注职坐标编程语言C/C+频道！