线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用）

线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用）

一、前言：

​ 在学数据结构的时候，第一次上机实验，老师让我们实现线性表的顺序存储结构和链式存储结构及其简单操作，看着就脑阔疼。书上的代码吧，都是伪代码，照着敲出来n多报错（我们用的是清华大学出版社严蔚敏、陈文博编著的《数据结构及应用算法程序（修订版）》，书挺好的，就是有些地方不太照顾初学者。反正就是看着脑瓜子嗡嗡的，但搞懂了之后满满的都是成就感，让人又爱又恨，感兴趣的小伙伴可以看看）；上网搜前人的成果吧，无一例外都报错七八十个（有可能是我自己的原因，没别的意思）。

​ 一怒之下，我熬了两个通宵终究还是实现了（在实现过程中我也深刻体会到一个好的编译器对码农的帮助有多大，写顺序表的时候我用的VC++6.0，找错是找的我头都秃了，写链表的时候我换了VS2010，报错处有红色波浪线，改错那是嘎嘎快）。一直有想写个博客记录一下我的努力成果，但总是由于各种原因不了了之，今天我终于还是写了这篇博客。

​ 顺序表和链表概念之类的我就不做介绍了，网上一搜，写得好的博主大有人在，咱就不赘述了；下面是顺序表及其简单操作，和链表及其简单操作，用c和c++混用实现，具体有哪些操作在头文件注释里找吧（里面的注释可能有我个人的一些标注，我懒得删了，将就着看吧）

二、线性表的顺序存储结构及其简单操作（多模块）：

首先肯定要创建一个WIN32控制台应用程序的空项目的（在分多模块时一定要注意每个源程序文件引入头文件）

1.创建头文件Definition.h：

#include 
#include  //至少ErrorMessage中要用到
#include //至少ErrorMessage中要用到
const int LIST_INIT_SIZE=100;//线性表（默认的）初始分配最大空间量
const int LISTINCREMENT=10;//默认的增补空间量
//定义线性表SqList类型
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
    int incrementsize;
}SqList;
//顺序表的初始化
//C语言没有默认参数用法，所以可能要C和C++混用
void InitList_Sq(SqList &L,int maxsize=LIST_INIT_SIZE,int incresize=LISTINCREMENT);
//将初始化后的顺序表前十个元素分别赋值为1-10
void NatureList1_10_Sq(SqList &L);
//顺序表查找元素
//在L查找第一个与e相等的元素，若能找到返回其在L的位序，否则返回0
int LocateElem_Sq(SqList L,ElemType e);
/*接下来的三个函数都是为了实现顺序表的插入*/
//出错信息处理函数
void ErrorMessage(char *s);
//顺序表追加空间
void increment(SqList &L);
//顺序表插入元素
//在顺序表L的第i个元素前插入新的元素e ,1<=i<=L.length+1,容量不足按预定义增量扩容
void ListInsert_Sq(SqList &L,int i,ElemType e);
//顺序表删除元素
//在顺序表L中删除第i个元素，并用e返回其值，1<=i<=L.length
void ListDelete_Sq(SqList &L,int i,ElemType &e);//用到了ErrorMessage
//顺序表的销毁
//释放顺序表L所占的储存空间
void DestroyList_Sq(SqList &L);
//顺序表的显示
//因为查找元素时顺序是反的，为了探明原因，写一个显示顺序表的函数
void PrintList_Sq(SqList L);

2.创建源程序文件InitList_Sq.cpp:

//顺序表的初始化
//C语言没有默认常数用法，所以可能要C和C++混用
#include "Definition.h"
void InitList_Sq(SqList &L,int maxsize,int incresize)
{
    L.elem=new ElemType[maxsize];//为顺序表分配一个最大容量为maxsize的数组空间
    L.length=0;
    L.listsize=maxsize;
    L.incrementsize=incresize;
}

3.创建源程序文件NatureList1_10_Sq.cpp:

//将初始化后的顺序表前十个元素分别赋值为1-10
#include "Definition.h"
void NatureList1_10_Sq(SqList &L)
{
    for(int i=0;i<=9;i++)
    {
        L.elem[i]=i+1;
    }
    L.length=10;
}

4.创建源程序文件LocateElem_Sq.cpp:

//顺序表查找元素
//在L查找第一个与e相等的元素，若能找到返回其在L的位序，否则返回0
#include "Definition.h"
int LocateElem_Sq(SqList L,ElemType e)
{
    int i=1;
    ElemType *p=L.elem;
    while(i<=L.length && *(p++)!=e) i++;
    if(i<=L.length) return i;
    else return 0;
}//LocateElem_Sq

5.创建源程序文件ErrorMessage.cpp:

//出错信息处理函数
#include "Definition.h"
void ErrorMessage(char *s)
{
    cout<

6.创建源程序文件increment.cpp:

//顺序表追加空间
#include "Definition.h"
void increment(SqList &L)
{
    ElemType *a;//？？标记一下这里可能会出问题？？
    a=new ElemType [L.listsize+L.incrementsize];
    for(int i=0;i<=L.length;i++)
        a[i]=L.elem[i];
    delete[] L.elem;
    L.elem=a;
    L.listsize=L.listsize+L.incrementsize;
}

7.创建源程序文件ListInsert_Sq.cpp:

//顺序表插入元素
//在顺序表L的第i个元素前插入新的元素e ,1<=i<=L.length+1,容量不足按预定义增量扩容
#include "Definition.h"
void ListInsert_Sq(SqList &L,int i,ElemType e)
{
    if(i<1||i>L.length+1)
        ErrorMessage("i值不合法");
    if(L.length>=L.listsize)
        increment(L);//'>'应该可以不要
    ElemType *q=&(L.elem[i-1]);
    for(ElemType *p=&(L.elem[L.length-1]);p>=q;p--)
        *(p+1)=*p;
    *q=e;
    L.length++;
}//ListInsert_Sq

8.创建源程序文件ListDelete_Sq.cpp:

//顺序表删除元素
//在顺序表L中删除第i个元素，并用e返回其值，1<=i<=L.length
#include "Definition.h"
void ListDelete_Sq(SqList &L,int i,ElemType &e)
{
    if((i<1)||(i>L.length)) 
        ErrorMessage("i值不合法");
    ElemType *p=&(L.elem[i-1]);
    e=*p;
    ElemType *q=L.elem+L.length-1;
    for(++p;p<=q;p++)
        *(p-1)=*p;
    L.length--;
}

9.创建源程序文件DestroyList_Sq.cpp:

//顺序表的销毁
//释放顺序表L所占的储存空间
#include "Definition.h"
void DestroyList_Sq(SqList &L)
{
    delete[] L.elem;
    L.listsize=0;
    L.length=0;
}//DestroyList_Sq

10.创建源程序文件PrintList_Sq.cpp:

//顺序表的显示
//因为查时顺序是反的，为了探明原因，写一个显示顺序表的函数
#include "Definition.h"
void PrintList_Sq(SqList L)
{
    printf("当前顺序表所有元素:");
    for (int i=0;i

11.创建(主函数)源程序文件Main_Sq.cpp：

#include "Definition.h"
int main()
{
    SqList A;
    printf("\n\n");
    int flag;
    printf("******************************************************\n");
    printf("*************choose the operation of List*************\n");
    printf("*****************1-顺序表的初始化*********************\n");
    printf("*****************2-得到1-10的自然顺序表***************\n");
    printf("*****************3-顺序表的显示***********************\n");
    printf("*****************4-顺序表查找元素*********************\n");
    printf("*****************5-顺序表插入元素*********************\n");
    printf("*****************6-顺序表删除元素*********************\n");
    printf("*****************7-顺序表的销毁***********************\n");
    printf("*****************0-退出*******************************\n");
    printf("******************************************************\n");
    printf("\n\n");
    

    while(1){
        printf("Input the function you want to chose:\n");
        scanf("%d",&flag);
        if(flag==0||flag==1||flag==2||flag==3||flag==4||flag==5||flag==6||flag==7)
        {
            printf("The function is=%d\n",flag);
            switch(flag)
            {
            case 1:
                
                {
                    InitList_Sq(A);
                    printf("顺序表初始化成功\n");
                    break;
                }
            case 2:
                {
                    NatureList1_10_Sq(A);
                    printf("已得到1-10的自然顺序表\n");
                    break;
                }
            case 3:
                {
                    printf("当前顺序表为：\n");
                    PrintList_Sq(A);
                    break;
                }
            case 4:
                {
                    int a,pos;
                    printf("请输入你要查找的元素值\n");
                    scanf("%d",&a);
                    pos=LocateElem_Sq(A,a);
                    printf("你要查找的元素值最早出现在第%d位\n",pos);
                    printf("注：若显示0则顺序表中无该元素\n");
                    break;
                }
            case 5:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要（前）插入元素的位置和值:\n");
                    scanf("%d%d",&pos,&a);
                    ListInsert_Sq(A,pos,a);
                    printf("插入元素成功\n");
                    break;
                }
            case 6:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要删除元素的位置:\n");
                    scanf("%d",&pos);
                    ListDelete_Sq(A,pos,a);
                    printf("你删除的元素为%d\n",a);
                    break;
                }
            case 7:
                {
                    DestroyList_Sq(A);
                    printf("销毁成功\n");
                    break;
                }
            case 0:
                printf("you choose to exit\nGoodbye!\n");
                return 0;
            }
        }
        else ErrorMessage("请在菜单内挑选功能");
    }
    return 0;

}

三、顺序表的顺序存储结构及其简单操作（两模块）：

1.创建头文件Definition.h：

#include 
#include  //至少ErrorMessage中要用到
#include //至少ErrorMessage中要用到
using namespace std;
const int LIST_INIT_SIZE=100;//线性表（默认的）初始分配最大空间量
const int LISTINCREMENT=10;//默认的增补空间量
//定义线性表SqList类型
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
    int incrementsize;
}SqList;
//顺序表的初始化
//C语言没有默认常数用法，所以可能要C和C++混用
void InitList_Sq(SqList &L,int maxsize=LIST_INIT_SIZE,int incresize=LISTINCREMENT);
//将初始化后的顺序表前十个元素分别赋值为1-10
void NatureList1_10_Sq(SqList &L);
//顺序表查找元素
//在L查找第一个与e相等的元素，若能找到返回其在L的位序，否则返回0
int LocateElem_Sq(SqList L,ElemType e);
/*接下来的三个函数都是为了实现顺序表的插入*/
//出错信息处理函数
void ErrorMessage(char *s);
//顺序表追加空间
void increment(SqList &L);
//顺序表插入元素
//在顺序表L的第i个元素前插入新的元素e ,1<=i<=L.length+1,容量不足按预定义增量扩容
void ListInsert_Sq(SqList &L,int i,ElemType e);
//顺序表删除元素
//在顺序表L中删除第i个元素，并用e返回其值，1<=i<=L.length
void ListDelete_Sq(SqList &L,int i,ElemType &e);//用到了ErrorMessage
//顺序表的销毁
//释放顺序表L所占的储存空间
void DestroyList_Sq(SqList &L);
//顺序表的显示
//因为查找元素时顺序是反的，为了探明原因，写一个显示顺序表的函数
void PrintList_Sq(SqList L);
//顺序表的初始化
//C语言没有默认常数用法，所以可能要C和C++混用
void InitList_Sq(SqList &L,int maxsize,int incresize)
{
    L.elem=new ElemType[maxsize];//为顺序表分配一个最大容量为maxsize的数组空间
    L.length=0;
    L.listsize=maxsize;
    L.incrementsize=incresize;
}
//将初始化后的顺序表前十个元素分别赋值为1-10
void NatureList1_10_Sq(SqList &L)
{
    for(int i=0;i<=9;i++)
    {
        L.elem[i]=i+1;
    }
    L.length=10;
}
//顺序表的显示
//因为查找元素时顺序是反的，为了探明原因，写一个显示顺序表的函数
void PrintList_Sq(SqList L)
{
    printf("当前顺序表所有元素:");
    for (int i=0;iL.length+1)
        ErrorMessage("i值不合法");
    if(L.length>=L.listsize)
        increment(L);//'>'应该可以不要
    ElemType *q=&(L.elem[i-1]);
    for(ElemType *p=&(L.elem[L.length-1]);p>=q;p--)
        *(p+1)=*p;
    *q=e;
    L.length++;
}//ListInsert_Sq
//顺序表删除元素
//在顺序表L中删除第i个元素，并用e返回其值，1<=i<=L.length
void ListDelete_Sq(SqList &L,int i,ElemType &e)
{
    if((i<1)||(i>L.length)) 
        ErrorMessage("i值不合法");
    ElemType *p=&(L.elem[i-1]);
    e=*p;
    ElemType *q=L.elem+L.length-1;
    for(++p;p<=q;p++)
        *(p-1)=*p;
    L.length--;
}
//顺序表的销毁
//释放顺序表L所占的储存空间
void DestroyList_Sq(SqList &L)
{
    delete[] L.elem;
    L.listsize=0;
    L.length=0;
}//DestroyList_Sq

2.创建(主函数)源程序文件Main_Lk.cpp：

#include "Definition.h"
int main()
{
    SqList A;
    printf("\n\n");
    int flag;
    printf("******************************************************\n");
    printf("*************choose the operation of List*************\n");
    printf("*****************1-顺序表的初始化*********************\n");
    printf("*****************2-得到1-10的自然顺序表***************\n");
    printf("*****************3-顺序表的显示***********************\n");
    printf("*****************4-顺序表查找元素*********************\n");
    printf("*****************5-顺序表插入元素*********************\n");
    printf("*****************6-顺序表删除元素*********************\n");
    printf("*****************7-顺序表的销毁***********************\n");
    printf("*****************0-退出*******************************\n");
    printf("******************************************************\n");
    printf("\n\n");
    
    while(1){
        printf("Input the function you want to chose:\n");
        scanf("%d",&flag);
        if(flag==0||flag==1||flag==2||flag==3||flag==4||flag==5||flag==6||flag==7)
        {
            printf("The function is=%d\n",flag);
            switch(flag)
            {
            case 1:
                
                {
                    InitList_Sq(A);
                    printf("顺序表初始化成功\n");
                    break;
                }
            case 2:
                {
                    NatureList1_10_Sq(A);
                    printf("已得到1-10的自然顺序表\n");
                    break;
                }
            case 3:
                {
                    printf("当前顺序表为：\n");
                    PrintList_Sq(A);
                    break;
                }
            case 4:
                {
                    int a,pos;
                    printf("请输入你要查找的元素值\n");
                    scanf("%d",&a);
                    pos=LocateElem_Sq(A,a);
                    printf("你要查找的元素值最早出现在第%d位\n",pos);
                    printf("注：若显示0则顺序表中无该元素\n");
                    break;
                }
            case 5:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要（前）插入元素的位置和值:\n");
                    scanf("%d%d",&pos,&a);
                    ListInsert_Sq(A,pos,a);
                    printf("插入元素成功\n");
                    break;
                }
            case 6:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要删除元素的位置:\n");
                    scanf("%d",&pos);
                    ListDelete_Sq(A,pos,a);
                    printf("你删除的元素为%d\n",a);
                    break;
                }
            case 7:
                {
                    DestroyList_Sq(A);
                    printf("销毁成功\n");
                    break;
                }
            case 0:
                printf("you choose to exit\nGoodbye!\n");
                return 0;
            }
        }
        else ErrorMessage("请在菜单内挑选功能");
    }
    return 0;
}

四、链表的顺序存储结构及其简单操作（多模块）：

1.创建头文件Difinition.h：

#include 
#include  //至少ErrorMessage中要用到
#include //至少ErrorMessage中要用到
using namespace std;

const int LIST_INIT_SIZE=5;//链表默认长度为5

typedef int ElemType;//声明ElemType
//（单）链表的储存表示
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;//??可能有问题，标记一下??
//初始化一个长度为n的链表,默认长度为LIST_INIT_SIZE
void ListCreat_Lk(LinkList *&head,int n=LIST_INIT_SIZE);//特别要注意*&head
//遍历链表(逐项输出)
void TravelList_Lk(LinkList *head);
//求链表的长度
int ListLength_Lk(LinkList *head);
//查找链表中的元素,显示其节点位序
void LocateElem_Lk(LinkList *head,ElemType e);
//出错信息处理函数
void ErrorMessage(char *s);
//链表节点插入（前插）
//在第i个元素前插入一个元素e
void InsertElem_Lk(LinkList *&head,int i,ElemType e);//特别要注意*&head
//删除链表的第i个元素，并用e返回其值
void DeleteElem_Lk(LinkList *&head,int i,ElemType &e);//特别要注意*&head
//链表的销毁
//从第一个元素开始逐个删除
void DestroyList_Lk(LinkList *&head);//特别要注意*&head

2.创建源程序文件ListCreat_Lk.cpp：

//初始化一个长度为n的链表,默认长度为LIST_INIT_SIZE
#include "Difinition.h"//Definition打错了，将就着用吧
void ListCreat_Lk(LinkList *&head,int n)
{
    LinkList *node,*end;//定义头节点，普通节点，尾部节点；
    head=new LinkList;//分配地址
    end=head;//若是空链表则头尾节点一样
    for(int i=0;idata);
        end->next=node;
        end=node;
    }
    end->next=NULL;//结束创建
}//LinkCreat_Lk

3.创建源程序文件TravelList_Lk.cpp：

//遍历链表(逐项输出)
#include "Difinition.h"//Definition打错了，将就着用吧
void TravelList_Lk(LinkList *head)
{
    LinkList *p=head->next;
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p=p->next;
    }
    printf("\n");
}//TravelList_Lk

4.创建源程序文件ListLength_Lk.cpp：

//求链表的长度
#include "Difinition.h"//Definition打错了，将就着用吧
int ListLength_Lk(LinkList *head)
{
    LinkList *p=head->next;
    int k=0;
    while(p)
    {
        p=p->next;
        k++;
    }
    return k;
}//ListLength_Lk

5.创建源程序文件LocateElem_Lk.cpp：

//查找链表中的元素,显示其节点位序
#include "Difinition.h"//Definition打错了，将就着用吧
void LocateElem_Lk(LinkList *head,ElemType e)
{
    int k=0;
    LinkList *p=head;
    while(p&&p->data!=e)
    {
        p=p->next;
        k++;
    }
    if(p==NULL) k=0;
    printf("你所查找的元素最先出现的位序为：%d\n",k);
    printf("注：若显示0则该链表无所查元素\n");
}//LocateList_Lk

6.创建源程序文件ErrorMessage.cpp：

//出错信息处理函数
#include "Difinition.h"//Definition打错了，将就着用吧
void ErrorMessage(char *s)
{
    cout<

7.创建源程序文件InsertElem_Lk.cpp：

//链表节点插入（前插）
//在第i个元素前插入一个元素e
#include "Difinition.h"//Definition打错了，将就着用吧
void InsertElem_Lk(LinkList *&head,int i,ElemType e)//特别要注意*&head
{
    int k=ListLength_Lk(head);
    if(i<1||i>k) ErrorMessage("i值不合法");
    else if(i==1)
    {
        LinkList *p=new LinkList;
        p->data=e;
        p->next=head->next;
        head->next=p;
    }
    else
    {
        LinkList *q=head;
        for(i=i-1;i>0;i--)
        {
            q=q->next;
        }
        LinkList *p=new LinkList;
        p->data=e;
        p->next=q->next;
        q->next=p;
    }
}//InsertElem_Lk

8.创建源程序文件DeleteElem_Lk.cpp：

//删除链表的第i个元素，并用e返回其值
#include "Difinition.h"//Definition打错了，将就着用吧
void DeleteElem_Lk(LinkList *&head,int i,ElemType &e)//特别要注意*&head
{
    int k=ListLength_Lk(head);
    if(i<1||i>k) ErrorMessage("i值不合法");
    else if(i==1)
    {
        LinkList *p=head->next;
        head->next=p->next;
        e=p->data;
        delete p;
    }
    else
    {
        LinkList *q=head;
        for(i=i-1;i>0;i--)
        {
            q=q->next;
        }
        LinkList *p=q->next;
        e=p->data;
        q->next=p->next;
        delete p;
    }
}//DeleteElem_Lk

9.创建源程序文件DestroyList_Lk.cpp：

//链表的销毁
//从第一个元素开始逐个删除
#include "Difinition.h"//Definition打错了，将就着用吧
void DestroyList_Lk(LinkList *&head)//特别要注意*&head
{
    LinkList *p;
    while(head->next!=NULL)
    {
        p=head->next;
        head->next=p->next;
        delete p;
    }
}//DestroyLink_Lk

10.创建源程序文件Main_Lk.cpp：

#include "Difinition.h"//Definition打错了，将就着用吧
int main()
{
    LinkList *head1;//LinkList *head1=new LinkList;也可去除警告
    head1=NULL;
    printf("\n\n");
    int flag;
    printf("**************************************************************\n");
    printf("*****************choose the operation of List*****************\n");
    printf("*********************1-链表的初始化***************************\n");
    printf("*********************2-链表的遍历（逐项输出）*****************\n");
    printf("*********************3-求链表的长度***************************\n");
    printf("*********************4-查找链表的元素*************************\n");
    printf("*********************5-链表的元素插入*************************\n");
    printf("*********************6-链表的元素删除*************************\n");
    printf("*********************7-链表的销毁*****************************\n");
    printf("*********************0-退出***********************************\n");
    printf("**************************************************************\n");
    printf("****注：此程序涉及的链表带头结点，但不参与长度和位序的计算****\n");
    printf("\n\n");
    
    while(1){
        printf("Input the function you want to chose:\n");
        scanf("%d",&flag);
        if(flag==0||flag==1||flag==2||flag==3||flag==4||flag==5||flag==6||flag==7)
        {
            printf("The function is=%d\n",flag);
            switch(flag)
            {
            case 1:
                {
                    printf("请逐个输入链表的五个值：\n");
                    ListCreat_Lk(head1);
                    printf("链表初始化成功(长度为5)\n");
                    break;
                }
            case 2:
                {
                    printf("当前链表为：\n");
                    TravelList_Lk(head1);
                    break;
                }
            case 3:
                {
                    int len=ListLength_Lk(head1);
                    printf("当前链表长度为：%d\n",len);
                    break;
                }
            case 4:
                {
                    int a;
                    printf("请输入你要查找的元素值\n");
                    scanf("%d",&a);
                    LocateElem_Lk(head1,a);
                    break;
                }
            case 5:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要（前）插入元素的位置和值:\n");
                    scanf("%d%d",&pos,&a);
                    InsertElem_Lk(head1,pos,a);
                    printf("插入元素成功\n");
                    break;
                }
            case 6:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要删除元素的位置:\n");
                    scanf("%d",&pos);
                    DeleteElem_Lk(head1,pos,a);
                    printf("你删除的元素为%d\n",a);
                    break;
                }
            case 7:
                {
                    DestroyList_Lk(head1);
                    printf("销毁成功\n");
                    break;
                }
            case 0:
                printf("you choose to exit\nGoodbye!\n");
                return 0;
            }
        }
        else ErrorMessage("请在菜单内挑选功能");
    }
    return 0;
}
/*"."一般情况下理解为"的”
“->”一般理解为"指向的结构体的"
即引用结构体变量中的元素，若变量是一般的结构体变量用“.”，若为指针则用“->”
注意区别头结点和头指针*/

五、链表的顺序存储结构及其简单操作（两模块）：

1.创建头文件Definition.h：

#include 
#include  //至少ErrorMessage中要用到
#include //至少ErrorMessage中要用到
using namespace std;

const int LIST_INIT_SIZE=5;//链表默认长度为5

typedef int ElemType;//声明ElemType
//（单）链表的储存表示
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;//??可能有问题，标记一下??
//初始化一个长度为n的链表,默认长度为LIST_INIT_SIZE
void ListCreat_Lk(LinkList *&head,int n=LIST_INIT_SIZE);//特别要注意*&head
//遍历链表(逐项输出)
void TravelList_Lk(LinkList *head);
//求链表的长度
int ListLength_Lk(LinkList *head);
//查找链表中的元素,显示其节点位序
void LocateElem_Lk(LinkList *head,ElemType e);
//出错信息处理函数
void ErrorMessage(char *s);
//链表节点插入（前插）
//在第i个元素前插入一个元素e
void InsertElem_Lk(LinkList *&head,int i,ElemType e);//特别要注意*&head
//删除链表的第i个元素，并用e返回其值
void DeleteElem_Lk(LinkList *&head,int i,ElemType &e);//特别要注意*&head
//链表的销毁
//从第一个元素开始逐个删除
void DestroyList_Lk(LinkList *&head);//特别要注意*&head
//初始化一个长度为n的链表,默认长度为LIST_INIT_SIZE
void ListCreat_Lk(LinkList *&head,int n)
{
    LinkList *node,*end;//定义头节点，普通节点，尾部节点；
    head=new LinkList;//分配地址
    end=head;//若是空链表则头尾节点一样
    for(int i=0;idata);
        end->next=node;
        end=node;
    }
    end->next=NULL;//结束创建
}//LinkCreat_Lk
//遍历链表(逐项输出)
void TravelList_Lk(LinkList *head)
{
    LinkList *p=head->next;
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p=p->next;
    }
    printf("\n");
}//TravelList_Lk
//求链表的长度
int ListLength_Lk(LinkList *head)
{
    LinkList *p=head->next;
    int k=0;
    while(p)
    {
        p=p->next;
        k++;
    }
    return k;
}//ListLength_Lk
//查找链表中的元素,显示其节点位序
void LocateElem_Lk(LinkList *head,ElemType e)
{
    int k=0;
    LinkList *p=head;
    while(p&&p->data!=e)
    {
        p=p->next;
        k++;
    }
    if(p==NULL) k=0;
    printf("你所查找的元素最先出现的位序为：%d\n",k);
    printf("注：若显示0则该链表无所查元素\n");
}//LocateList_Lk
//出错信息处理函数
void ErrorMessage(char *s)
{
    cout<k) ErrorMessage("i值不合法");
    else if(i==1)
    {
        LinkList *p=new LinkList;
        p->data=e;
        p->next=head->next;
        head->next=p;
    }
    else
    {
        LinkList *q=head;
        for(i=i-1;i>0;i--)
        {
            q=q->next;
        }
        LinkList *p=new LinkList;
        p->data=e;
        p->next=q->next;
        q->next=p;
    }
}//InsertElem_Lk
//删除链表的第i个元素，并用e返回其值
void DeleteElem_Lk(LinkList *&head,int i,ElemType &e)//特别要注意*&head
{
    int k=ListLength_Lk(head);
    if(i<1||i>k) ErrorMessage("i值不合法");
    else if(i==1)
    {
        LinkList *p=head->next;
        head->next=p->next;
        e=p->data;
        delete p;
    }
    else
    {
        LinkList *q=head;
        for(i=i-1;i>0;i--)
        {
            q=q->next;
        }
        LinkList *p=q->next;
        e=p->data;
        q->next=p->next;
        delete p;
    }
}//DeleteElem_Lk
//链表的销毁
//从第一个元素开始逐个删除
void DestroyList_Lk(LinkList *&head)//特别要注意*&head
{
    LinkList *p;
    while(head->next!=NULL)
    {
        p=head->next;
        head->next=p->next;
        delete p;
    }
}//DestroyLink_Lk

2.创建（主函数）源程序文件Main_Lk.cpp：

#include "Difinition.h"//Definition打错了，将就着用吧
int main()
{
    LinkList *head1;//LinkList *head1=new LinkList;也可去除警告
    head1=NULL;
    printf("\n\n");
    int flag;
    printf("**************************************************************\n");
    printf("*****************choose the operation of List*****************\n");
    printf("*********************1-链表的初始化***************************\n");
    printf("*********************2-链表的遍历（逐项输出）*****************\n");
    printf("*********************3-求链表的长度***************************\n");
    printf("*********************4-查找链表的元素*************************\n");
    printf("*********************5-链表的元素插入*************************\n");
    printf("*********************6-链表的元素删除*************************\n");
    printf("*********************7-链表的销毁*****************************\n");
    printf("*********************0-退出***********************************\n");
    printf("**************************************************************\n");
    printf("****注：此程序涉及的链表带头结点，但不参与长度和位序的计算****\n");
    printf("\n\n");
    

    while(1){
        printf("Input the function you want to chose:\n");
        scanf("%d",&flag);
        if(flag==0||flag==1||flag==2||flag==3||flag==4||flag==5||flag==6||flag==7)
        {
            printf("The function is=%d\n",flag);
            switch(flag)
            {
            case 1:
                {
                    printf("请逐个输入链表的五个值：\n");
                    ListCreat_Lk(head1);
                    printf("链表初始化成功(长度为5)\n");
                    break;
                }
            case 2:
                {
                    printf("当前链表为：\n");
                    TravelList_Lk(head1);
                    break;
                }
            case 3:
                {
                    int len=ListLength_Lk(head1);
                    printf("当前链表长度为：%d\n",len);
                    break;
                }
            case 4:
                {
                    int a;
                    printf("请输入你要查找的元素值\n");
                    scanf("%d",&a);
                    LocateElem_Lk(head1,a);
                    break;
                }
            case 5:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要（前）插入元素的位置和值:\n");
                    scanf("%d%d",&pos,&a);
                    InsertElem_Lk(head1,pos,a);
                    printf("插入元素成功\n");
                    break;
                }
            case 6:
                {
                    int pos;
                    ElemType a;
                    printf("请输入你要删除元素的位置:\n");
                    scanf("%d",&pos);
                    DeleteElem_Lk(head1,pos,a);
                    printf("你删除的元素为%d\n",a);
                    break;
                }
            case 7:
                {
                    DestroyList_Lk(head1);
                    printf("销毁成功\n");
                    break;
                }
            case 0:
                printf("you choose to exit\nGoodbye!\n");
                return 0;
            }
        }
        else ErrorMessage("请在菜单内挑选功能");
    }
    return 0;

}
/*"."一般情况下理解为"的”
“->”一般理解为"指向的结构体的"
即引用结构体变量中的元素，若变量是一般的结构体变量用“.”，若为指针则用“->”
注意区别头结点和头指针*/

六、后记：

​ 到这里，我终于快写完了我的第一篇博客，我感觉我快要升华了。言归正传，如果要纯c语言实现，将cout换成printf，const改用#dfine，默认参数略作修改，new改用malloc……即可；反之若要纯c++实现（因为c++完全兼容c，我不确定这种说法对不对哈，明白什么意思就行），只需将printf换成cout……，……，……即可。因为我比较懒，就不想再搞了，就这么将就着看（用吧）。至于演示结果，截图不知道放哪了，就省略了吧。

​ 再次提醒，注释里面可能有我在编写/调试过程中的一些杂七杂八的个人标注，看不懂就当没看见就好，我自己往回看我自己可能都看不懂……嗯，就是懒得删了。

​ 第一篇博客，难免有错，欢迎斧正。

你可能感兴趣的:(cc++数据结构和算法)

  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • 【数据结构和算法实践-树-LeetCode110-平衡二叉树】 NeVeRMoRE_2024 数据结构与算法实践算法数据结构leetcodeb树
    数据结构和算法实践-树-LeetCode110-平衡二叉树题目MyThought代码示例JAVA-8题目给定一个二叉树，判断它是否是平衡二叉树输入：root=[3,9,20,null,null,15,7]输出：trueMyThought判断平衡二叉树的条件是树的左右高度相差为1一、利用递归去遍历1、边界为节点为null，树高为0；2、树高的递增规则为，根的左节点和右节点比较值+1二、为了方便信息传
  • 海量数据查找最大K个值：数据结构与算法的选择 星辰@Sea 数据结构Java数据结构
    在处理大数据集时，经常需要找到数据集中最大的K个元素，这样的需求在很多领域都有广泛应用，例如推荐系统中寻找评分最高的K个商品、数据分析中找出最重要的K个特征、搜索引擎中找到排名前K的结果等等。面对海量数据，传统的排序方法可能不再适用，因为它们通常具有较高的时间复杂度。因此，选择合适的数据结构和算法对于提高效率至关重要。本文将详细介绍如何在海量数据集中查找最大的K个值，探讨不同的数据结构与算法选择，
  • 从0开始的算法（数据结构和算法）基础（九） Solidao 算法数据结构java
    二分查找二分查找是一个常规的搜索算法，根据数据的有序性来的。二分查找步骤0.排序，一定要排序，不然这个算法实现不了，可以去看上一篇的排序。初始化边界：首先确定数组的左边界和右边界。左边界一般初始化为0，右边界初始化为数组的长度减1（数组是从0开始的，不要告诉我开始学数据结构的你不知道，array.length-1）。进入循环查找：在左边界小于等于右边界的条件下，继续执行查找操作。计算中间点：每次循
  • Java 学习路线：适合小白的超细学习路线及实例代码 Dreams°123 后端javaeclipsejvmspringtomcatideintellij-idea
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
  • 【数据结构和算法实践-树-LeetCode107-二叉树的层序遍历Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcode
    数据结构和算法实践-树-LeetCode107-二叉树的层序遍历Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root，返回其节点值自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）。输入：root=[3,9,20,null,null,15,7]输出：[[15,7],[9,20],[3]]MyThought题目给定的是通过二叉树的层序去遍历，结合示例
  • 自幂数判断c++ 呃m c++比赛真题c++
    题目描述样例输入3152111153样例输出FFT代码如下：#includeusingnamespacestd;longlongm,a;intmain(){cin>>m;for(inti=1;i>a;longlongt=a,n[10],cc=0,s=0;while(t!=0){//求位数与拆位n[cc]=t%10;t=t/10;cc++;}for(intj=0;j
  • 探索图形算法的奇妙世界：goraph 孔岱怀
    探索图形算法的奇妙世界：goraphgoraphPackagegoraphimplementsgraphdatastructureandalgorithms.项目地址:https://gitcode.com/gh_mirrors/go/goraph在编程领域，数据结构和算法是构建高效应用的基础。今天，我们要向您推荐一款名为【goraph】的开源项目，它是一个用Go语言实现的图形数据结构及其算法库。
  • 【Lidar】基于Python的点云数据下采样+体素显示 RS迷途小书童 激光雷达点云数据python开发语言激光点云数据点云数据处理
    1Open3D库介绍Open3D是一个开源的3D数据处理库，发布于2015年，目前已经更新到0.17.0版本。它基于MIT协议开源许可，使用C++11实现，并经过高度优化，还通过PythonPybinding提供了前端PythonAPI。Open3D为开发者提供了一组精心选择的数据结构和算法，内部实现高度优化并设置为并行化。它处理3D数据的各种应用，包括点云、网格、体积计算、可视化、深度学习、测量
  • 图解数据结构python读书笔记_python cookbook3读书笔记第一章数据结构和算法 eternal?
    pythonheapq模块查询一组序列中最大和最小的数据importheapqnums=[1,8,2,23,7,-4,18,23,42,37,]#获取序列中3个最大值#print(heapq.nlargest(3,nums))#获取序列中3个最小值#print(heapq.nsmallest(3,nums))#把数据压入堆中在堆中最小的那个数值永远排在最前面时间想取出最小的3个数值只需执行3次he
  • 从0开始的算法（数据结构和算法）基础（八） Solidao 算法数据结构排序算法
    说了这么久的数据结构，理论性比较强，下面我们来进入算法部分，运用之前学的数据结构来实现算法。今天的主体部分是排序，难度不大。排序排序的算法是比较简单实用的算法，也是很多的算法的基础。也分很多种，可以根据时间空间难度不同的，有序数据能够被更高效地查找、分析和处理。选择排序选择算法是一个时间复杂度O(n2)，空间复杂度是O(1),运行时间比较长。其主要思想是每次从未排序的部分中选择最小（或最大）的元素
  • 计算机学习 程序员牛马家 java
    不要只盯着计算机语言学习，你现在已经学习了C语言和Java，暑假又规划学习Python，最后你掌握的就是计算机语言包而已。2.建议你找一门想要深挖的语言，沿着这个方向继续往后学习知识就行。计算机语言是学不完的，而未来就业找工作要从事技术岗位，需要不仅仅是计算机语言的，还得学习数据结构和算法、操作系统、计算机网络、数据库、还得做实战项目等等。java不敢用ChatGPT水论文了！OpenAI反作弊工
  • Java 技术栈：Java 中的 HashSet、LinkedHashSet 和 TreeSet（Set 集合）特点与实现解析 阳爱铭 java技术栈javapython开发语言后端数据库架构数据结构个人开发
    Java集合框架（JavaCollectionsFramework）是Java编程语言中处理集合的基础设施，提供了强大的数据结构和算法支持。本文将深入探讨Java中的三种主要Set集合：HashSet、LinkedHashSet和TreeSet，分析它们的特点、实现原理及实际应用场景。1.Set接口概述Set接口是Java集合框架中的一个重要接口，定义了一组不允许重复元素的集合。与List接口不同
  • 在Go中理解栈和先进先出原则 jzpfbpx golang算法开发语言
    Go是一种功能强大的编程语言，提供了丰富的数据结构和算法。堆栈是计算机科学中的基本数据结构之一。在本博文中，我们将探讨如何在Go中实现和使用堆栈，以及堆栈如何遵循先进先出(FIFO)原则。首先，让我们来看看堆栈是什么以及它是如何工作的。栈是一种线性数据结构，用于存储元素集合。堆栈的主要特点是遵循后进先出（LIFO）原则：最后一个添加到堆栈的元素是第一个被移除的元素。下面是一个如何在Go中实现简单堆
  • 数据结构——单向链表（C语言版） GG Bond.ฺ 数据结构链表c语言
    在数据结构和算法中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中，我们可以使用指针来实现单向链表。下面将详细介绍如何用C语言实现单向链表。目录1.定义节点结构体2.初始化链表3.插入节点4.删除节点5.遍历链表6.主函数1.定义节点结构体首先，我们需要定义表示链表节点的结构体。每个节点包含一个数据域和一个指向下一个节点的指针域。typedefst
  • 数据结构与算法-希尔排序 时光不老c 数据结构与算法算法java数据结构
    引言在计算机科学中，数据结构和算法是构建高效软件系统的基石。而排序算法作为算法领域的重要组成部分，一直在各种应用场景中发挥着关键作用。今天我们将聚焦于一种基于插入排序的改进版本——希尔排序（ShellSort），深入了解其原理、实现步骤以及优缺点。一、希尔排序简介希尔排序(ShellSort)是由DonaldShell在1959年提出的，它是对插入排序的一种改进，通过定义一个增量序列来对原始数据进
  • 在Go中理解栈和先进先出原则 ldxxxxll golang算法开发语言
    Go是一种功能强大的编程语言，提供了丰富的数据结构和算法。堆栈是计算机科学中的基本数据结构之一。在本博文中，我们将探讨如何在Go中实现和使用堆栈，以及堆栈如何遵循先进先出(FIFO)原则。首先，让我们来看看堆栈是什么以及它是如何工作的。栈是一种线性数据结构，用于存储元素集合。堆栈的主要特点是遵循后进先出（LIFO）原则：最后一个添加到堆栈的元素是第一个被移除的元素。下面是一个如何在Go中实现简单堆
  • 为什么要学习数据结构和算法？ Programmer Liu 数据结构与算法数据结构算法
    你是不是觉得数据结构和算法，跟操作系统、计算机网络一样，是脱离实际工作的知识？可能除了面试，这辈子也用不着？尽管计算机相关专业的同学在大学都学过这门课程，甚至很多培训机构也会培训这方面的知识，但是据我了解，很多程序员对数据结构和算法依旧一窍不通。还有一些人也只听说过数组、链表、快排这些最最基本的数据结构和算法，稍微复杂一点的就完全没概念。当然，也有很多人说，自己实际工作中根本用不到数据结构和算法。
  • 学习数据结构和算法的第8天 blxx 数据结构学习算法
    顺序表的实现进行头插eg:在数组12345的开头插入-1变成-112345#includetypedefstructSeqList{SLDataTypea[100];//假设顺序表最大容量为100intsize;//当前顺序表的大小}SL;voidSeqListPushFront(SL*ps,SLDataTypex){intend=ps->size-1;while(end>=0){ps->a[en
  • 1～10 luckyhubo
    p1课程内容介绍学习数据结构的重要性线性结构：数组栈队列链表哈希表：树结构：图结构：排序&搜索p2邂逅数据结构和算法p3什么是数据结构数据结构就是在计算机中，存储和组织数据的方式。p4什么是算法
  • 11递归---解析案例汉诺塔问题和斐波那契数列 程序媛小菜鸡成长中 数据结构与算法算法java递归算法
    前言数据结构和算法的最终目标都是降低时间复杂度。数据结构是从数据组织形式的角度达成这个目标；算法则是从数据处理的角度达成这个目标。1、什么递归通俗解释就是某个函数自己调用自己。递归的两层含义：（1）递归问题必须可以分解为若干个规模较小，与原问题形式相同的子问题，并且这些子问题可以用完全相同的解题思路来解决。（2）递归问题的演化过程是一个对原问题从大到小进行拆解的过程，并且会有一个明确的终点（临界点
  • WebSocket | 基于TCP的全双工通信网络协议 逐梦苍穹 JavaEE网络协议websockettcp/ip
    文章目录1、介绍2、示例2.1、分析2.2、代码开发2.3、功能测试作者介绍：双非本科大三网络工程专业在读，阿里云专家博主，专注于Java领域学习，擅长web应用开发、数据结构和算法，初步涉猎Python人工智能开发和前端开发。主页：@逐梦苍穹所属专栏：JavaEE✈您的一键三连，是我创作的最大动力1、介绍WebSocket是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工通信——浏览器
  • 手把手教您刷力扣，击破数据结构和算法--笔记 print('冰心') 力扣入门笔记算法数据结构leetcode
    强推学习视频：手把手带你刷Leetcode力扣｜各个击破数据结构和算法｜大厂面试必备技能【已完结】_哔哩哔哩_bilibili「力扣」8.5折优惠链接：https://leetcode-cn.com/premium/?promoChannel=siyangyuan其他相关合集：手把手带你刷力扣+数据结构+算法合集：BV1sy4y1q79MLeetcode力扣1-300题视频讲解合集：BV1xa41
  • 手把手教您刷力扣，击破数据结构和算法--笔记（链表） print('冰心') 力扣入门笔记算法数据结构leetcode
    强推学习视频：手把手带你刷Leetcode力扣｜各个击破数据结构和算法｜大厂面试必备技能【已完结】_哔哩哔哩_bilibili「力扣」8.5折优惠链接：https://leetcode-cn.com/premium/?promoChannel=siyangyuan其他相关合集：手把手带你刷力扣+数据结构+算法合集：BV1sy4y1q79MLeetcode力扣1-300题视频讲解合集：BV1xa41
  • 力扣算法Algorithm竞赛模板库（codeforces-go）：含了算法竞赛中常用的数据结构和算法实现，助力开发者更高效地解决问题 汀、人工智能 #习题_算法算法leetcode数据结构动态规划图论力扣算法资料
    1.算法Algorithm竞赛模板库（codeforces-go）算法竞赛模板库，为算法竞赛爱好者提供了一系列精心设计的算法模板。这个库包含了算法竞赛中常用的数据结构和算法实现，助力开发者更高效地解决问题一个算法模板应当涵盖以下几点：对该算法的基本介绍（核心思想、复杂度等）参考链接或书籍章节（讲的比较好的资料）模板代码（可以包含一些注释、使用说明）模板补充内容（常见题型中的额外代码、建模技巧等）相
  • JS的高级用法 一只理智恩 jsjavascript前端ajaxnode.jsvue.jsreact.jses6
    关于JS高级用法在学习JavaScript的过程中，我们必须了解一些基础知识，如变量、函数、类、循环等。这些基础知识是我们使用JavaScript的基础。但是，在日常的业务开发中，我们需要一些更高级的技巧来更好地解决问题。通过阅读本文，你将了解到JS的高级知识点以及实际应用技巧，如高级数据结构和算法、函数式编程、异步编程和面向对象编程。我们会利用代码实例来让大家更好地理解这些知识点。同时，我们也会
  • 百度地图接口 | 实现校验收货地址是否超出配送范围 逐梦苍穹 java百度
    目录1.环境准备2.代码开发2.1application.yml2.2OrderServiceImpl作者介绍：双非本科大三网络工程专业在读，阿里云专家博主，专注于Java领域学习，擅长web应用开发、数据结构和算法，初步涉猎Python人工智能开发和前端开发。主页：@逐梦苍穹您的一键三连，是我创作的最大动力1.环境准备百度地图接口一般来说在外卖项目中的功能是，校验收货地址是否超出配送范围注册账号
  • Nginx负载均衡 510888780 nginx应用服务器
    Nginx负载均衡一些基础知识: nginx 的 upstream目前支持 4 种方式的分配 1)、轮询（默认）       每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 2)、weight       指定轮询几率，weight和访问比率成正比
  • RedHat 6.4 安装 rabbitmq bylijinnan erlangrabbitmqredhat
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 机器版本： [root@redhat1 rabbitmq]# lsb_release LSB Version: :base-4.0-amd64:base-4.0-noarch:core
  • FilenameUtils工具类 eksliang FilenameUtilscommon-io
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。
  • xml文件解析SAX 不懂事的小屁孩 xml
    xml文件解析:xml文件解析有四种方式， 1.DOM生成和解析XML文档(SAX是基于事件流的解析) 2.SAX生成和解析XML文档(基于XML文档树结构的解析) 3.DOM4J生成和解析XML文档 4.JDOM生成和解析XML 本文章用第一种方法进行解析，使用android常用的DefaultHandler import org.xml.sax.Attributes;
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区 酷的飞上天空 mysql
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 #!/usr/bin/python # -*- coding: utf8 -*- import pymysql import datetime import calendar #要分区的表 table_name = 'my_table' #连接数据库的信息 host,user,passwd,db =
  • 如何搭建数据湖架构？听听专家的意见 蓝儿唯美 架构
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据  “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
  • spring学习——控制反转与依赖注入 a-john spring
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。  
  • 用spool+unixshell生成文本文件的方法 aijuans xshell
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下: 　　set pages 50000; 　　set lines 200; 　　set trims on; 　　set heading off; 　　spool /oracle_backup/log/test/dept.lst; 　　select deptno||','||dname||','||loc
  • 1、基础--名词解析(OOA/OOD/OOP) asia007 学习基础知识
    OOA:Object-Oriented Analysis（面向对象分析方法） 是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
  • 浅谈java转成json编码格式技术 百合不是茶 json编码java转成json编码
    json编码;是一个轻量级的数据存储和传输的语言       在java中需要引入json相关的包,引包方式在工程的lib下就可以了   JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非   常适合于服务器与 JavaScript 之间的数据的交
  • web.xml之Spring配置(基于Spring+Struts+Ibatis) bijian1013 javaweb.xmlSSIspring配置
    指定Spring配置文件位置 <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml, /WEB-INF/
  • Installing SonarQube（Fail to download libraries from server） sunjing InstallSonar
    1.  Download and unzip the SonarQube distribution 2.  Starting the Web Server The default port is "9000" and the context path is "/". These values can be changed in &l
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查 bit1129 mongodb
    一、创建复本集   假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令：   mongod --port 27017 --dbpath data1 --replSet rs0 mongod --port 27018 --dbpath data2 --replSet rs0 mongod --port 27019 -
  • Anychart图表系列二之执行Flash和HTML5渲染 白糖_ Flash
    今天介绍Anychart的Flash和HTML5渲染功能   HTML5 Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa bozch laravel
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜 bylijinnan 编程之美
    import java.util.Arrays; import java.util.Random; public class Nim { /**编程之美 NIM游戏分析 问题： 有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头， 能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
  • lunce创建索引及简单查询 chengxuyuancsdn 查询创建索引lunce
    import java.io.File; import java.io.IOException; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Docume
  • [IT与投资]坚持独立自主的研究核心技术 comsci it
           和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段.....        所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
  • flashback transaction闪回事务查询 daizj oraclesql闪回事务
       闪回事务查询有别于闪回查询的特点有以下3个： （1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 （2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 （3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件 游其是你 FilenameFilter
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题 dcj3sjt126com c
    # include <stdio.h> int f(void) //括号中的void表示该函数不能接受数据，int表示返回的类型为int类型 { return 10; //向主调函数返回10 } void g(void) //函数名前面的void表示该函数没有返回值 { //return 10; //error 与第8行行首的void相矛盾 } in
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl dcj3sjt126com centos
    今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again   处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 &n
  • 单例模式 shuizhaosi888 单例模式
    单例模式      懒汉式 public class RunMain { /** * 私有构造 */ private RunMain() { } /** * 内部类，用于占位，只有 */ private static class SingletonRunMain { priv
  • Spring Security（09）——Filter 234390216 Spring Security
    Filter 目录 1.1     Filter顺序 1.2     添加Filter到FilterChain 1.3     DelegatingFilterProxy 1.4     FilterChainProxy 1.5
  • 公司项目NODEJS实践0.1 逐行分析JS源代码 mongodbnginxubuntunodejs
      一、前言         前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。         网上有很多nod
  • java.lang.Math liuhaibo_ljf javaMathlang
    System.out.println(Math.PI); System.out.println(Math.abs(1.2)); System.out.println(Math.abs(1.2)); System.out.println(Math.abs(1)); System.out.println(Math.abs(111111111)); System.out.println(Mat
  • linux下时间同步 nonobaba ntp
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
  • ZooKeeper3.4.6的集群部署 roadrunners zookeeper集群部署
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。   1、准备工作 我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。   数据存储目录
  • Java高效读取大文件 tomcat_oracle java
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法： 　　Files.readLines(new File(path), Charsets.UTF_8); 　　FileUtils.readLines(new File(path)); 　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
  • 微信支付api返回的xml转换为Map的方法 xu3508620 xmlmap微信api
    举例如下： <xml>    <return_code><![CDATA[SUCCESS]]></return_code>    <return_msg><![CDATA[OK]]></return_msg>    <appid><
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他