精华内容
下载资源
问答
  • go链表(头指针和尾指针)

    千次阅读 2019-02-14 11:28:53
     再用一个结构体分别指向链表的头和尾两个节点  向链表添加元素时, 动态修改两个指针的指向  主要弄清楚二者的关系就好理解了, 关系如下图: 上面是结构体链表 /*创建链表结构体, 用于表示实际链表上的节点...

    要求: 创建一个空链表, 可以从头部插入任意数据, 也可以从尾部插入, 再遍历出来

    分析: 首先肯定是需要一个链表型的结构体

             再用一个结构体分别指向链表的头和尾两个节点

             向链表添加元素时, 动态修改两个指针的指向

             主要弄清楚二者的关系就好理解了, 关系如下图:

    上面是结构体链表

    /*创建链表结构体, 用于表示实际链表上的节点*/
    type LinkNode struct {
        data interface{}				// 数据为任意类型
        next *LinkNode
    }

    下面只是一个结构体变量, 有两个指针, 始终指向链表的头节点和尾节点

    随着链表节点增加, 分别更改这两个指针就行了 

    /*创建结构体, 用于代表链表的头节点和尾节点*/
    type OneNode struct {
        head *LinkNode			//指向链表头节点
        tail *LinkNode			// 指向链表尾节点
    }

    最后循环链表的时候, 只需要根据OneNode的头指针获取到LinkNode链表的头节点就可以

    /*循环链表*/
    func (p *OneNode) Each() {
        node := p.head			
        for node != nil {
            fmt.Println(node.data)
            node = node.next
        }
    }

    完整代码:

    package main
    import "fmt"
    
    /*创建链表结构体, 用于表示实际链表上的节点*/
    type LinkNode struct {
        data interface{}				// 数据为任意类型
        next *LinkNode
    }
    
    /*创建结构体, 用于代表链表的头节点和尾节点*/
    type OneNode struct {
        head *LinkNode				// 表示链表中的头节点
        tail *LinkNode				// 表示链表中的尾节点
    } 
    
    /*头部插入*/
    func (p *OneNode)AddHead(d interface{}) {	
        /*创建节点*/
        var node = &LinkNode{
            data : d,
        }
    
        /*OneNode, 若为空, 则创建OneNode, 指向头尾节点*/
        if p.head == nil && p.tail == nil {
            p.tail = node
            p.head = node
            return
        }
        node.next = p.head		//连结
        p.head = node
    }
    
    /*尾部插入*/
    func (p *OneNode)AddTail(d interface{}) {	
        /*创建节点*/
        var node = &LinkNode{
            data : d,
        }
    
        /*判断OneNode是否为空*/
        if p.head == nil && p.tail == nil {
            p.tail = node
            p.head = node
    	    return
        }
        p.tail.next = node		//连结
        p.tail = node
    }
    
    /*循环链表*/
    func (p *OneNode) Each() {
        node := p.head			// 遍历从头部开始(实际遍历的是Node)
        for node != nil {
            fmt.Println(node.data)
            node = node.next
        }
    }
    package main
    import "strconv"
    
    func main() {
        var link OneNode
        for i:=0; i<10;i++ {
            link.AddTail("A" + strconv.Itoa(i))
        }
        link.Each()
    }

     

    展开全文
  • 循环列表设立头指针和尾指针

    千次阅读 2016-04-13 12:18:34
    #include using namespace std; typedef struct Lnode{  int data;  struct Lnode *next; }Lnode,*Linklist; int Init(Linklist& L){  L=(Linklist)malloc(sizeof(Lnode));  if(!L)return -1;...

    #include<iostream>
    using namespace std;
    typedef struct Lnode{
     int data;
     struct Lnode *next;
    }Lnode,*Linklist;
    int Init(Linklist& L){
     L=(Linklist)malloc(sizeof(Lnode));
     if(!L)return -1;
     L->next=L;
      L->data=NULL;
     return 0;
    }
    int shuru(int m,Linklist&L){
     Linklist A=L;
     for(int i=0;i<m;i++){
      int j;
      cout<<i+1<<":";
      cin>>j;
      Linklist S;
      S=(Linklist)malloc(sizeof(Lnode));
      S->data=j;
      A->next=S;
      S->next=L;
      A=S;
     }
    return 0;
    }
    int shuchu(Linklist &L){
     Linklist A=L->next;
     while(A->next->data){
     cout<<A->data<<"-->";
     A=A->next;
     }
     cout<<A->data;
     return 0;
    }
    int wei(Linklist L,Linklist &wei){
     Linklist A=L->next;
     while(A->next->data){
      A=A->next;
     }
      wei=A;
     return 0;
    }
    int hebin(Linklist &wei1,Linklist& wei2,Linklist L1,Linklist L2)
    {
    wei1->next=L2->next;
    wei2->next=L1;
    return 0;
    }

    int main(){
     Linklist L;
     int j;
     Init(L);
     cout<<"输入的个数"<<endl;
     cin>>j;
     shuru(j,L);
     shuchu(L);
     Linklist S;
     Init(S);
     cout<<endl;
     cout<<"输入的个数"<<endl;
     cin>>j;
     shuru(j,S);
     shuchu(S);
     cout<<endl;
    Linklist wei1,wei2;
    wei(L,wei1);
    wei(S,wei2);
    hebin(wei1,wei2,L,S);
    shuchu(L);
    cout<<endl;
     return 0;
    }

     

    展开全文
  • 我在思考一个问题,单链表的话一般要建个头指针,这样操作起来方便,单循环链表要一般建个尾指针,这样也可以...至于严蔚敏的数据结构里关于双向链表的建立好像都没有头指针和尾指针,她开始是结点,遍历也是结点。
  • //p2指向字符串地址 if (str == NULL) { printf("空指针错误!"); return ; } while (p1 ) //当p1地址小于p2地址时执行循环 { char c = *p1; *p1 = *p2; //完成指针指向地址的值的交换 ...
    示例代码如下:
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void reverseStr(char *str)
    {
    	int length;			
    	char *p1;
    	char *p2;
    
    	length = strlen(str);		//获取字符串长度
    	p1	   = str;				//p1指向字符串首地址
    	p2     = str + length - 1;	//p2指向字符串尾地址
    	if (str == NULL)		
    	{
    		printf("空指针错误!");
    		return ;
    	}
    	while (p1 < p2)				//当p1地址小于p2地址时执行循环
    	{
    		char c = *p1;			
    		*p1	   = *p2;				//完成指针指向地址的值的交换
    		*p2    = c;
    		p1++;						//交换完毕后p1指针指向下一个字符地址
    		p2--;						//交换完毕后p2指针指向上一个字符地址
    	}
    
    }
    
    int main()
    {
    	char str1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    	char str2[] = "0123456789";
    
    	//调用函数执行
    	reverseStr(str1);						
    	reverseStr(str2);
    	//打印输出结果
    	printf("反转后str1为:%s\n", str1);
    	printf("反转后str2为:%s\n", str2);
    
    	system("pause");
    	return 0;
    }
    程序执行结果:
    反转后str1为:ZYXWVUTSRQPONMLKJIHGFEDCBA
    反转后str2为:9876543210
    请按任意键继续. . .





    展开全文
  • 双循环链表(包含指针与尾指针

    双循环链表(包含头指针与尾指针)

    以及基本功能的实现

    list_ d_link_c.h

    #ifndef _LIST_D_LINK_C_
    #define _LIST_D_LINK_C_
    
    #include<iostream>
    #include<assert.h>
    using namespace std;
    
    #define ElemType int 
    
    typedef struct Node
    {
    	ElemType data;
    	struct Node *prio;
    	struct Node *next;
    }Node,*PNode;
    
    typedef struct List
    {
    	PNode first;
    	PNode last;
    	size_t size;
    }List;
    
    void Initlist(List *list);
    void push_back(List *list,ElemType x);
    void push_front(List *list,ElemType x);
    bool pop_back(List *list);
    bool pop_front(List *list);
    void show_seqlist(List *list);
    bool delete_val(List  *list,ElemType key);
    int length(List *list);
    Node* find(List *list,ElemType key);
    void clear(List *list);
    void destroy(List *list);
    bool next(List *list,ElemType key);
    bool prio(List *list,ElemType key);
    bool resver(List *list);
    bool sort(List *list);//升序
    bool modify(List *list,ElemType key);
    bool insert_val(List *list,ElemType key);
    
    #endif //_LIST_D_LINK_C_

    list_ d_link_c.cpp

    #include"Seqlist_ d_link_c.h"
    
    void Initlist(List *list)
    {
    	Node *s = (Node *)malloc(sizeof(Node));
    	assert(s != NULL);
    	list->first = list->last = s;
    	list->last->next = list->first;
    	list->first->prio = list->last;
    	list->size = 0;
    }
    
    void push_back(List *list,ElemType x)
    {
    	Node *p = (Node *)malloc(sizeof(Node));
    	assert(p != NULL);
    	p->data = x;
    
    	p->next = list->first;
    	list->first->prio = p;
    	list->last->next = p;
    	p->prio = list->last;
    
    	list->last = p;
    	list->size++;
    }
    
    void push_front(List *list,ElemType x)
    {
    	Node *p = (Node *)malloc(sizeof(Node));
    	assert(p != NULL);
    	p->data = x;
    
    	if(list->size == 0)
    	{
    		list->last = p;
    	}
    	p->next = list->first->next;
    	p->prio = list->first;
    	list->first->next = p;
    	list->size++;
    }
    
    bool pop_back(List *list)
    {
    	Node *p = list->last;
    	
    	if(list->size == 0)
    	{
    		cout<<"list is NULL!"<<endl;
    		return false;
    	}
    	if(list->size == 1)
    	{
    		list->last = list->first;
    	}
    	p->prio->next = list->first;
    	list->first->prio = p->prio;
    	free(p);
    	list->last = list->first->prio;
    	list->size--;
    	return true;
    }
    
    bool pop_front(List *list)
    {
    	Node *p = list->first->next;
    	if(list->size ==0)
    	{
    		cout<<"the list is null!"<<endl;
    		return false;
    	}
    	if(list->size == 1)
    	{
    		list->last = list->first;
    		//list->last->next = list->first;
    	}
    	list->first->next = p->next;
    	p->next->prio = list->first;
    	free(p);
    	list->size--;
    	return true;
    }
    
    void show_seqlist(List *list)
    {
    	Node *p = list->first->next;
    	while(p!= list->first)
    	{	
    		cout<<p->data<<"-->";
    		p = p->next;
    	}	
    	cout<<"Nul"<<endl;
    }
    
    int length(List *list)
    {
    	return list->size;
    }
    
    Node* find(List *list,ElemType key)
    {
    	Node *p = list->first->next;
    	while(p != list->first && p->data != key)
    		p = p->next;
    	if(p == list->first)
    		return NULL;
    	return p;
    }
    
    void clear(List *list)
    {
    	Node *p = list->first->next;
    	while(p != list->first)
    	{
    		list->first->next = p->next;
    		free(p);
    		p = list->first->next;
    	}
    	list->last = list->first;
    	list->size = 0;
    }
    
    void destroy(List *list)
    {
    	clear(list);
    	free(list->first);
    	list->first = list->last = NULL;
    }
    
    bool next(List *list,ElemType key)
    {
    	Node *p = find(list,key);
    	if(p == NULL)
    		return false;
    	else if(p == list->last)
    		cout<<key<<"'s next is "<<list->first->next->data<<endl;
    	else
    		cout<<key<<"'s next is "<<p->next->data<<endl;
    	return true;
    }
    
    bool prio(List *list,ElemType key)
    {
    	Node *p = find(list,key);
    	if(p == NULL)
    		return false;
    	else if(p == list->first->next)
    		cout<<key<<"'s prio is "<<list->last->data<<endl;
    	else
    		cout<<key<<"'s prio is "<<p->prio->data<<endl;
    	return true;
    }
    
    bool delete_val(List *list,ElemType key)
    {
    	Node *p = find(list,key);
    	if(p == NULL)
    		return false;
    	
    	p->prio->next = p->next;
    	p->next->prio = p->prio;
    	if(p == list->last)
    		list->last = p->prio;
    	free(p);
    	list->size--;
    	return true;
    }
    
    bool resver(List *list)
    {
    	Node *p = list->first->next;
    	Node *q = p->next;
    
    	p->next = list->first;
    	list->first->prio = p;
    	list->last = p;
    
    	if(list->size <= 1)
    		return false;
    	while(q != list->first)
    	{
    		p = q;
    		q = q->next;
    
    		p->next = list->first->next;
    		p->prio = list->first;
    		list->first->next = p;
    		p->next->prio = p;
    	}
    	return true;
    }
    
    bool sort(List *list)//升序
    {
    	Node *p = list->first->next;
    	Node *q = p->next;
    	
    	p->next = list->first;
    	list->first->prio = p;
    	list->last = p;
    	
    	if(list->size <= 1)
    		return false;
    	list->size = 1;//设定初始长度为1
    	while(q != list->first)
    	{
    		p = q;
    		q = q->next;
    		insert_val(list,p->data);
    		free(p);
    	}
    	return true;
    }
    
    bool modify(List  *list,ElemType key)
    {
    	Node *p = find(list,key);
    	if(p == NULL)
    		return false;
    	cout<<"please input a new item:";  
        cin>>key; 
    	p->data = key;
    	return true;
    }
    
    bool insert_val(List  *list,ElemType key)
    {
    	Node *p = find(list,key);
    	if(p != NULL)
    		return false;
    	Node *q = (Node *)malloc(sizeof(Node));
    	q->data = key;
    	p = list->first;
    	while(p != list->last)  
        {  
            if(p->next->data > key)  
                break;
            else  
                p = p->next;  
        }
    	q->next = p->next;
    	p->next->prio = q;
    	q->prio = p;
    	p->next = q;
    	if(p == list->last)
    		list->last = q;
    	list->size++;
    	return true;
    }

    main.cpp(测试)

    #include"Seqlist_ d_link_c.h"
    void main (void)
    {
    	List mylist;
    	Initlist(&mylist);
    		int select = 1;
    	int item;
    	while(select)
    	{
    		cout<<"***********************************"<<endl;
    		cout<<"* [1] push_back   [2] push_front  *"<<endl;
    		cout<<"* [3] show_seqlist[0] quit_system *"<<endl;
    		cout<<"* [4] pop_back    [5] pop_front   *"<<endl;
    		cout<<"* [6] delete_val  [7] insert_val  *"<<endl;
    		cout<<"* [08] modify     [09]clear       *"<<endl;
    		cout<<"* [10] destroy    [11]sort        *"<<endl;
    		cout<<"* [12] resver     [13]length      *"<<endl;
    		cout<<"* [14] next       [15]prio        *"<<endl;
    		cout<<"***********************************"<<endl;
    		cout<<"请选择:";
    		cin>>select;
    		switch(select)
    		{
    		case 1:
    			cout<<"请输入要插入的数据(-1结束):>";
    			while(cin>>item,item!=-1)
    			{
    				push_back(&mylist,item);
    			}
    			break;
    		case 2:
    			cout<<"请输入要插入的数据(-1结束):>";
    			while(cin>>item,item!=-1)
    			{
    				push_front(&mylist,item);
    			}
    			break;
    		case 3:
    			show_seqlist(&mylist);
    			break;
    		case 4:
    			pop_back(&mylist);
    			break;
    		case 5:
    			pop_front(&mylist);
    			break;
    		case 6:
    			cout<<"please input a value:";
    			cin>>item;
    			delete_val(&mylist,item);
    			break;
    		case 7:
    			cout<<"please input a value:";
    			cin>>item;
    			insert_val(&mylist,item);
    			break;
    		case 8:
    			cout<<"please input a value:";
    			cin>>item;
    			modify(&mylist,item);
    			break;
    		case 9:
    			clear(&mylist);
    			break;
    		case 10:
    			destroy(&mylist);
    			select = 0;
    			break;
    		case 11:
    			sort(&mylist);
    			break;
    		case 12:
    			resver(&mylist);
    			break;
    		case 13:
    			cout<<"length is "<<length(&mylist)<<endl;
    			break;
    		case 14:
    			cout<<"please input a value:";
    			cin>>item;
    			next(&mylist,item);
    			break;
    		case 15:
    			cout<<"please input a value:";
    			cin>>item;
    			prio(&mylist,item);
    			break;
    		default:
    			select = 0;
    			break;
    		}
    	}
    }


    展开全文
  • 指针和头结点意义和区别

    万次阅读 多人点赞 2019-01-08 23:09:14
    2、头指针和头结点 由定义可知头指针指向链表第一个存储位置,当存在头结点时头指针指向头结点,这时如果删除链表中的节点头指针不会改变(头指针不能删除)。 当不存在头结点时,头指针指向首结点,如果这时候...
  • /*和头结点连接*/ list->first->next = s; s->pre = list->first; /*若是第一个节点,尾指针该指向它*/ if(list->size == 0) { list->last = s; } list->size++; return true; } else { ...
  • 转载于:https://www.cnblogs.com/hzy-bwd/p/11541565.html
  • 对单链表实现如下功能: void InitList(List *list); //初始化单链表 bool push_back(List *list,ElemType x); //尾插法 void show_seqlist(List *list); //显示链表内容 bool push_front(List *list,...//插法 b
  • 单链表的头指针节点与节点

    千次阅读 2020-04-29 18:10:26
    单链表的头指针节点与节点 头指针为NULL时,则该单链表为空链表;等于在内存中没有分配节点内存。 链表从头节点开始存储数据。节点同样有数据,但指向下一节点的地址为空。 下面从头到尾打印单链表的值的...
  • #include .../*带有结点,指针真,尾指针的栈基本操作*/ struct Stack {  elemtype data; struct Stack *next; };//*PStack; //PStack ptop; //PStack pbottom; //定义指针,尾指针
  • 尾指针循环队列

    千次阅读 2020-06-29 14:48:27
    本题要求只使用尾指针,在我们之前的 3-19,我们使用了顺序表构建只带头指针和计数器的队列,在3-19中,我们使用头指针和奇数器找到了尾指针,所以能够攻破题目。而此题只允许用一个尾指针,该怎么办呢? 回想...
  • 对循环链表,有时不给出头指针,而给出尾指针可以更方便的找到第一个最后一个结点。 如何查找开始结点终端结点? 开始结点:rear->next->next 终端结点:rear 循环链表的合并: void Combine...
  • 循环队列: 队头指针:指向队首元素的前一个位置 队尾指针:指向队尾元素 循环栈: 队头指针:指向队首元素 队尾指针:指向队尾元素的后一个位置 ...
  • 顺序循环队列常规的设计方法使用队尾指针和指针:队尾指针用于指示当前的队尾位置的下标,队指针用于指示当前队位置的下标。现要求设计一个使用队头指针和计数器的顺序循环队列,其操作包括初始化、入队列、...
  • 带头尾指针的循环链表

    千次阅读 2019-05-25 17:33:53
    循环链表是在单链表基础上将队尾的指针指向表头,循环链表可以在表头表尾操作.而且可以很好的解决插入或删除高于表长的问题(运用取模运算)相较上一篇的单链表(用0元素填充)有更方便的操作方式. 循环链表实现 基本...
  • 不过我们需要改造一下现有的循环链表,我们不用指针,而是用指向终端结点的尾指针来表示循环链表,此时查找开始结点终端结点都很方便了 如图所示,这样,我们把尾指针代替节点作为首发指针,就能可使得...
  • 单链表的必要条件:节点的head,以及尾指针指向null; 1结点 首先,不要被以下三个词组弄混了: 链表头:数据内容为第一个元素的结点。 指针:指向结点元素的指针。 结点:数据内容无效,其指针是...
  • 单循环链表中设置尾指针比设置指针更好的原因

    万次阅读 多人点赞 2016-07-11 21:12:52
    尾指针是指向终端结点的指针,用它...设一带结点的单循环链表,其尾指针为rear,则开始结点终端结点的位置分别是rear->next->nextrear,查找时间都是O(1)。 若用指针来表示该链表,则查找终端结点的时间为O(n)。
  • 在链表中使用结点与尾指针

    万次阅读 多人点赞 2018-01-06 21:21:59
    结点 首先,不要被以下三个词组弄混了: ...头指针:指向结点元素的指针。...结点:数据内容无效,其指针头指针。...一句话描述为:头指针是指向结点的指针结点是指向链表头的结点。
  • C语言链表的头指针节点

    千次阅读 多人点赞 2019-02-17 16:09:48
    头指针:指向链表的第一个节点(或者说是链表中第一个结点的存储位置叫做头指针),如果链表有结点,则是指向结点的指针 。 在访问链表时,只能顺序访问,我们要先找到链表的头指针,因为它是指向第一个节点的...
  • 在该算法中,专门定义了链表的尾指针,注意链表在定义,遍历,等操作上折纸指针的链表的区别。 #include #include using namespace std; #define MAX 100 typedef struct LNode{ int data; struct LNod
  •  书上的解释如下:第一个参数pHead是一个指向指针指针,当向一个空链表插入一个节点时,新插入的节点是链表的头指针,此时会改动头指针,因此必须把pHead参数设置为指向指针指针。  总的来说这样做的目的是...
  • 假设以带头结点的循环链表表示一个队列,并且只设一个队尾指针指向元素结点(注意不设头指针),试写出相应的置空队、入队、出队的算法。(Java描述)
  • 头指针结点的区别

    千次阅读 2014-10-09 11:50:40
    头指针头指针是指链表
  • 我看人民邮电出版社的数据结构(c语言版)第2版,课本例题里链队的指针front是指向队元素,尾指针是指向队尾元素的下一位,但在后面的习题里的循坏链表队列的指针front是指向队元素的下一位,而尾指针是指向...
  • 指示方法不同元素入队和出队操作也不同,但是在做大部分题目的时候,我们并不需要分析队头指针和队尾指针具体操作,我们只要记住下面两个结论就行 结论 结论一:当队列执行元素入队操作时,队尾指针(rear)向后移,...
  • 单链表也是一种线性表,所以总得有个头有个。链表中第一个结点的存储位置叫做头指针,那么整个...“链表中第一个结点的存储位置叫做头指针”,如果链表有结点,那么头指针就是指向结点数据域的指针。画一个图吧。
  • 单链表头节点,头指针

    万次阅读 多人点赞 2018-06-12 21:17:55
    ...链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。 这里有个地方要注意,就是对头指针...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 160,464
精华内容 64,185
关键字:

头指针和尾指针