精华内容
下载资源
问答
  • 尾指针及其简单应用

    千次阅读 2018-08-14 09:25:39
    尾指针及其简单应用 循环链表如果拿到最后结点,若没有尾指针(rear),那么需要O(n)的时间。如果有的话,只需要O(1)的时间。 如果有两个链表,需要将他们连接,拥有尾指针只需要O(1)的时间复杂度。 此时,判断循环...

    尾指针及其简单应用

    循环链表如果拿到最后结点,若没有尾指针(rear),那么需要O(n)的时间。如果有的话,只需要O(1)的时间。

    如果有两个链表,需要将他们连接,拥有尾指针只需要O(1)的时间复杂度。

    此时,判断循环链表是否为空的方法:rear是否等于rear->next。

    一道题目:将两个线性表A(a1,a2,a3...)和B(b1,b2,b3...)连接成一个线性表。

    思路:A的rear不再指向A的head,而是指向B的head->next;然后需要将B的head释放(一个链表只能有一个头结点);最后,将B的rear重新指向A的head。


    简单实现:

    Node * Connect(Node *a_rear,Node *b_rear){ //参数是两个尾指针 
        Node *p = a_rear->next;//p指向A的head
        
        a_rear->next = b_rear->next->next; //a->rear指向B的head->next 
        
        free(b_rear->next);
        
        b_rear->next = p;
        return b_rear; //返回新链表的尾指针 
    }
    展开全文
  • 单循环链表中设置尾指针比设置头指针更好的原因

    万次阅读 多人点赞 2016-07-11 21:12:52
    尾指针是指向终端结点的指针,用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便。 设一带头结点的单循环链表,其尾指针为rear,则开始结点和终端结点的位置分别是rear->next->next和rear,查找...

    尾指针是指向终端结点的指针,用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便。

    设一带头结点的单循环链表,其尾指针为rear,则开始结点和终端结点的位置分别是rear->next->next和rear,查找时间都是O(1)。 若用头指针来表示该链表,则查找终端结点的时间为O(n)。

    展开全文
  • /*如果释放的是最后一个节点,尾指针需要改变指向,其余情况无需改变*/ if(s == list->last) { list->last = s->pre; } return true; } else { cout!"; return false; } } /*bool Delete_val...

    对循环双链表实现下述功能:


    void meau();                           //菜单函数
    void Initlist(List *list);             //初始化
    void show(List *list);                 //打印链表内容
    bool Push_back(List *list,ElemType x); //尾插法
    bool Push_front(List *list,ElemType x);//头插法
    bool Isempty(List *list);              //判断链表是否为空
    bool Pop_back(List *list);             //尾删法
    bool Pop_front(List *list);            //头删法
    Node *Find_val(List *list,ElemType x); //按值查找
    bool Delete_val(List *list,ElemType x);//按值删除
    bool modify(List *list,ElemType x);    //修改
    void clear(List *list);                //清空链表
    void destory(List *list);              //摧毁链表
    void reverse(List *list);              //逆置链表
    Node *prio(List *list,ElemType x);     //求某个值的前驱
    Node *next(List *list,ElemType x);     //求某个值的后继
    bool Insert_val(List *list,ElemType x);//按值插入
    void sort(List *list);                 //排序(升序)


    DCList.h:

    #ifndef __DCLIST_H__
    #define __DCLIST_H__
    
    #include<assert.h>
    #include<iostream>
    using namespace std;
    
    typedef int ElemType;
    
    typedef struct Node
    {
    	struct Node *pre;
    	struct Node *next;
    	ElemType data;
    }Node;
    
    typedef struct List
    {
    	Node *first;
    	Node *last;
    	int size;
    }List;
    
    void meau();                           //菜单函数
    void Initlist(List *list);             //初始化
    void show(List *list);                 //打印链表内容
    bool Push_back(List *list,ElemType x); //尾插法
    bool Push_front(List *list,ElemType x);//头插法
    bool Isempty(List *list);              //判断链表是否为空
    bool Pop_back(List *list);             //尾删法
    bool Pop_front(List *list);            //头删法
    Node *Find_val(List *list,ElemType x); //按值查找
    bool Delete_val(List *list,ElemType x);//按值删除
    bool modify(List *list,ElemType x);    //修改
    void clear(List *list);                //清空链表
    void destory(List *list);              //摧毁链表
    void reverse(List *list);              //逆置链表
    Node *prio(List *list,ElemType x);     //求某个值的前驱
    Node *next(List *list,ElemType x);     //求某个值的后继
    bool Insert_val(List *list,ElemType x);//按值插入
    void sort(List *list);                 //排序(升序)
    #endif
    
    DCList.cpp:

    #include"DCList.h"
    /*菜单函数*/
    void meau()
    {
    	cout<<"*****************SeqList********************"<<endl;
    	cout<<"                                ---zyh_helen"<<endl;
    	cout<<"*[1]InitSeqList              [2]Push_back  *"<<endl;
    	cout<<"*[3]Push_front               [4]Pop_back   *"<<endl;
    	cout<<"*[5]Pop_front                [6]Find_val   *"<<endl;
    	cout<<"*[7]show                     [0]Quit_syatem*"<<endl;
    	cout<<"*[8]modify                   [9]Delete_val *"<<endl; 
    	cout<<"*[10]clear                   [11]destory   *"<<endl; 
    	cout<<"*[12]reverse                 [13]prio      *"<<endl;
    	cout<<"*[14]next                    [15]sort      *"<<endl;
    	cout<<"*[16]Insert_val                            *"<<endl;
    }
    /*初始化链表*/
    void Initlist(List *list)
    {
    	Node *s = (Node *)malloc(sizeof(Node));
    	assert(s != NULL);
    	s->next = s->pre = s;
    	list->first = list->last = s;
    	list->size = 0;
    }
    /*尾插法*/
    bool Push_back(List *list,ElemType x)
    {
    	Node *s = (Node *)malloc(sizeof(Node));
    	if(s != NULL)
    	{
    		s->data = x;
    		list->last->next = s;
    		s->pre = list->last;
    
    		list->last = s;
    		list->last->next = list->first;
    		list->first->pre = list->last;
    		//s->next = list->first;
    		//list->last = s;
    		list->size++;
    		return true;
    	}
    	else
    		return false;
    }
    /*打印链表内容*/
    void show(List *list)
    {
    	Node *s = list->first->next;
    	while(s != list->first)
    	{
    		cout<<s->data<<"-->";
    		s = s->next;
    	}
    	cout<<"NULL"<<endl;
    }
    /*头插法*/
    bool Push_front(List *list,ElemType x)
    {
    	Node *s = (Node *)malloc(sizeof(Node));
    	if(s != NULL)
    	{
    		s->data = x;
    		/*和后面元素(原来的第一个元素)连接*/
    		s->next = list->first->next;
    		list->first->next->pre = s;
    		/*和头结点连接*/
    		list->first->next = s;
    		s->pre = list->first;
    		/*若是第一个节点,尾指针该指向它*/
    		if(list->size == 0)
    		{
    			list->last = s;
    		}
    		list->size++;
    		return true;
    	}
    	else
    	{
    		cout<<"申请空间失败!"<<endl;
    		return false;
    	}
    }
    /*判断链表是否为空*/
    bool Isempty(List *list)
    {
    	return (list->size == 0);
    }
    /*尾删法*/
    bool Pop_back(List *list)
    {
    	if(Isempty(list))
    	{
    		cout<<"链表已空!"<<endl;
    		return false;
    	}
    	Node *s = list->last->pre;//找到最后一个节点的前驱
    	free(list->last);//释放最后一个节点
    	/*连接*/
    	s->next = list->first;
    	list->last = s;
    	list->size--;
    	return true;
    }
    bool Pop_front(List *list)
    {
    	if(Isempty(list))
    	{
    		cout<<"链表已空!"<<endl;
    		return false;
    	}
    	Node *s = list->first->next;//找到第一个节点(要释放的)
    	/*连接*/
    	list->first->next = s->next;
    	s->next->pre = list->first;
    	/*如果要删除的结点是第一个节点,尾指针要改变指向*/
    	if(list->size == 1)
    	{
    		list->last = list->first;
    	}
    	free(s);
    	list->size--;
    	return true;
    }
    /*查找函数:找到指定元素:返回指向它的指针,找不到:返回NULL*/
    Node *Find_val(List *list,ElemType x)
    {
    	Node *s = list->first->next;
    	while(s != list->first)
    	{
    		if(x == s->data)
    			return s;
    		else
    			s = s->next;
    	}
    	return NULL;
    }
    /*按值删除结点*/
    bool Delete_val(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	if(s != NULL)
    	{
    		/*连接:头删,尾删,都适用*/
    		s->pre->next = s->next;
    		s->next->pre = s->pre;
    		/*释放*/
    		free(s);
    		list->size--;
    		/*如果释放的是最后一个节点,尾指针需要改变指向,其余情况无需改变*/
    		if(s == list->last)
    		{
    			list->last = s->pre;
    		}
    		return true;
    	}
    	else
    	{
    		cout<<"the item is not exist!"<<endl;
    		return false;
    	}
    }
    /*bool Delete_val(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	if(s != NULL)
    	{
    		if(s == list->first->next)
    		{
    			Pop_front(list);
    		}
    		else if(s == list->last)//为什么没加else,删除头结点会出错???
    		{
    			Pop_back(list);
    		}
    		else
    		{
    			s->pre->next = s->next;
    			s->next->pre = s->pre;
    			free(s);
    			list->size--;
    		}
    		return true;
    	}
    	else
    	{
    		cout<<"the item is not exist!"<<endl;
    		return false;
    	}
    }*/
    /*修改链表中指定的值*/
    bool modify(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	ElemType item;
    	if(s != NULL)
    	{
    		cout<<"please input a new item:";
    		cin>>item;
    		s->data = item;
    		return true;
    	}
    	else
    	{
    		cout<<"the item is not exist!"<<endl;
    		return false;
    	}
    }
    /*清空链表*/
    void clear(List *list)
    {
    	Node *s = list->first->next;//s总是指向链表中的第一个节点
    	while(s != list->first)
    	{
    		list->first->next = s->next;//将链表中的第一个结点空出来
    		free(s);//释放第一个节点
    		s = list->first->next;//重新指向新的第一个节点
    	}
    	list->last = list->first;
    	list->size = 0;
    }
    /*销毁链表*/
    void destory(List *list)
    {
    	clear(list);
    	free(list->first);
    	list->first = list->last = NULL;
    }
    /*链表逆置:保留第一个结点,将剩余的结点游离出来,然后依次头插到保留的结点中*/
    void reverse(List *list)
    {
    	Node *s = list->first->next;//第一个结点
    	Node *p = s->next;//分离出剩余的结点
    	/*第一个结点逆置后成为最后一个结点*/
    	s->next = list->first;
    	list->last = s;
    	while(p != list->first)
    	{
    		s = p;      //保存游离出来的第一个节点
    		p = p->next;//为下一次头插做准备
    		/*将游离出的第一个节点--->头插-->进去*/
    
    		s->next = list->first->next;
    		list->first->next->pre = s;
    		
    		s->pre = list->first;
    		list->first->next = s;
    		/*
    		Push_front(list,s->data);
    		free(s);调用Push_front函数,会自动创建结点,所以得释放原来的结点
    		*/
    	}
    	
    }
    /*求指定元素的前驱*/
    Node *prio(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	if(s != NULL)
    	{
    		if(s == list->first->next)
    		{
    			cout<<"it doesn't have prio!"<<endl;
    		}
    		else
    		{
    			return s->pre;
    		}
    	}
    	else
    	{
    		cout<<"the item is not exist!"<<endl;
    		return NULL;
    	}
    }
    /*求指定元素的后继*/
    Node *next(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	if(s != NULL)
    	{
    		if(s == list->last)
    		{
    			cout<<"it doesn't have next!"<<endl;
    		}
    		else
    		{
    			return s->next;
    		}
    	}
    	else
    	{
    		cout<<"the item is not exist!"<<endl;
    		return NULL;
    	}
    }
    /*按值插入:若插入的值已经存在,返回NULL,否则将值插入(假设链表数据有序:升序)*/
    bool Insert_val(List *list,ElemType x)
    {
    	Node *s = Find_val(list,x);
    	if(s != NULL)
    	{
    		cout<<"the item is already exist!"<<endl;
    		return false;
    	}
    	/*创建要插入的结点*/
    	Node *p = (Node *)malloc(sizeof(Node));
    	p->data = x;
    	/*查找要插入位置的前驱*/
    	s = list->first;	
    	while(s != list->last)
    	{
    		if(s->next->data > x)
    			break;//要插入的位置找到(在s之后插入)
    		else
    			s = s->next;
    	}
    	/*插入*/
    	p->next = s->next;
    	s->next->pre = p;
    
    	p->pre = s;
    	s->next = p;
    	/*若要插入位置的前驱是最后一个结点,即尾插,则尾指针需要改变指向*/
    	if(s == list->last)
    	{
    		list->last = p;
    	}
    	list->size++;
    	return true;
    }
    /*升序*/
    void sort(List *list)
    {
    	Node *s = list->first->next;//第一个结点
    	Node *p = s->next;//分离出剩余的结点
    	/*第一个结点逆置后成为最后一个结点*/
    	s->next = list->first;
    	list->last = s;
    
    	while(p != list->first)
    	{
    		s = p;
    		p = p->next;
    		/*将游离出来的第一个节点按值插入到保存结点中*/
    		Insert_val(list,s->data);
    		free(s);//调用Insert_val()会创建结点,所以应该原来的结点释放
    	}
    
    }


    main.cpp:

    #include"DCList.h"
    
    int main()
    {
    	List mylist;
    	Node *s;
    	Initlist(&mylist);
    	ElemType item;
    	int choice = 1;
    	while(choice)
    	{
    		meau();
    		cout<<"input you choice:"<<endl;
    		cin>>choice;
    		switch(choice)
    		{
    		case 1:
    			Initlist(&mylist);
    			break;
    		case 2:
    			cout<<"input the item you want to push_back:-1 as a end"<<endl;
    			while(cin>>item,item != -1)
    			Push_back(&mylist,item);
    			break;
    		case 3:
    			cout<<"input the item you want to push_back:-1 as a end"<<endl;
    			while(cin>>item,item != -1)
    			Push_front(&mylist,item);
    			break;
    		case 4:
    			Pop_back(&mylist);
    			break;
    		case 5:
    			Pop_front(&mylist);
    			break;
    		case 6:
    			cout<<"input the item you want to find:"<<endl;
    			cin>>item;
    			Find_val(&mylist,item);
    			if(Find_val(&mylist,item) != NULL)
    				cout<<"the item is found!"<<endl;
    			else
    				cout<<"the item is not exist:"<<endl;
    			break;
    		case 7:
    			show(&mylist);
    			break;
    		case 8:
    			cout<<"input the item you want to modify:"<<endl;
    			cin>>item;
    			modify(&mylist,item);
    			break;
    		case 9:
    			cout<<"input the item you want to delete:"<<endl;
    			cin>>item;
    			Delete_val(&mylist,item);
    			break;
    		case 10:
    			clear(&mylist);
    			break;
    		case 11:
    			destory(&mylist);
    			break;
    		case 12:
    			reverse(&mylist);
    			break;
    		case 13:
    			cout<<"input the item you want to find it's prio:"<<endl;
    			cin>>item;
    			s = prio(&mylist,item);
    			if(s != NULL)
    				cout<<"it's prio is:"<<s->data<<endl;
    			break;
    		case 14:
    			cout<<"input the item you want to find it's next:"<<endl;
    			cin>>item;
    			s = next(&mylist,item);;
    			if(s != NULL)
    				cout<<"it's next is:"<<s->data<<endl;
    			break;
    		case 15:
    			sort(&mylist);
    			break;
    		case 16:
    			cout<<"input the item you want to insert:"<<endl;
    			cin>>item;
    			Insert_val(&mylist,item);
    			break;
    		default:
    			break;
    		}
    	}
    	destory(&mylist);
    	return 0;
    }
    


    具体功能:望读者自行测试,如有错误欢迎提出修改意见微笑----->>>zyh_helen



    展开全文
  • 在链表中使用头结点与尾指针

    万次阅读 多人点赞 2018-01-06 21:21:59
    http://blog.csdn.net/jmy5945hh/article/details/7574857 ...头指针:指向头结点元素的指针。...头结点:数据内容无效,其指针是头指针。...一句话描述为:头指针是指向头结点的指针,头结点是指向链表头的结点。

    http://blog.csdn.net/jmy5945hh/article/details/7574857


    头结点

    首先,不要被以下三个词组弄混了大笑

    链表头:数据内容为第一个元素的结点。

    头指针:指向头结点元素的指针。

    头结点:数据内容无效,其指针是头指针。

    一句话描述为:头指针是指向头结点的指针,头结点是指向链表头的结点。


    对于一个链表来说,头指针是一定存在的,是访问链表的入口,如果没有头指针则无法对其进行访问;链表头对于非空表来说是一定存在的,非空表则不存在。

    注意到,如果说我们不引入头结点的话,将出现操作不统一的问题:

    1、对于元素访问的或者结点的引用不统一。假设pHead是头指针,pNode是指向其他链表结点的指针。此时头指针指向链表头。

    [cpp]  view plain  copy
    1. pHead->Element; //对于链表头的访问  
    2. pNode->next->Element; //对于其他结点的访问  

    2、对于空表与非空表的判定操作不统一。假设pHead是头指针,pNode是指向其他链表结点的指针。此时头指针指向链表头。

    [cpp]  view plain  copy
    1. pHead == NULL; //对于空表的判定  
    2. pNode->next == NULL; //对于非空表是否访问到末尾的判定  

    头结点的引入可以很好地解决这两个问题。首先来看看带头结点的三种链表形式。

    单链表:


    双链表:


    循环双链表(循环单链表类同)


    访问形式统一为:

    [cpp]  view plain  copy
    1. p->next->Element; //统一后的元素访问  
    2. p->next == NULL; //统一后的末尾判定  

    个人来讲,倾向于在链表中引入头结点。虽然多出了一块儿存储空间,但是相对于大链表来说,这个空间是微不足道的。好处是使所有的操作保持一致性代码的编写也更为简单。


    引申:在队列的数据结构中, 一种实现方法是队列的头指针(或者标号)为对头的前一个位置。这种方式也可以看作为头结点的一种扩展方式。


    2 尾指针

    另外一种链表的技巧是使用尾指针。

    尾指针是相对于头指针而言的,形式与头指针相同,内容只想链表的最后一个节点。

    通常,链表的插入语删除操作都是在链表头或者链表尾进行。如果只保存一个头指针的话,要在链表尾操作时必须先遍历整个表,增加了时间复杂度,如果能再保存一个尾指针,则可以立即找到链表尾,时间复杂度降为O(1)。生气

    在单向循环链表中,时常值保存一个尾指针,因为尾指针的下一个节点即是头结点。这样便可以方便地在首尾进行操作。


    最后,提供一个带头结点和尾指针的单链表插入实现参考代码。

    [cpp]  view plain  copy
    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3.   
    4. #define ElementType int  
    5.   
    6. struct ListNode  
    7. {  
    8.     ElementType Element;  
    9.     struct ListNode *Next;  
    10. };  
    11.   
    12. typedef struct  
    13. {  
    14.     struct ListNode *Head;  
    15.     struct ListNode *Tail;  
    16. } List, *pList;  
    17.   
    18. int InsertTail( ElementType X, pList L ) //尾部插入元素  
    19. {  
    20.     struct ListNode *newP;  
    21.   
    22.     if ( (newP = malloc(sizeof(struct ListNode))) == NULL )  
    23.     {  
    24.         perror("OUT OF SPACE!");  
    25.         return -1;  
    26.     }  
    27.   
    28.     newP->Element = X;  
    29.     newP->Next = NULL;  
    30.   
    31.     L->Tail->Next = newP;  
    32.     L->Tail = newP;  
    33.   
    34.     if ( L->Head->Next == NULL)  
    35.     {  
    36.         L->Head->Next = L->Tail;  
    37.     }  
    38.   
    39.     return 0;  
    40. }  
    41.   
    42. int InsertHead( ElementType X, pList L ) //头部插入元素  
    43. {  
    44.     struct ListNode *newP;  
    45.   
    46.     if ( (newP = malloc(sizeof(struct ListNode))) == NULL )  
    47.     {  
    48.         perror("OUT OF SPACE!");  
    49.         return -1;  
    50.     }  
    51.   
    52.     newP->Element = X;  
    53.     newP->Next = L->Head->Next;  
    54.     L->Head->Next = newP;  
    55.   
    56.     return 0;  
    57. }  
    58.   
    59.       
    60. int main()  
    61. {  
    62.     pList L;  
    63.   
    64.     if ( (L = malloc(sizeof(List))) == NULL )  
    65.     {  
    66.         perror("OUT OF SPACE!");  
    67.         return -1;  
    68.     }  
    69.   
    70.     if ( (L->Head = malloc(sizeof(struct ListNode))) == NULL )  
    71.     {  
    72.         perror("OUT OF SPACE!");  
    73.         return -1;  
    74.     }  
    75.   
    76.     L->Head->Next = NULL; //初始化  
    77.     L->Tail = L->Head;  
    78.       
    79.     InsertTail( 10, L );  
    80.     InsertTail( 11, L );  
    81.     InsertTail( 12, L ); //三次尾部插入  
    82.     InsertHead( 13, L );  
    83.     InsertHead( 14, L ); //两次头部插入  
    84.     InsertTail( 15, L );  
    85.     InsertTail( 16, L ); //两次尾部插入  
    86.   
    87.     while( L->Head->Next != NULL ) //遍历输出  
    88.     {  
    89.         printf("%d ", L->Head->Next->Element);  
    90.         L->Head = L->Head->Next;  
    91.     }  
    92.   
    93.     puts("");  
    94.   
    95.     return 0;  
    96. }  


    运行结果:

    [cpp]  view plain  copy
    1. jimmy@MyPet:~/code/learnc$ make  
    2. gcc -Wall -g -o test test.c -std=c99  
    3. jimmy@MyPet:~/code/learnc$ ./test   
    4. 14 13 10 11 12 15 16  
    展开全文
  • //头删法:释放第一个节点->size-1(如果只有一个节点,释放它之后尾指针得指向头结点),其他情况尾指针不变 bool pop_front(List *list) { if(list->size == 0) { cout链表已空"; return false; } Node *p =...
  • @[TOC](6-2 带队尾指针的循环链表表示队列 (25分)) 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针) ,试编写相应的入队和出队算法,实现根据用户输入的入队个数和出队个数...
  • [题目]:有一个单链表,它的元素全部是...head和tail分别是指向该链表第一个元素(即头元素)和最后一个元素(即元素)的全局性指针。请实现调用接口如下所示的两个C语言函数:  int Delete (element *elem);  
  • 指针 与 数组 ( 指针 | 数组 | 指针运算 | 数组访问方式 | 字符串 | 指针数组 | 数组指针 | 多维数组 | 多维指针 | 数组参数 | 函数指针 | 复杂指针解读)
  • 2. 指向一维数组的指针以及指针数组 3. 指向函数的指针 —— 1. 指向变量的指针/指针变量 2. 指向数组的指针/数组指针 3. 指向字符串的指针/字符指针 4. 指向函数的指针/函数指针 5. 指向结构体的指针/结构指针
  • 指针

    2011-05-25 15:15:00
    教学内容 (1)指针指针变量的概念,指针变量的定义、赋值与引用,指针变量的运算。 (2)数组指针与数组指针变量的概念,一维数组元素地址的三种表示方式,一维数组元素值的四种表示方式及应用举例。...
  • 指针

    千次阅读 2011-11-11 17:22:31
    §9.1 指针的概念 指针(pointer):是一个变量的地址。 指针变量:是一个变量,其值是另一个变量的地址。 任何变量都在计算机内存中占有一块内存区域, 变量的值就存放在这块内存区域之中,(寄存器变量不在内存...
  • C++指针

    2016-03-19 22:23:06
    简介定义指针是“指向”另外一种类型的复合类型。与引用类似,指针也实现了对其他对象的间接访问,然而指针与引用相比又有很多不同点: ...指针无需再定义时赋初值,和其他内置类型一样,在块作用域内定
  • C++面试题-指针-指针数组与数组指针

    千次阅读 2019-01-11 00:16:33
    C++面试题-指针-指针数组与数组指针 问:int (*p)[n]与int *p[n]的区别? 答: int (*p)[n]是数组指针,指向某n个元素所组成的整块的数组,返回值是整型指针类型的。 int *p[n]是指针数组,指向数组里面的每个...
  • 添加节点详见上一篇blog: 《c语言 运用函数实现单向链表的创建,添加...再定义一个结构体类型的指针p(其作用为:代替头指针遍历链表) 头删除:如果头指针的位置与要删除节点位置相同(if判断) 将删除标记指向头...
  •  书上的解释如下:第一个参数pHead是一个指向指针指针,当向一个空链表插入一个节点时,新插入的节点是链表的头指针,此时会改动头指针,因此必须把pHead参数设置为指向指针指针。  总的来说这样做的目的是...
  • C指针

    2008-04-07 12:58:00
    1.指针的概念 指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。 要搞清一个指针需要搞清指针的四方面的内容:指针的类型;指针所指向的类型;指针的值或者叫指针所指向的内存区;还有指针本身...
  • 指针详解

    2007-08-04 14:24:00
    转载述:这是一篇比较老的关于指针的文章,... 指针的值二、指针的算术运算 三、运算符&和* 四、指针表达式五、数组和指针的关系六、指针和结构类型的关系 七、指针和函数的关系 八、指针类型转换九、指针的安全问题
  • 链表指针问题

    万次阅读 多人点赞 2018-06-08 17:03:12
    转 昨天周末给学妹讲了一些指针的知识,本来我对指针就是似懂非懂的状态,经过昨天一讲,我对指针的学习就更深刻了果然给别人讲课也是学习的一个方法。加上最近复习数据结构,发现我的博客里没有链表的博文,所以趁...
  • 浅谈C++指针

    2017-03-06 21:12:58
    ps:本人蒟蒻,如有错误请指正Orz 指针是什么 这个需要涉及到某些原理的问题:C++定义类型的时候,实际上是在内存中给你开辟了...指针作用 有了指针,我们就可以知道空间所在的地址,好比你有了朋友的地址,可以
  • 众说周知,在队列的题目中,队头指针(front)和队尾指针(rear)有两种指示方法。 (1)队头指针 ①指向队头元素 ②指向队头元素元素的前一个位置 (2)队尾指针 ①指向队尾元素 ②指向队尾元素的后一个位置 指示方法...
  • while(*s) { /*---省略其他内容---*/ ...char *p[]比起单纯的多维数组,字符没有多余的空间,但是得准备一部分空间来储存指向这部分空间的指针数组。因此占用的字节数也不同。 即:p[0]指向"ABC"的开...
  • 【嵌入式开发】C语言 指针数组 多维数组

    万次阅读 热门讨论 2014-03-19 01:52:05
    ① 模拟C语言中内存分配策略 ;...④ 多维数组 作为参数的时候, 其列数 不能省略 行可以省略, 否则就找不到指针数组中的其它指针了 ; ⑤ 指针数组 和 二维数组 , 指针数组用于存储长度可变的数组, 更节省空间 ;
  • 理解c语言的指针

    2015-01-10 18:18:54
    指针对于初学者往往是很难以琢磨的东西,因为它并不如变量那么抽象,而是更贴近底层的真实结构。指针操作往往会出现各种各样的岔子,我觉得都是由于对指针理解不深,使用不熟练造成的。这篇文章是我一年半来学习...
  • 1、函数指针基础 函数指针指向的是函数而非对象,和其他指针一样,函数指针指向的是某种特定类型。函数的类型由它的返回类型和形参类型共同决定,与函数名无关。例如: //比较两个string对象的长度 bool ...
  • C和指针学习

    万次阅读 热门讨论 2008-06-24 18:15:00
    C和指针学习最后更新时间:2012.12.3原则:尽量短小精悍,实用,需要扩充阅读都是以链接形式出现注意:本文主要是针对Unix环境下的C目 录一.编译与链接二.特殊字符三.数据类型四.修饰符五.运算符六.控制语句七.函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,877
精华内容 16,750
关键字:

尾指针的作用