精华内容
下载资源
问答
  • 2018-07-10 22:47:09
    #include<iostream>
    using namespace std;
    
    struct Node
    {
    	int data;
    	Node *next;
    };
    
    typedef Node* LinkList;
    
    void init(LinkList *L);
    bool insert(LinkList *L, int location, int data);
    void show(LinkList L);
    bool Delete(LinkList *L, int location);
    
    int main()
    {
    	LinkList List;
    	init(&List);
    	for (int i = 1; i <= 10; i++)
    	{
    		insert(&List, i, i);
    	}
    	 show(List);
    	 cout << List->data << endl;
    
    	system("pause");
    	return 0;
    }
    
    //初始化的时候,应该制造一个节点
    void init(LinkList *L)
    {
    	LinkList s = (LinkList)malloc(sizeof(Node));
    	s->data = -1;
    	*L = s;
    	s->next = *L;
    }
    
    bool insert(LinkList *L, int location, int data)
    {
    	//位置问题
    	if (location < 1)
    	{
    		cout << "erro" << endl;
    		return false;
    	}
    
    	LinkList p = *L;
    	int j = 1;
    	p = p->next;//指向头指针
    
    
    	//注意与非循环链表的判断区别
    	while (p->next!= (*L)->next&&j < location)
    	{
    		p = p->next;
    		j++;
    	}
    
    	//位置大于实际长度
    	//循环链表的时候,当p所指的链表为空,是可以插入的。
    	//但是非循环链表,当p所指的地址为空,不可以插入。
    	if (j!=location)
    	{
    		cout << "erro" << endl;
    		return false;
    	}
    
    	LinkList temp = p->next;
    	LinkList s = (LinkList)malloc(sizeof(Node));
    	s->data = data;
    	p->next = s;
    	s->next = temp;
    	if (p == *L)
    	{
    		*L = s;
    	}
    }
    
    void show(LinkList L)
    {
    	LinkList p = L->next->next;
    	cout << "display: ";
    	while (p != L->next)
    	{
    		cout << p->data << " ";
    		p = p->next;
    	}
    	cout << endl;
    }
    
    bool Delete(LinkList *L, int location)
    {
    	LinkList p = (*L)->next;//指向头指针
    	if (p->next == *L|| location<1)
    	{
    		cout << "erro" << endl;
    		return false;
    	}
    
    	int j = 1;
    	while (p->next != (*L)->next&&j < location)
    	{
    		j++;
    		p = p->next;
    	}
    
    	if (p->next == (*L)->next)
    	{
    		cout << "erro" << endl;
    		return false;
    	}
    
    	LinkList temp = p->next;
    	p->next = temp->next;
    	if (temp == *L)
    	{
    		*L = p;
    	}
    	free(temp);
    	return true;
    
    }
    //链表1的尾节点插在链表2的第一个节点前。链表2的尾节点指向链表1的头节点。将链表2的尾节点作为新链表的尾节点。释放链表2的头节点。
    //特别注意的是,链表2不能为空,否则会出错:因为我们要删除链表2的头节点。
    //链表1可为空,但是这样做相当于把链表2的地址更改为链表1的地址。
    bool emerge(LinkList *L1, LinkList *L2, LinkList *L3)
    {
    	LinkList List2 = *L2;//尾节点
    	LinkList List1 = *L1;//尾节点
    	LinkList List1_head = List1->next;//备份链表1的头节点
    	if (isEmpty(List2) == true)
    	{
    		cout << "erro" << endl;
    		return false;
    	}
    
    	LinkList temp = List2->next;//链表2的头结点
    	List1->next = temp->next;//链表1的尾节点的next指针指向链表2的首节点
    	List2->next = List1_head;//链表2的尾节点的next指针指向链表1的头节点
    	*L3 = List2;//新链表的尾节点为链表2的尾节点
    	free(temp);
    	return true;
    }


    更多相关内容
  • 单向循环链表

    2021-01-20 03:32:26
    循环链表结点指针是指向链表的头结点。从我画的循环链表图中,你应该可以看出来,它像一个环一样首尾相连,所以叫作“循环”链表。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历...
  • 遇到一个问题就是双向循环链表的实现,改指向的时候总是发蒙。 我自己尝实现了一个python的双向循环链表。附上代码,希望对大家有帮助。 如果不懂什么是双向循环链表的伙伴,需要补习一下数据结构的基础之后哦~~~ 在...
  • 如果把单链表的最后一个节点的指针指向链表头部,而不是指向NULL,那么就构成了一个单向循环链表,通俗讲就是把尾节点的下一跳指向头结点。 单向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表: 双向...

    一、单向循环链表

    • 单向循环链表:
      如果把单链表的最后一个节点的指针指向链表头部,而不是指向NULL,那么就构成了一个单向循环链表,通俗讲就是把尾节点的下一跳指向头结点。

    单向循环链表 –多个节点

    在这里插入图片描述

    单向循环链表 – 只有1个节点

    在这里插入图片描述
    对于和我们之前学的单向链表相比,单向循环链表的区别在于其尾节点指向链表的首节点,我们在单链表(Linked List)的clear、add、remove、indexOf以及toString方法的底层封装的博客上面可以改动的也无非就是添加和删除的操作。

    (一)单向循环链表 — add(int index, E element)

    @Override
    public void add(int index, E element) {
    	rangeCheckForAdd(index);
    	
    	if (index == 0) {
    		//先不要修改first,因为要是修改了;再找最后一个节点的时候会发生变化
    		Node<E> newFirst = new Node<>(element, first);
    		// 拿到最后一个节点
    		Node<E> last = (size == 0) ? newFirst : node(size - 1);
    		last.next = newFirst;
    		first = newFirst;
    	} else {
    		Node<E> prev = node(index - 1);
    		prev.next = new Node<>(element, prev.next);
    	}
    	size++;
    }
    

    (二)单向循环链表 — remove(int index)

    @Override
    public E remove(int index) {
    	rangeCheck(index);
    	
    	Node<E> node = first;
    	if (index == 0) {
    		if (size == 1) {
    			first = null;
    		} else {
    			//先拿到最后一个节点
    			Node<E> last = node(size - 1);
    			//再改变first节点
    			first = first.next;
    			last.next = first;
    		}
    	} else {
    		Node<E> prev = node(index - 1);
    		node = prev.next;
    		prev.next = node.next;
    	}
    	size--;
    	return node.element;
    }
    

    (三)单向循环链表 — node中的toString方法

    private static class Node<E> {
    	E element;
    	Node<E> next;
    	public Node(E element, Node<E> next) {
    		this.element = element;
    		this.next = next;
    	}
    	
    	@Override
    	public String toString() {
    		StringBuilder sb = new StringBuilder();
    		sb.append(element).append("_").append(next.element);
    		return sb.toString();
    	}
    }
    

    (四)测试

    import com.mj.circle.SingleCircleLinkedList;
    public class Main {
    	static void testList(List<Integer> list) {
    		list.add(11);
    		list.add(22);
    		list.add(33);
    		list.add(44);
    
    		list.add(0, 55); // [55, 11, 22, 33, 44]
    		list.add(2, 66); // [55, 11, 66, 22, 33, 44]
    		list.add(list.size(), 77); // [55, 11, 66, 22, 33, 44, 77]
    
    		list.remove(0); // [11, 66, 22, 33, 44, 77]
    		list.remove(2); // [11, 66, 33, 44, 77]
    		list.remove(list.size() - 1); // [11, 66, 33, 44]		
    		System.out.println(list);
    	}
    	public static void main(String[] args) {
    		 testList(new SingleCircleLinkedList<>());	
    	}
    }
    运行结果:
    size=4, [11_66, 66_33, 33_44, 44_11]
    

    二、双向循环链表

    双向循环链表 –多个节点

    在这里插入图片描述

    双向循环链表 – 只有1个节点

    在这里插入图片描述

    • 双向循环链表:双(向)链表中有两条方向不同的链,即每个结点中除next域存放后继结点地址外,还增加一个指向其直接前趋的指针域prior。

    (一)单向循环链表 — add(int index, E element)

    @Override
    public void add(int index, E element) {
    	rangeCheckForAdd(index);
    
    	// size == 0
    	// index == 0
    	if (index == size) { // 往最后面添加元素
    		Node<E> oldLast = last;
    		last = new Node<>(oldLast, element, first);
    		if (oldLast == null) { // 这是链表添加的第一个元素
    			first = last;
    			first.next = first;
    			first.prev = first;
    		} else {
    			oldLast.next = last;
    			first.prev = last;
    		}
    	} else {
    		Node<E> next = node(index); 
    		Node<E> prev = next.prev; 
    		Node<E> node = new Node<>(prev, element, next);
    		next.prev = node;
    		prev.next = node;
    		
    		if (next == first) { // index == 0
    			first = node;
    		}
    	}
    	
    	size++;
    }
    

    (二)单向循环链表 — remove(int index)

    @Override
    public E remove(int index) {
    	rangeCheck(index);
    	return remove(node(index));
    }
    
    private E remove(Node<E> node) {
    	if (size == 1) {
    		first = null;
    		last = null;
    	} else {
    		Node<E> prev = node.prev;
    		Node<E> next = node.next;
    		prev.next = next;
    		next.prev = prev;
    		
    		if (node == first) { // index == 0
    			first = next;
    		}
    		
    		if (node == last) { // index == size - 1
    			last = prev;
    		}
    	}
    	
    	size--;
    	return node.element;
    }
    

    (三)单向循环链表 — node中的toString方法

    private static class Node<E> {
    E element;
    	Node<E> prev;
    	Node<E> next;
    	public Node(Node<E> prev, E element, Node<E> next) {
    		this.prev = prev;
    		this.element = element;
    		this.next = next;
    	}
    	
    	@Override
    	public String toString() {
    		StringBuilder sb = new StringBuilder();
    		
    		if (prev != null) {
    			sb.append(prev.element);
    		} else {
    			sb.append("null");
    		}
    		
    		sb.append("_").append(element).append("_");
    
    		if (next != null) {
    			sb.append(next.element);
    		} else {
    			sb.append("null");
    		}
    		
    		return sb.toString();
    	}
    }
    

    (四)测试

    import com.mj.circle.CircleLinkedList;
    public class Main {
    	static void testList(List<Integer> list) {
    		list.add(11);
    		list.add(22);
    		list.add(33);
    		list.add(44);
    
    		list.add(0, 55); // [55, 11, 22, 33, 44]
    		list.add(2, 66); // [55, 11, 66, 22, 33, 44]
    		list.add(list.size(), 77); // [55, 11, 66, 22, 33, 44, 77]
    
    		list.remove(0); // [11, 66, 22, 33, 44, 77]
    		list.remove(2); // [11, 66, 33, 44, 77]
    		list.remove(list.size() - 1); // [11, 66, 33, 44]
    		
    		System.out.println(list);
    	}
    
    	public static void main(String[] args) {
    		 testList(new CircleLinkedList<>());
    	}
    }
    运行结果:
    size=4, [44_11_66, 11_66_33, 66_33_44, 33_44_11]
    
    展开全文
  • 结点指针的单循环链表结构 //带结点的单循环链表 //可以不要头指针 typedef int elementType; typedef struct LinkedList{ elementType data; struct LinkedList* next; }node; 带结点指针的单循环链表...

    带尾结点指针的单循环链表结构

    //带尾结点的单循环链表
    //可以不要头指针
    
    typedef int elementType;
    typedef struct LinkedList{
    	elementType data;
    	struct LinkedList* next;
    }node;
    

    带尾结点指针的单循环链表初始化

    //R是尾结点 
    void initialList(node *&R){
    	R = new node;//申请头结点 
    	R->next = R; 
    } 
    
    

    求表长度

    //求表长度
    int listLength(node* R){
    	int len = 0;
    	node* p = R->next->next;//指向表中的第一个元素 
    	
    	//当p指针没有指向头结点时继续循环 
    	while (p != R->next){
    		len++;
    		p = p->next;
    	}
    	
    	return len;
    } 
    

    插入操作

    //插入操作 
    int listInsert(node *R, int i, elementType x){
    	node* p, *S;
    	int k = 0;
    	//指向头结点 
    	p = R->next;
    	
    	//找到要插入位置的前一个结点 
    	while (k != i-1 && p->next != R->next){
    		k++;
    		p = p->next;
    	} 
    	
    	//i超出范围 
    	if (k != i-1){
    		return false;
    	}
    	else{
    		S = new node;
    		S->data = x;
    		S->next = p->next;
    		p->next = S;
    		//如果插入的位置在尾结点之后,则修改尾结点的指向 
    		if (R->next == S)
    			R = S;
    			
    		return true;
    	}
    }
    

    删除操作

    //删除操作 
    bool listDelete(node *&R, int i, elementType &x){
    	node* p = R->next;
    	node* u;
    	int k = 0;
    	//找到要删除结点的前一个结点 
    	while (k != i-1 && p->next != R->next){
    		k++;
    		p = p->next;
    	}
    	//如果p指向尾结点,则i超出范围 
    	if (p->next == R->next)
    		return false; //i超出范围
    	else{
    		u = p->next;
    		p = u->next;
    		x = u->data;
    		
    		//如果删除的是尾结点,则修改尾结点指针的指向 
    		if (R == u)
    			u = p;
    			
    		delete u;
    		
    		return true;
    	} 
    }
    

    将A、B两个带尾指针的单循环链表首 尾相接,尽量节省时间

    void scrMergeAB(node *&A, node *&B){
    	node* u;
    	
    	u = A->next;//保留A的头结点的位置 
    	A->next = B->next->next;//将A的尾结点指针指向B的第一个结点 
    	delete B->next;//删除B的头结点 
    	B->next = u;//将B的尾结点的next指针指向A的头结点 
    	
    	A = B;//A和B指针都指向新链表的尾结点 
    } 
    
    展开全文
  • 循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中,查找ai的后继Next(L,a;),耗时仅为O(1),因为...

    单向循环链表

    循环链表和单链表的区别

    1. 表中最后结点的指针不是NULL,而是改为指向头结点,从而整个链表形成了一个环。

    2. 循环单链表中没有指针域为NULL的结点,故判空条件为判断 *A (表尾节点) *A 的next是否为头指针

    3. 空表:if(A->next == H) { 空表 }

    在这里插入图片描述

    循环链表的特点

    • 循环单链表插入,删除算法于单链表几乎一样

    正是因为循环单链表是一个“环”在任何位置插入和删除操作都是等价的,无须判断是否是表全。循环链表可以从任意一个结点开始遍历整个链表循环链表不设头指针而仅设尾指针,若只设置尾指针A,A->next即为头指针,对表头,表尾进行操作都只要O(n).

    • 关于两个循环链表合并为一个循环链表
      在这里插入图片描述

    双向循环链表——概念

    在单链表L中,查找ai的后继Next(L,a;),耗时仅为O(1),因为取ai后继指针即可。
    但查找ai的直接前驱Prior(L,ai);则需从链表的头指针开始,找到结点ai前一结点即是。故运算Prior(L,ai)依赖表长n,耗时为O(n)。另外,若链表中有一指针值被破坏,则整个链表脱节。这是单链表的不足

    为此,引入双向链表。先定义双向链表中的结点:
    在这里插入图片描述
    其中,datanext同单链表,增加一指针域prior其指向本结点的直接前驱
    结点描述:

    typedef int data_t; 
    typedef struct dnode_t
    { 
            data_tdata;
            struct dnode_t *prior;
            struct dnode_t *next;
    }dlinknode_t , *dlinklist_t;
    
    • 表L=(a0·····an-1)(设n=2) 的双向循环链表如图:
      -
      设p为链表中某结点的指针,有对称性:
      (p->prior)->next = p =(p->next)->prior
    
    • 双向链表的查找等运算基本上和单链表类似。
    • 在双向循环链表中,某结点 *p 为尾结点时,p->next == H,当循环双链表尾空表时,某头结点的prior域next域都等于H

    下面我们学习一下双向循环链表的插入和删除运算

    1. 双向循环链表——插入

    插入: 即实现在链表L的第i结点前插入一结点x的运算,如图
    在这里插入图片描述

    ① q->prior = p->prior;(p->prior)->next = q;
    ③ q->next = p;
    ④ p->prior=q;
    
    • 算法思路:
      调用查找算法Getlist(L,i);,获取结点ai的指针p。若存在,申请一q结点,存入元素x,然后修改指针,将q结点插入p结点之前
      此算法时间复杂度主要算在查找算法getlist(L,i);上,故T(n)=O(n);

    2. 双向循环链表——删除

    删除: 即实现删除链表L第i结点 的运算,如图
    在这里插入图片描述

    • 算法思路:
      调用查找算法Getlist(L,i);,获取结点ai的指针p,若p存在,则修改指针删除

    概念我们了解了,接下来我们要去实现双向链表的操作。

    双向链表的插入创建

    文件一:dlist.h 插入创建双向链表

    #ifndef __DLIST_H__
    #define __DLIST_H__
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    
       int data;
       struct node *prior;
       struct node *next;
    
    }dlistnode;
    
    
    extern dlistnode *dlist_create();
    extern void dlist_show(dlistnode *H);
    #endif
    

    在这里插入图片描述
    文件二:dlist.c 插入创建双向链表

    #include"dlist.h"
    
    //创建双向链表
    dlistnode *dlist_create(){
       dlistnode *H,*p,*r;
       int num;
    
       if(( H =(dlistnode *)malloc(sizeof(dlistnode))) == NULL){
    	puts("malloc failed");
    	return NULL;
       }
       //建立空双向链表
       H->prior = H;   //头结点前驱后继都指向自己
       H->next = H;    
       r = H;          //指针r 指向头结点
       //用户输入
       while(1) {
           puts("please input(-1 exit):");
           scanf("%d",&num);
           if(num == -1){
    	       puts("-1 exit");
    	       break;
           }
    
           if((p = (dlistnode *)malloc(sizeof(dlistnode))) == NULL){
    	puts("malloc failed");
    	return NULL;
           }
           //新节点赋值
           p->data = num;
           
           //插入双向链表
           p->prior = r;
           p->next = r->next;
           r->next = p;
           H->prior = p;
           r = p;
    
       } 
       return H;
    }
    
    //遍历链表并输出链表数据
    void dlist_show(dlistnode *H){
    
       dlistnode *p;
       p = H->next;
    
       while(p != H){
           printf("%d ",p->data);
           p=p->next;
       }
       puts("");
    }
    
    

    文件三:test.c 插入创建双向链表

    #include"dlist.h"
    
    
    int main(){
    
       dlistnode *H;
    
       H=dlist_create();
    
       dlist_show(H);
    
       return 0;
    }
    
    

    在这里插入图片描述

    双向链表——查找

    查找:getlist(L,i);提供要查找结点ai的编号,返回指向该结点ai的指针
    在这里插入图片描述
    结点个数 n=3; i的范围【0,n-1】

    文件一:dlist.h 插入创建双向链表

    #ifndef __DLIST_H__
    #define __DLIST_H__
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    
       int data;
       struct node *prior;
       struct node *next;
    
    }dlistnode;
    
    extern dlistnode *dlist_create();
    extern void dlist_show(dlistnode *H);
    extern dlistnode *dlist_get(dlistnode *H,int pos)#endif
    

    文件二:dlist.c 按位查找双向链表

    dlistnode *dlist_get(dlistnode *H,int pos){
        int i =-1;
        dlistnode *p = H;
    
        if(pos < 0){
            puts("pos < 0,invalid");
            return NULL;
        }
        
        while(i < pos){
    	   p = p->next;
    	   i++;
    	   if(p == H){
    	       puts("pos is invalid");
    	       return NULL;
    	   }
        }
        return p;
    }
    

    文件三:test.c 用户输入按位查找双向链表

    #include"dlist.h"
    
    
    int main(){
    
       dlistnode *H,*p;
       int pos;
    
       H=dlist_create();
    
       dlist_show(H);
       
       //用户输入按位查找
       while(1){
          puts("input pos");
          scanf("%d",&pos);
          p =  dlist_get(H,pos);
          if(p){
             printf("%d \n",p->data);
          }
       }
       return 0;
    }
    

    在这里插入图片描述

    双向链表——插入

    插入: 即实现在链表L的第i结点前插入一结点x的运算,如图
    在这里插入图片描述

    • 算法思路:
      调用查找算法Getlist(L,i);,获取结点ai的指针p。若存在,申请一q结点,存入元素x,然后修改指针,将q结点插入p结点之前
      此算法时间复杂度主要算在查找算法getlist(L,i);上,故T(n)=O(n);

    文件一:dlist.h 插入创建双向链表

    #ifndef __DLIST_H__
    #define __DLIST_H__
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    
       int data;
       struct node *prior;
       struct node *next;
    
    }dlistnode;
    
    extern dlistnode *dlist_create();
    extern void dlist_show(dlistnode *H);
    extern dlistnode *dlist_get(dlistnode *H,int pos);
    extern int dlist_insert(dlistnode *H , int value ,int pos);
    #endif
    

    文件二:dlist.c 按位插入双向链表

    int dlist_insert(dlistnode *H , int value ,int pos){
    	dlistnode *p,*q;
    
    	p = dlist_get(H,pos);
    	if(p == NULL){
                return -1;
    	}
            
            if((q = (dlistnode *)malloc(sizeof(dlistnode))) == NULL){
    	   puts("malloc failed");
    	   return -1;
            } 
    	q->data = value;
    
    	q->prior = p->prior;
    	q->next = p;
    	p->prior->next = q;
    	q->prior = q;
    
    	return 0;
    }
    

    文件三:test.c 用户输入按位插入双向链表

    #include"dlist.h"
    
    
    int main(){
    
       dlistnode *H;
       int pos;
    
       H=dlist_create();
    
       dlist_show(H);
       
       //用户输入按位查找
         while(1){
          puts("input pos");
          scanf("%d",&pos);
          
          dlist_insert(H,100,pos);
          dlist_show(H);
          }
       return 0;
    }
    

    在这里插入图片描述

    双向链表——删除

    删除: 即实现删除链表L第i结点 的运算,如图
    在这里插入图片描述

     p->prior->next = p->next;
     p->next->prior = p-prior;
    
    • 算法思路:
      调用查找算法Getlist(L,i);,获取结点ai的指针p,若p存在,则修改指针删除
      文件一:dlist.h 插入创建双向链表
    #ifndef __DLIST_H__
    #define __DLIST_H__
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    
       int data;
       struct node *prior;
       struct node *next;
    
    }dlistnode;
    
    extern dlistnode *dlist_create();
    extern void dlist_show(dlistnode *H);
    extern dlistnode *dlist_get(dlistnode *H,int pos);
    extern int dlist_insert(dlistnode *H , int value ,int pos);
    extern int dlist_delete(dlistnode *H ,int pos);
    #endif
    

    文件二:dlist.c 用户输入按位删除双向链表

    int dlist_delete(dlistnode *H ,int pos){
        dlistnode *p;
    
        p = dlist_get(H,pos);
        if(p == NULL){
                return -1;
        }
        
        p->prior->next = p->next;
        p->next->prior = p-prior;
    
        free(p);
        p=NULL;
        return 0;
    }
    

    文件三:test.c 用户输入按位删除双向链表

    #include"dlist.h"
    
    int main(){
    
       dlistnode *H;
       int pos;
    
       H=dlist_create();
    
       dlist_show(H);
    
        while(1){
          puts("input pos");
          scanf("%d",&pos);
          
          dlist_delete(H,pos);
          dlist_show(H);
        }
       return 0;
    }
    
    

    在这里插入图片描述

    -----------------------------------------很棒学习完了数据结构的 双向循环链表--------------------------------------------------

    在这里插入图片描述

    --------------------------------------------------------[下期预告:线性表的应用举例]------------------------------------------------------

    展开全文
  • 循环链表尾指针

    千次阅读 2016-10-28 11:10:39
    循环链表-指针
  • 在学习过单链表以及进阶的双链表之后就需要进一步学习循环链表了,顾名思义,这种链表头尾相接,形成一个环(即尾节点的后继指针指向第一个节点),其他的单链表的差别不大,但循环链表从表中任意一个节点出发,都...
  • 假设以带头结点的循环链表表示一个队列,并且只设一个队尾指针指向尾元素结点(注意不设头指针),试写出相应的置空队、入队、出队的算法。(Java描述)
  • 带头节点循环链表

    千次阅读 2018-02-02 20:49:50
    带头节点的循环链表循环链表尾节点指向头节点 头文件clist.h #pragma once //带头节点的循环链表 //循环链表尾节点指向头节点 typedef struct CNode { int data;//数据域 struct CNode *next;//指向下...
  • Java中的循环链表

    2022-01-18 19:42:35
    循环链表中,最后一个节点指向第一个节点,从而完成一整圈节点。换句话说,我们也可以说在这个链表中,最后一个元素不是空的。在这种类型的链表中,任何节点都可以作为起点。这意味着可以遍历整个列表,即使我们从...
  • 对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表,可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法,循环...
  • 数据结构-基本算法-不带头结点的循环链表(学生时代源码,调试可运行)
  • 链表删除节点

    千次阅读 2021-02-22 15:22:20
    你可以假设节点数据结构在头文件double_linked_list_node.h文件中定义,函数第一个参数是一个指向包含链表根指针的节点的指针,第二个参数是个指向欲移除的节点的指针,如果链表并不包含欲移除的指针,函数就返回假...
  • 带头指针的循环链表

    千次阅读 2019-05-25 17:33:53
    循环链表是在单链表基础上将队尾的指针指向表头,循环链表可以在表头和表尾操作.而且可以很好的解决插入或删除高于表长的问题(运用取模运算)相较上一篇的单链表(用0元素填充)有更方便的操作方式. 循环链表实现 基本...
  • 单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 ...
  • 双向循环链表,即每个节点都拥有一前一后两个指针且头尾互链的链表。各种链表的简单区别如下:单向链表:基本链表;单向循环链表:不同于单向链表以 NULL 判断链表的尾部,单向循环链表的尾部链接到表头,因此当迭代...
  • 循环链表和单链表(参考单链表)大致一样,只是结点要指向头结点,本文是使用结点rear来表示,之所以使用指针,是因为如果使用头结点来寻找列表最后一个元素时间复杂度为O(n),如果使用结点来寻找列表最后...
  • 【数据结构算法】②、单向循环链表的创建插入删除实现、单向循环链表的初始化、遍历、插入(首元结点、其他结点情况)、删除元素、查询元素
  • 单、双链表的循环链表(十五)

    千次阅读 2022-04-21 18:59:09
    如果最后一个结点的指针指向节点,形成一个闭环,就可以从任意一个节点出发,访问所有结点,这就是循环链表。 <2>.单链表 单链表的最后一个结点的next指针域为空。 单链表为空判断: L->next = ...
  • 带头节点的双向循环链表(C语言)

    千次阅读 2021-11-29 13:48:51
    带头节点的双向循环链表 代码+详细分析(C语言)
  • 【数据结构】循环链表

    千次阅读 2022-04-01 22:54:19
    文章目录1.概念2.循环链表的头文件与函数声明3.函数实现3.1 购买节点3.2 初始化...循环链表:和单链表唯一的区别:尾节点保留着头节点的地址 循环链表的特点: 1. 尾节点可以找到头节点 2. 头节点不能找到尾节点 3.
  • 而对于双循环链表,只需要最后一个元素的next指向head->next,head->next的prior指向最后一个节点即可。 插入操作 新节点s插入链表,s->next给p结点,s->prior给p->prior,然后,p->prior->next指向s,p->prior再...
  • 数据结构 循环链表及其基本操作

    千次阅读 2022-03-19 12:37:37
    数据结构 循环链表及一系列操作
  • 内存中一片连续空间(不妨假设地址从1到m),提供给两个栈S1和S2使用,怎样分配这部分存储空间,使得对任一个栈,仅当这部分空间全满时才发生上溢。
  • 在双向链表指定节点后插入节点

    千次阅读 2021-05-25 02:52:35
    要在列表中的指定节点之后插入节点,需要跳过所需数量的节点以便到达目标节点,然后根据需要调整指针。为此,请参考使用以下步骤。为新节点分配内存。 请使用以下语句。ptr = (struct node *)malloc(sizeof(struct ...
  • 带头结点双向循环链表基本操作(c语言版)
  • 若是不清楚链表的结构,该篇文章不适合观看,这里只做文字说明,没有链表结构的图示
  • C语言双向循环链表

    2021-08-07 20:03:39
    这次介绍双向链表,既然叫双向就说明可以往两个方向进行遍历,可以利用中间的一个节点推出下一个节点和上一个节点,所以在定义一个双向链表节点的时候,除了要保存数据和下一个节点的地址,还得保存上一个节点的地址...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,687
精华内容 42,274
关键字:

循环链表的尾节点指向