TommyBay

C++ 手写链表最终更新

历史更新内容：

v1.4.2 更新：添加对尾指针的支持以便PushBack()
v1.4.3 更新：添加对前向指针的支持，使之成为双链表以便PopBack()
v1.4.4 更新：紧急修复了空表PushFront()和PopFront()时，使用了空指针的（并不存在的）前向指针成员的bug，但代价是各添加了一个if块，会导致性能损失
v1.4.5 更新：添加对循环链表的支持使之成为循环双链表。

老目标：

单链表基本实现
单链表的构造函数
完成Lab2_3
尾指针
双链表
用单链表 (v1.4.4) 实现“快速找到未知长度单链表的中间节点”
用单链表 (v1.4.4) 实现“链表的冒泡排序”
循环双链表
用循环(双)链表 (v1.4.5) 完成约瑟夫环问题的解决；
C++多文件
越界异常处理
学习真正的C++ STL Linked List；
通过C++面向对象特性，实现链栈(与链队列)

重要提示：

如提示未定义nullptr，请将编译器设置为C++11或取消第5行语句的注释。
由于循环链表的特性（比如根据tail->nextfirst还是tail->nextnullptr判断尾端），为简单起见使用普通单链表 (v1.4.4) 实现冒泡排序和寻找中间节点的示例；约瑟夫环则使用循环链表。
本周将投入到链栈链队列（1天）以及图论与树（直到10.17）的工作中去，因此本更新为链表的最后更新，敬请留意新文章。

用单链表 (v1.4.4) 实现“快速找到未知长度单链表的中间节点”

//myLinkedList(TailInsert) v1.4.4 快速找到未知长度单链表的中间节点
// #define TT template 
// #define mll myLinkedList
#define N 5
//#define nullptr NULL
#include 
#include 
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    Node<T>* GetMiddleNode();

    int Test();
private:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
    tail=first;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
	while(first->next!=nullptr)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
    while (p!=nullptr)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
    while (p!=nullptr)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;
            length++;
            if (s->next==nullptr)
                tail=s;
            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
            if (p->next==nullptr)
                tail=p;
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
        tail=s;
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
    if (p->next==nullptr)
        tail=p;
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
    if (first->next==nullptr)
        tail=first;
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
    if (s->next==nullptr)
        tail=s;
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    s->prev=nullptr;
    tail=p;
    delete s;
    length--;
    return temp;
}

template <typename T>
Node<T>* myLinkedList<T>::GetMiddleNode()
{
    Node<T>* p=first->next;
    Node<T>* q=first->next;
//    while (p!=nullptr)
//    {
//        p=p->next->next;
//        q=q->next;
//    }
    while (true)
    {
        if ((p==nullptr)||(p->next==nullptr))
            break;
        else
        {
            p=p->next->next;
            q=q->next;
        }
    }
    return q;
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    cout<<"根据数组初始化新链表myList："<
    cout<<"new myList:"<<endl;
    int arr[N]={1,2,3,4,5};
    myLinkedList<int> myList(arr,N);
    myList.PopBack();
	myList.PrintList();

	Node<int>* ansptr=myList.GetMiddleNode();
	cout<<ansptr->data;

    //cout<<"
    return 0;
}

用单链表 (v1.4.4) 实现“链表的冒泡排序”

//myLinkedList(TailInsert) v1.4.4 链表的冒泡排序 Swap()
// #define TT template 
// #define mll myLinkedList
#define N 5
//#define nullptr NULL
#include 
#include 
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    void Swap(Node<T>* p,Node<T>* q);
    bool Compare(Node<T>* p,Node<T>* q);
    void BubbleSort();

    int Test();
private:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
    tail=first;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
	while(first->next!=nullptr)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
    while (p!=nullptr)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
    while (p!=nullptr)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;
            length++;
            if (s->next==nullptr)
                tail=s;
            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
            if (p->next==nullptr)
                tail=p;
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
        tail=s;
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
    if (p->next==nullptr)
        tail=p;
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
    if (first->next==nullptr)
        tail=first;
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
    if (s->next==nullptr)
        tail=s;
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    s->prev=nullptr;
    tail=p;
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::Swap(Node<T>* p,Node<T>* q)
{
    T temp=p->data;
    p->data=q->data;
    q->data=temp;
}

template <typename T>
bool myLinkedList<T>::Compare(Node<T>* p,Node<T>* q)
{
    if ((p->data)>(q->data))
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::BubbleSort()
{
    Node<T>* BBack=first;
    while (BBack->next!=nullptr)
    {
        BBack=BBack->next;
    }

    while (BBack!=first->next)
    {
        Node<T>* p=first->next;
        while (p->next!=BBack)
        {
            if (Compare(p,p->next))
                Swap(p,p->next);
            p=p->next;
        }
        if (Compare(p,p->next))
            Swap(p,p->next);
        BBack=p;
    }
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    cout<<"根据数组初始化新链表myList："<
    cout<<"new myList:"<<endl;
    int arr[N]={5,4,3,2,1};
    myLinkedList<int> myList(arr,N);
    myList.PrintList();
    myList.BubbleSort();
    myList.PrintList();

    //cout<<"
    return 0;
}

用循环(双)链表 (v1.4.5) 完成约瑟夫环问题的解决；

//myLinkedList(TailInsert) v1.4.5 约瑟夫环 lab3_3
// #define TT template 
// #define mll myLinkedList
#define N 6
#define MAXN 110
#define nullptr NULL
#include 
#include 
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    int Test();
//private:
public:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    tail=first;
    first->next=tail;
    first->prev=tail;
    length=0;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
//	while(first->next!=nullptr)
	while(first->next!=first)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
//    while (p!=nullptr)
    while (p!=first)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
//        while (p!=nullptr)
        while (p!=first)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
//    while (p!=nullptr)
    while (p!=first)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
//    while (p!=nullptr)
    while (p!=first)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;

            s->next->prev=s;
            length++;
//            if (s->next==nullptr)
//                tail=s;
            if (s->next==first)
            {
                tail=s;
                first->prev=tail;
            }

            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
//    while (p!=nullptr)
    while (p!=first)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
//            if (p->next==nullptr)
//                tail=p;
            if (p->next==first)
            {
                tail=p;
                first->prev=tail;
            }
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
//        while (p!=nullptr)
        while (p!=first)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
    {
        tail=s;
        first->prev=tail;
    }
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
//    if (p->next==nullptr)
//        tail=p;
    if (p->next==first)
    {
        tail=p;
        first->prev=tail;
    }
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
//    if (first->next==nullptr)
//        tail=first;
    if (first->next==first)
    {
        tail=first;
        first->prev=tail;
    }
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
//    if (s->next==nullptr)
//        tail=s;
    if (s->next==first)
    {
        tail=s;
        first->prev=tail;
    }
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;

    first->prev=tail;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    //s->prev=nullptr;//No need to
    tail=p;
    delete s;
    length--;

    first->prev=tail;
    return temp;
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    int arr[N]={1,2,3,4,5,6},m=3;
    int arr[MAXN],n=0,m=0;
    cout<<"How many soliders?"<<endl;
    cin>>n;
    cout<<"What are their codes?"<<endl;
    for (int i=0;i<n;i++)
    {
        cin>>arr[i];
    }
    myLinkedList<int> myl(arr,N);
    cout<<"They are:"<<endl;
    myl.PrintList();
    cout<<"What is the command?"<<endl;
    cin>>m;

    cout<<"The killing list:"<<endl;
    Node<int>* ptr=myl.first;
    Node<int>* ptrX=ptr;
    for (int i=0;i<N;i++)
    {
        for (int j=0;j<m;j++)
        {
            ptrX=ptr;
            ptr=ptr->next;
            if (ptr==myl.first)
                ptr=ptr->next;
        }
        int temp=ptr->data;
        ptrX->next=ptr->next;
        cout<<temp<<' ';
//        delete ptr;
    }
    return 0;
}

(全文完)

数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
2024.8.22 Python，链表两数之和，链表快速反转，二叉树的深度，二叉树前中后序遍历，N叉树递归遍历，翻转二叉树 RaidenQ python 链表开发语言
1.链表两数之和输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9,9,9,9,9],l2=[9,9,9,9]输出：[8,9,9,9,0,0,0,1]昨天的这个题，用自己的办法写的麻烦的要死，然后刚才一看chat归类的办法，感觉自己像个智障。classListNode
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
自定义队列 junjun2018
队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
【高阶数据结构】并查集椿融雪数据结构与算法数据结构并查集
文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
python中文版软件下载-Python中文版编程大乐趣
python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
leetcode021-合并两个有序链表陆阳226
问题描述将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例：输入：1->2->4,1->3->4输出：1->1->2->3->4->4解答递归法：每一层减去一个较小的节点，直到某个链表为null递归结束。publicstaticListNodesolution(ListNodel1,ListNodel2){if(l1==null){returnl2;}
MySQL事务隔离级别和MVCC 简书徐小耳
MySQL事务隔离级别和MVCC参考：https://mp.weixin.qq.com/s/Jeg8656gGtkPteYWrG5_Nw1.MVCC只对读已提交和可重复的读有效果，而未提交读和串行则无意义。2.每条记录都会有trx_id(事务修改记录的id）和roll_pointer是一个指针指向旧版本的undo日志链表（row_id不是必必要的，如果有主键存在就不需要了）3.版本链的头结点就是记
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
每日一题《leetcode--LCR 022.环形链表||》 Peace & Love487 题目分享 leetcode 链表算法笔记数据结构
https://leetcode.cn/problems/c32eOV/我们使用两个指针，fast与slow。它们起始都位于链表的头部。随后slow指针每次向后移动一个位置，而fast指针向后移动两个位置。如果链表中存在环，则fast指针最终将再次与slow指针在环中相遇。structListNode*detectCycle(structListNode*head){structListNode*
LCR 078. 合并 K 个升序链表装B且挨揍の LeetCode 链表算法数据结构经验分享笔记 java
https://leetcode.cn/problems/vvXgSW/description/https://leetcode.cn/problems/vvXgSW/description/解题思路方法一：每个链表维护一个索引，每次找到值最小的节点，索引加一。可以采用优先队列实现。/***Definitionforsingly-linkedlist.*publicclassListNode{*i
数组模拟单链表 Star_. 蓝桥杯 java 数据结构链表
实现一个单链表，链表初始为空，支持三种操作：向链表头插入一个数；删除第k个插入的数后面的数；在第k个插入的数后插入一个数。现在要对该链表进行M次操作，进行完所有操作后，从头到尾输出整个链表。注意:题目中第k个插入的数并不是指当前链表的第k个数。例如操作过程中一共插入了n个数，则按照插入的时间顺序，这n个数依次为：第1个插入的数，第2个插入的数，…第n个插入的数。输入格式第一行包含整数M，表示操作次
Golang Channel PandaSkr golang
Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
数据结构 1 五花肉村长数据结构算法开发语言 c语言 visualstudio
1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
c语言双向链表清空,C语言实现链表之双向链表（四）清空链表火龙果和哈密瓜 c语言双向链表清空
/*==============================================================================*操作：清空链表，释放结点内存，将链表重置为空表*操作前：ppHeadNode为链表头指针的二级指针*操作后：(*ppHeadNode)所指链表中的所有结点的内存被释放，重置为空表==============================
jvm调优总结（从基本概念到深度优化） oloz java jvm jdk 虚拟机应用服务器
JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
【Scala十六】Scala核心十：柯里化函数 bit1129 scala
本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系 1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
HashMap dalan_123 java
HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构在java中，最基本的数据结构无外乎：数组和引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
Java Swing如何实时刷新JTextArea，以显示刚才加append的内容周凡杨 java 更新 swing JTextArea
在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
servlet或struts的Action处理ajax请求 g21121 servlet
其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
FineReport的公式编辑框的语法简介老A不折腾 finereport 公式总结
FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。简单的说下自己感觉的公式要注意的几个地方： 1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
linux mysql 数据库乱码的解决办法墙头上一根草 linux mysql 数据库乱码
linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写修改/etc/my.cnf 具体的修改内容如下: [client] default-character-set=utf8 [mysqld] datadir=/var/lib/mysql socket=/va
我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
mysql 基准测试之sysbench annan211 基准测试 mysql基准测试 MySQL测试 sysbench
1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz cd sysbench-0.5 chmod +x autogen.sh ./autogen.sh ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
sql的复杂查询使用案列与技巧百合不是茶 oracle sql 函数数据分页合并查询
本片博客使用的数据库表是oracle中的scott用户表; ------------------- 自然连接查询查询 smith 的上司(两种方法) &
深入学习Thread类 bijian1013 java thread 多线程 java多线程
一．线程的名字下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。同时，Thr
JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 java fastjson net.sf.json
在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。一.fastjson实例 JsonUtil.java package com.study; impor
【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
#!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
nginx三种获取用户真实ip的方法 ronin47
随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。实例环境：用户IP 120.22.11.11
java-判断二叉树是不是平衡 bylijinnan java
参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtils BeanUtils
BeanUtils.copyProperties VS PropertyUtils.copyProperties 作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
[金融与信息安全]最简单的数据结构最安全 comsci 数据结构
现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
vi区段删除 Cwind linux vi 区段删除
区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 vi概述引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
清除tomcat缓存的方法总结 dashuaifu tomcat 缓存
用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开依然是以前的Jsp的页面。出现这种现象的原因主要是tomcat缓存的原因。解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
不要盲目的在项目中使用LESS CSS dcj3sjt126com Web less
　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。　　比如它的引用功能 ? .rounded_corners{
[入门]更上一层楼 dcj3sjt126com PHP yii2
更上一层楼通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。本章将介绍一些有助于更好使用 Yii 的资源：
Apache HttpClient使用详解 eksliang httpclient http协议
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
zxing二维码扫描功能 gundumw100 android zxing
经常要用到二维码扫描功能现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
纯HTML+CSS带说明的黄色导航菜单 ini html Web html5 css hovertree
HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： <!DOCTYPE html > <html > <head> <title>HoverTree
fastjson初始化对性能的影响 kane_xie fastjson 序列化
之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。网上的说法： fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/ funct
java 计时器应用 tangqi609567707 java timer
mport java.util.TimerTask; import java.util.Calendar; public class MyTask extends TimerTask { private static final int
erlang输出调用栈信息 wudixiaotie erlang
在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。也可以用这个函数：erlang:get_s

C++ 手写链表 最终更新

历史更新内容：

老目标：

重要提示：

用单链表 (v1.4.4) 实现“快速找到未知长度单链表的中间节点”

用单链表 (v1.4.4) 实现“链表的冒泡排序”

用循环(双)链表 (v1.4.5) 完成约瑟夫环问题的解决；

你可能感兴趣的:(数据结构,链表)

C++ 手写链表最终更新