精华内容
下载资源
问答
  • 创建一个循环双链表,P指向第一个元素值为X的结点,设计一算法从该链表中删除*P结点。
  • 内存中一片连续空间(不妨假设地址从1到m),提供给两栈S1和S2使用,怎样分配这部分存储空间,使得对任一个栈,仅当这部分空间全满时才发生上溢。
  • #include using namespace std; template class LinkNode{ public: T data; LinkNode<T> *pLast;... void delete1(LinkNode<T> *p);... cout 删除后的链表为:" ; li->show(); } return 0; }  
    #include<iostream>
    using namespace std;
    template<class T>
    class LinkNode{
    public:
        T data;
        LinkNode<T> *pLast;
        LinkNode<T> *pNext;
        LinkNode(T data){
            this->data = data;
        }
    };
    
    template<class T>
    class LinkList{
    private:
        LinkNode<T> *pHead;
        LinkNode<T> *pTail;
    public:
        LinkList(){
            this->pHead = NULL;
            this->pTail = NULL;
        }
        void show();
        void inserttail(T data);
        void delete1(LinkNode<T> *p);
        int deletex(T data);
    };
    template<class T>
    void LinkList<T> :: show(){
        LinkNode<T> *p;
        if(this->pHead == NULL)
            cout << "空" << endl;
        else{
            for(p = this->pHead;p!=pTail;p = p->pNext){
            cout << p->data << "   ";
            }
            cout << pTail->data << endl;
        }
    }
    template<class T>
    void LinkList<T> :: inserttail(T data){
            LinkNode<T> *p = new LinkNode<T>(data);
            if(pHead == NULL)
                pHead = pTail = p;
            else{
                pHead->pLast = p;
                p->pNext = pHead;
                pTail->pNext = p;
                p->pLast = pTail;
                pTail = p;
            }
    }
    template<class T>
    void LinkList<T> :: delete1(LinkNode<T> *p){
        if(p == pHead)
            pHead = p->pNext;
        if(p == pTail)
            pTail = p->pLast;
        p->pLast->pNext = p->pNext;
        p->pNext->pLast = p->pLast;
        delete p;
    }
    template<class T>
    int LinkList<T> :: deletex(T data){
        LinkNode<T> *temp;
        if(pHead == NULL){
            cout << "链表为空,无法删除!" << endl;
            return 0;
        }
        else{
            for(temp = pHead;temp != pTail;temp = temp->pNext){
                if(temp->data == data){
                    delete1(temp);
                    cout << "删除成功!" << endl;
                    return 1;
                }
            }
            if(pTail->data == data){
                delete1(pTail);
                return 1;
            }
            cout << "链表内不存在数据为" << data << "的结点!" << endl;
            return 0;
        }
    }
    int main(){
        LinkNode<char> *x = new LinkNode<char>('p');
        LinkList<char> *li = new LinkList<char>;
        char c;
        int res;
        cout << "请输入数据(输入0结束):"<< endl;
        cin >> c;
        while(c != '0'){
            li->inserttail(c);
            cin >> c;
        }
        cout << "构建的链表为:" << endl;
        li->show();
        cout << "请输入要删除的结点的数据:" ;
        cin >> c;
        if(li->deletex(c)){
            cout << "删除后的链表为:" << endl;
            li->show();
        }
    
    return 0;
    }
    

     

    展开全文
  • 1.删除链表中的重复元素,要求是不能够使用缓冲区 由于题目要求了不能够使用额外的空间来进行辅助我们找出重复的元素,即不能够使用额外的数据结构来保存元素,所以我们不能够使用哈希表(HashSet)来辅助我们找出...

    1. 删除链表中的重复元素,要求是不能够使用缓冲区

    由于题目要求了不能够使用额外的空间来进行辅助我们找出重复的元素,即不能够使用额外的数据结构来保存元素,所以我们不能够使用哈希表(HashSet)来辅助我们找出重复的元素了,但是我们可以普遍的做法:使用双重循环来找出重复的元素

    在链表中一般是使用while循环而不使用for循环来遍历元素

    其中要使用到四个指针,第一个指针first指向的是第一层for循环的当前元素,第二个指针second指向的是第二层for循环的当前元素,第三个指针p指向的是第二层for循环的当前元素的前一个元素,因为我们要删除重复的元素,关键是改变前一个前驱指针的指向即可,把前一个指针的next指向下一个元素相当于就把重复的元素删除了,第四个指针pre是第一个指针的副本,用来在第二层for循环中将第一层循环的当前元素与第二层for循环的当前元素的元素值进行比较的,判断是否相同

    第一层for循环结束之后那么我们应该将第一个指针往下移动,改变指针p,second,pre的指向

    我觉得最重要的是弄清楚指针的指向,假如指针不够那么应该加多一个指针直到在循环中方便我们对元素进行操作

    还有就是思路清楚之后需要在写代码的时候把自己想的与对应的代码联系起来,每一句写出来的代码我们都应该做到心里有数,这句代码表示的是什么意思

    2. 画出其中的指针指向图

    3. 因为使用了两层for循环,那么时间复杂度为O(n ^ 2), 具体的代码如下:

    public class Main{
    	//内部的私有类
    	private static class ListNode{
    		ListNode next;
    		Object value;
    		public ListNode(Object value) {
    			super();
    			this.value = value;
    		}
    	}
    	
    	public static void main(String[] args) {
    		int arr[] = {1, 2, 3, 5, 4, 2, 3, 1, 7, 9, 10};
    		//利用数组生成链表
    		ListNode head = new ListNode(null);
    		ListNode p = head;
    		for(int i = 0; i < arr.length; i++){
    			p.next = new ListNode(arr[i]);
    			p = p.next;
    		}
    		removeRepetition(head);
    		ListNode p1 = head.next;
    		while(p1 != null){
    			System.out.print(p1.value + " ");
    			p1 = p1.next;
    		}
    	}
    
    	private static void removeRepetition(ListNode head){
    		//for循环的第一个指针
    		ListNode first = head.next;
    		//for循环的第二个指针
    		ListNode second = null;
    		ListNode p = null;
    		ListNode pre = null;
    		while(first != null){
    			pre = first;
    			second = first.next;
    			p = first;
    			while(second != null){
    				if(pre.value == second.value){
    					p.next = second.next;
    				}else{
    					//注意这句代码不能够写到else外面
    					p = second;
    				}
    				second = second.next;
    			}
    			first = first.next;
    		}
    	}
    }
    

     

    展开全文
  • 循环双链表

    2013-06-09 19:08:45
    循环双链表采用纯C编写,其中包含初始化、增加结点、修改结点和删除结点等
  • 循环链表、双链表、循环双链表循环链表循环链表的创建循环链表的头插循环链表的尾插循环链表的任意位置插入循环链表按位置删除循环链表的逆序循环链表的销毁双链表双链表的创建双链表的头插双链表的尾插双链表按任意...

    循环链表

    • 循环链表最后一个结点node->next重新指向头结点ls->head
    • 在单向链表的基础上将所有NULL的判断改写成是否为头结点

    循环链表的创建

    1. 链表没有结点的时候,头结点指向自身
      ls->head->next = ls->head;
    List *CreateList()
    {
    	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = ls->head;   // 空链表
    	
    	return ls;
    }
    

    循环链表的头插

    BOOL Insert_Head(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = ls->head->next;
    	ls->head->next = node;
    	
    	return TRUE;
    }
    

    循环链表的尾插

    
    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = ls->head;
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next != ls->head)
    	{
    		tmp = tmp->next;
    	}
    	
    	tmp->next = node;
    	
    	return TRUE;
    }
    

    循环链表的任意位置插入

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	
    				
    	return TRUE;
    }
    

    循环链表按位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head || tmp->next == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    	free(p);
    				
    	return TRUE;
    }
    

    循环链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || ls->head == ls->head->next || ls->head == ls->head->next->next)
    		return ERROR;
    	
    	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur != ls->head)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = ls->head;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;				//将头结点的next指向最后一个元素
    	
    	return TRUE;
    }
    

    循环链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next != ls->head)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    

    双链表

    双链表有指针域有两个指针,一个指向下一个结点,一个指向前一个结点

    双链表的创建

    vList *CreateList()
    {
    	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = NULL;   // 空链表
    	ls->head->pre  = NULL;     //包含两个指针
    	
    	return ls;
    }
    

    双链表的头插

    BOOL Insert_Head(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head->next;
    	ls->head->next = node;
    	node->pre = ls->head;
    	if (NULL != node->next)
    	node->next->pre = node;
    	
    	return TRUE;
    }
    

    双链表的尾插

    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next)
    	{
    		tmp = tmp->next;
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = NULL;
    	tmp->next = node;
    	node->pre = tmp;
    	
    	return TRUE;
    }
    

    双链表按任意位置插

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	if (node->next != NULL)
    		node->next->pre = node;
    	
    				
    	return TRUE;
    }
    
    

    双链表按位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL || tmp->next == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    
    	if (NULL != p->next)
    		p->next->pre = tmp;
    	free(p);
    				
    	return TRUE;
    }
    

    双链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
    		return ERROR;
    	
    /*	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;			//将头结点的next指向最后一个元素*/
    
    	Node *cur = ls->head->next;
    	while(cur->next)//最后结点不交换
    	{
    		Node *tmp = cur->next;	//保存cur的next指针
    		cur->next = cur->pre;	//next和pre交换
    		cur->pre = tmp;			
    		cur = tmp;				//移动
    
    	}
    	
    	ls->head->next->next = NULL;//第一个元素nextNULL
    	ls->head->next = cur;
    	cur->next = cur->pre;	//手动交换
    	cur->pre = ls->head;
    
    	return TRUE;
    }
    

    双链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    
    

    双向循环链表

    双向循环链表在双链表的基础上,将最后一个结点的尾指针重新指向头结点

    双向循环链表的创建

    List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = ls->head;   // 空链表
    	ls->head->pre  = ls->head;
    	
    	return ls;
    

    双向循环链表的头插

    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head->next;
    	ls->head->next = node;
    	node->pre = ls->head;
    	node->next->pre = node;
    	
    	return TRUE;
    

    双向循环链表的尾插

    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next != ls->head)
    	{
    		tmp = tmp->next;
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head;
    	tmp->next = node;
    	node->pre = tmp;
    	ls->head->pre = node;
    	
    	return TRUE;
    }
    
    

    双向循环链表的按任意位置插

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	node->next->pre = node;
    	
    				
    	return TRUE;
    }
    

    双向循环链表的按任意位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL || tmp->next == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    
    	if (NULL != p->next)
    		p->next->pre = tmp;
    	free(p);
    				
    	return TRUE;
    }
    

    双向循环链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
    		return ERROR;
    	
    /*	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;			//将头结点的next指向最后一个元素*/
    
    	Node *cur = ls->head->next;
    	while(cur->next != ls->head)
    	{
    		Node *tmp = cur->next;	//保存cur的next指针
    		cur->next = cur->pre;	//next和pre交换
    		cur->pre = tmp;			
    		cur = tmp;				//移动
    
    	}
    	
    	cur->next = cur->pre;
    	cur->pre = ls->head;
    	ls->head->pre = ls->head->next;	//逆序
    	ls->head->next = cur;
    
    	return TRUE;
    }
    

    双向循环链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next != ls->head)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    
    展开全文
  • //循环链表的尾指针应该指向头指针 p->link = head; currPos = p; tail = p; count++; } } template bool doubleList ::seek(const T x) { LinkNode * p = head; int i = length(); ...
    //头文件
    #ifndef DOUBLELIST_H
    #define DOUBLELIST_H
    
    #include
       
        
    using namespace std;
    template
        
         
    class LinkNode{
    public:
    	T data;
    	LinkNode
         
          * link;
    	LinkNode
          
           * prev;
    	LinkNode(const T item, LinkNode
           
            * str=NULL, LinkNode
            
             * ptr=NULL){ data = item; link = str; prev = ptr; } }; template
             
               class doubleList{ private: static int count ; LinkNode
              
               * head; LinkNode
               
                * tail; LinkNode
                
                 * currPos; LinkNode
                 
                  * position; bool seek(const T x);//查找与给定值相同的节点 public: doubleList(); ~doubleList(); void setValue(); bool deleteAim(const T x);//删除与给定值相同的节点 void clear(); void print(); int length(); }; template
                  
                    int doubleList
                   
                    ::length() { return count; } template
                    
                      int doubleList
                     
                      ::count = 0; template
                      
                        void doubleList
                       
                        ::print() { LinkNode
                        
                         * p = head; int i = length(); while (i) { cout << p->data << " "; p = p->link; i--; } } template
                         
                           doubleList
                          
                           ::doubleList() { //默认构造函数 } template
                           
                             doubleList
                            
                             ::~doubleList() { clear(); } template
                             
                               void doubleList
                              
                               ::setValue() { T data; cin >> data; if (head == NULL) { head = new LinkNode
                               
                                (data); head->link = head; //头结点的prev=NULL; head->prev = NULL; currPos = head; tail = head; count++; } else { LinkNode
                                
                                 * p = currPos; p->link = new LinkNode
                                 
                                  (data); p = p->link; p->prev = currPos; //循环链表的尾指针应该指向头指针 p->link = head; currPos = p; tail = p; count++; } } template
                                  
                                    bool doubleList
                                   
                                    ::seek(const T x) { LinkNode
                                    
                                     * p = head; int i = length(); while (i) { if (p->data == x) { position = p; return true; } p = p->link; i--; } return false; } template
                                     
                                       bool doubleList
                                      
                                       ::deleteAim(const T x) { if (seek(x)) { position->link->prev = position->prev; position->prev->link = position->link; delete position; count--; return true; } return false; } template
                                       
                                         void doubleList
                                        
                                         ::clear() { LinkNode
                                         
                                          * p = head; while (count) { p = p->link; delete head; head = p; count--; } } #endif //主函数 #include"DoubleList.h" int main(int argc, char argv[]) { doubleList
                                          
                                           list; int count; cout << "输入你需要的链表长度,并初始化:"; cin >> count; for (int i = 0; i < count; i++) { list.setValue(); } list.print(); int number; cout << "输入你要删除的数:"; cin >> number; list.deleteAim(number); list.print(); return 0; }
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
    展开全文
  • 双链表和循环双链表复习

    千次阅读 2018-08-10 08:40:32
    首先不管是单链表还是双链表或者循环双链表,都是为了提高访问效率,比如同样的插入操作,顺序表需要用数组移动元素,访问效率比较差,相反链表只需要移动指针,而且顺序表是有最大空间的,而链表没有。 双链表格式...
  • 若是不清楚链表的结构,该篇文章不适合观看,这里只做文字说明,没有链表结构的图示
  • 而对于双循环链表,只需要最后一个元素的next指向head-&gt;next,head-&gt;next的prior指向最后一个节点即可。 插入操作 新节点s插入链表,s-&gt;next给p结点,s-&gt;prior给p-&gt;prior,...
  • 用头插法建立带头结点的循环双链表并对已创建的双链表实现插入、删除、查找等基本操作。
  • 排序循环双链表 实现 package pers.zhang.linearList; /** * @author zhang * @date 2020/1/15 - 15:16 * * 按升序排序的循环双链表类,继承循环双链表类,E必须实现Comparable<T>接口,支持对象可比较...
  • 创建一个双向链表或双向循环链表

    千次阅读 2015-10-12 09:06:02
    #include #include #define len sizeof(struct list) struct list { int x; struct list *pre,*next;...struct list * create()//创建链表并返回链表的首地址 { struct list *p,*p1,*head; head=p=(struct list
  • 题目 19. 删除链表的倒数N节点 ...# 对于这种题目,循环结束条件设为快指针到达最后一个元素即可,然后倒数个元素,就让慢指针慢几步就好。 # 增加头部,是为了统一删除元素的代码 temp_head = Lis...
  • 循环链表的定义:将单链表中最后一数据元素的next指针指向第一个元素 循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的...
  • 循环双链表教程(个人笔记)

    千次阅读 热门讨论 2021-03-13 22:54:40
    循环双链表教程循环双链表教程(个人笔记)前言、定义结构体二、创建空表三、插入方法1.尾插法2.选插法四、查找方法1.按位置查找2.按内容查找五、输出链表六、删除方法1.按位置删除2.全部删除总结 、定义结构体 ...
  • 文章目录前言单链表单循环链表双链表循环链表错误纠正说明时间复杂度比较关于头结点 前言 博主最近在复习算法与数据结构,由于平时主力语言是Python,所以找了用Python讲解数据结构的视频看了下,链接为:...
  • 文章目录、前言二、循环单链表每次循环删除一个最小的三、单链表每次循环删除一个最小的四、循环双链表每次循环删除一个最小的五、双链表每次循环删除一个最小的六、循环双链表记录访问次数,按访问次数排序七、双...
  • 题目:设计一个算法用于判断带头结点的循环双链表是否对称 关键字:带头结点的循环双链表+判断对称 思路 关注:递归算法的设计重点在于找到“递归”的部分,即重复调用函数,改变部分相关变量 设f(L,x)的功能是:...
  • 循环链表与双向链表

    千次阅读 2014-04-21 14:55:36
    1循环链表 循环链表也是种链式存储结构,他的
  • 二章 线性表 双链表 循环链表

    千次阅读 多人点赞 2020-06-14 17:53:08
    二章 线性表 ...在单链表中只有一个指向其后继节点的指针,导致单链表只能从头结点依次顺序的向后遍历,访问后继结点的效率为O(1),但是访问前继结点的效率为O(1),为了解决这问题,我们引入了双链表
  • 循环双向链表

    2011-08-28 23:17:42
    明天开学了 暑假大概地过完了一遍基本的数据结构 现在也要开始复习 边学其他的东西了 大二开始了 加油 下面的循环双向链表作为链表类的第一个复习 文件"dlist.h" #include using namespace std; template class ...
  • * 编写一个程序实现循环双链表的各种基本运算,并在此基础上设计一个主程序 * 完成如下功能: * (1)初始化循环双链表h * (2)依次采用尾部插入法插入a,b,c,d,e元素 * (3)输出循环双链表h * (4)输出循环双链表h长度 * (....
  • 循环链表是另一种形式的链式存储结构,其特点是单链表的最后一结点的指针不为空,而是指向头结点(带头结点的链表)或第一个结点(不带头结点的链表),整个链表形成一环。这样从链表任何一位置出发,均可以...
  • 必须从第1个结点开始\n"); Sleep(sleep_time); exit(1); } DoubleList *pTemp; pTemp = L; pTemp = pTemp->next; int i=1; while (pTemp != L && i!=pos) { pTemp = pTemp->next; i++; } if ...
  • 循环链表双循环链表

    千次阅读 2017-05-07 22:49:01
    接着上篇博文,把循环链表里的双循环链表的基本操纵按照我个人的理解进行总结一下。 依然沿袭过去的风格,进入双循环链表之前,先提另种结构,双向链表,先有了...双链表循环链表
  • 文章目录循环链表1.1循环链表基本概念1.2循环链表基本操作1.3循环链表实现及使用二、双向链表2.1双向链表基本概念2.2双向链表基本操作2.3双向链表实现及使用 循环链表 1.1循环链表基本概念 1.2循环链表基本...
  • 双链表的插入和删除操作 在p节点之前插入值为x的节点 在p节点之后插入值为x的节点 双链表删除操作 双链表节点 package pers.zhang.linearList; /** * @author zhang * @date 2020/1/15 - 11:06 * 双链表...
  • 单链表、双向链表循环链表

    千次阅读 多人点赞 2019-07-26 14:26:09
    尾结点的指针不是指向下一个节点而是指向一个空地址NULL,表示链表上的最后一个节点。 和数组一样,链表也支持数据的查找、插入和删除操作。但相对于数据的插入删除需要做大量的搬移操作,链表的插入,删除的时间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,451
精华内容 19,380
关键字:

循环双链表删除第一个元素