单链表实现行编辑

头文件

Word_Stack.h

#include<cstdlib>
#include<iostream>
#include<string>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef char SElemType;
typedef int Status;
typedef struct word
{
 SElemType data;
 struct word* next;
}word, *Word;

//构造一个空栈S
Status InitStack(Word& S)
{
 S = (Word)malloc(sizeof(word));
 if (!S)
  exit(OVERFLOW);
 S->next = NULL;
 return OK;
}

//把栈S置为空
Status ClearStack(Word& S)
{
 if (S->next)
 {
  Word p = S->next;
  while (p)
  {
   S->next = p->next;
   free(p);
   p = S->next;
  }
 }
 return OK;
}

//销毁栈S
Status DestroyStack(Word& S)
{
 ClearStack(S);
 free(S);
 S = NULL;
 return OK;
}

//若栈S为空栈，则返回TRUE,否则返回FALSE
Status StackEmpty(Word S)
{
 if (!S->next)
  return TRUE;
 else
  return FALSE;
}

//返回栈S的元素个数，即栈的长度
int StackLength(Word S)
{
 int length = 0;
 Word p = S->next;
 while (p)
 {
  ++length;
  p = p->next;
 }
 return length;
}

//若栈S不空，用e返回S的栈顶元素，并返回OK,否则返回ERROR
Status GetTop(Word S, SElemType& e)
{
 if (!StackEmpty(S))
 {
  e = S->next->data;
  return OK;
 }
 return ERROR;
}

//插入元素e为新的栈顶元素
Status Push(Word& S, SElemType e)
{
 Word s = (Word)malloc(sizeof(word));
 if (!s)
  exit(OVERFLOW);
 s->data = e;
 s->next = S->next;
 S->next = s;
 return OK;
}

//若栈不空，则删除S的栈顶元素，并用e返回其值，并返回OK;否则返回ERROR
Status Pop(Word& S, SElemType& e)
{
 if (!StackEmpty(S))
 {
  Word p = S->next;
  e = p->data;
  S->next = p->next;
  free(p);
  return OK;
 }
 return ERROR;
}

//打印输出栈中元素
Status visit(SElemType data)
{
 if (cout<<data)
  return OK;
 else
  return ERROR;
}

//从栈底到栈顶依次对栈中每个元素调用函数visit().一旦visit()失败，则操作失败
Status StackTraverse(Word S, Status(*visit)(SElemType))
{
 int i = StackLength(S);
 while (1)
 {
  Word p = S;
  for (int j = 0; j < i; ++j)
   p = p->next;
  if (!(*visit)(p->data))
   return ERROR;
  if (S->next == p)
  {
   cout << " ";
   return OK;
  }
  --i;
 }
}

//把字符串转换成字符并用栈存储
Word input(char* str)
{
 char ch;
 Word words=NULL;
 int i = 0;
 if (str[0] == '\0')
  return NULL;
 else
 {
  InitStack(words);
  while (str[i]!= '\0')
  {
   switch (str[i])
   {
   case '@':
    ClearStack(words); break;
   case '#':
    if(!StackEmpty(words))
     Pop(words, ch);
    break;
   default:Push(words, str[i]);
    break;
   }
   i++;
  }
  return words;
 }
}

string char_into_string(char* ch)
{
 string str = ch;
 return str;
}

Line_Link.h

#include"Word_Stack.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;

typedef struct line
{
 Word elem;
 struct line* next;
}line,*Line, *Position;
typedef struct
{
 Line head, tail;
 int len;
}LinkList_Line;

//分配由p指向的值为e的结点，并返回OK;若分配失败，则返回ERROR
Status MakeNode(Line& p,Word e)
{
 p = (Line)malloc(sizeof(line));
 if (!p)
  return ERROR;
 p->elem = e;
 return OK;
}

//释放p所指向的结点
void FreeNode(Line& p)
{
 free(p);
 p = NULL;
}

//构造一个空的线性链表L
Status InitList(LinkList_Line& L)
{
 L.head = (Line)malloc(sizeof(line));
 L.head->next = NULL;
 L.tail = L.head;
 L.len = 0;
 return OK;
}

//销毁线性链表L
Status DestroyList(LinkList_Line& L)
{
 Line p = L.head->next;
 while (p)
 {
  Line q = p->next;
  FreeNode(p);
  p = q;
 }
 FreeNode(L.head);
 return OK;
}

//将线性链表L置为空表
Status ClearList(LinkList_Line& L)
{
 if (!L.head->next)
 {
  L.tail = L.head;
  L.len = 0;
  return OK;
 }
 Line p = L.head->next;
 while (p)
 {
  Line q = p->next;
  FreeNode(p);
  p = q;
 }
 L.head->next = NULL;
 L.tail = L.head;
 L.len = 0;
 return OK;
}

//已知h指向线性链表的头结点，将s所指向结点插入在第一个结点之前
Status InsFirst(Line h, Line s)
{
 s->next = h->next;
 h->next = s;
 return OK;
}

//已知h指向线性链表的头结点，删除链表中的第一个结点并以q返回
Status DelFirst(Line h, Line& q)
{
 q = h->next;
 if (q)
 {
  h->next = q->next;
  q->next = NULL;
  return OK;
 }
 return ERROR;
}

//将指针s所指向的一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
Status Append(LinkList_Line& L, Line s)
{
 int num = 0;
 L.tail->next = s;
 while (s)
 {
  num++;
  if (!s->next)
  {
   L.tail = s;
   L.len += num;
   return OK;
  }
  s = s->next;
 }
 return ERROR;
}

//删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
Status Remove(LinkList_Line& L, Line& q)
{
 if (L.head == L.tail)
  return ERROR;
 Line s = L.head;
 while (s)
 {
  if (L.tail == s->next)
  {
   q = s->next;
   s->next = NULL;
   L.tail = s;
   L.len--;
   return OK;
  }
  s = s->next;
 }
 return ERROR;
}

//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，并修改指针p指向新插入的结点
Status InsBefore(LinkList_Line& L, Line& p, Line s)
{
 Line q = L.head;
 while (q)
 {
  if (q->next == p)
  {
   q->next = s;
   s->next = p;
   p = s;
   L.len++;
   return OK;
  }
  q = q->next;
 }
 return ERROR;
}

//已知p指向线性链表L中的一个结点，将s所指结点插入p所指结点之后，并修改指针p指向新插入的结点
Status InsAfter(LinkList_Line& L, Line& p, Line s)
{
 s->next = p->next;
 p->next = s;
 p = s;
 if (!p->next)
  L.tail = p;
 L.len++;
 return OK;
}

//已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
Status SetCurElem(Line& p, Word e)
{
 p->elem = e;
 return OK;
}

//已知p指向线性链表中的一个结点，返回p所指向结点中数据元素的值
Word GetCurElem(Line p)
{
 return p->elem;
}

//若线性链表L为空，则返回TRUE;否则返回FALSE
Status ListEmpty(LinkList_Line L)
{
 if (!L.len)
  return TRUE;
 else
  return FALSE;
}

//返回线性链表L中元素个数
int ListLength(LinkList_Line L)
{
 return L.len;
}

//返回线性链表L中头结点的位置
Position GetHead(LinkList_Line L)
{
 return L.head;
}

//返回线性链表L中最后一个结点的位置
Position GetLast(LinkList_Line L)
{
 if (L.head->next)
  return L.tail;
 else
  return NULL;
}

//已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置，若无前驱则返回NULL
Position PriorPos(LinkList_Line L, Line p)
{
 if (p == L.head->next)
  return NULL;
 Line q = L.head->next;
 while (q&&q->next)
 {
  if (q->next == p)
   return q;
  q = q->next;
 }
 return NULL;
}

//已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置，若无后继则返回NULL
Position NextPos(LinkList_Line L, Line p)
{
 if (p->next == NULL)
  return NULL;
 return p->next;
}

//返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR
Status LocatePos(LinkList_Line L, int i, Line& p)
{
 if (i<1 || i>ListLength(L))
  return ERROR;
 int j = 0;
 p = L.head;
 while (j<i)
 {
  p = p->next;
  ++j;
 }
 return OK;
}

//关系函数,例如小于等于
Status compare(Word a, Word b)
{
 if (a->data<=b->data)
  return TRUE;
 else
  return FALSE;
}

//返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，若不存在这样的元素则返回NULL
Position LocateElem(LinkList_Line L, Word e, Status(*compare)(Word, Word))
{
 Line p = L.head->next;
 while (p&&!(*compare)(e, p->elem))
 {
  p = p->next;
  if (!p)
   return NULL;
 }
 if (!p)
  return NULL;
 else
  return p;
}

//访问并打印
Status display(Word i)
{
 if (StackTraverse(i,visit))
  return OK;
 else
  return ERROR;
}

//依次对L的每个元素调用函数visit().一旦visit()失败,则操作失败
Status ListTraverse(LinkList_Line L, Status(*display)(Word))
{
 Line p = L.head->next;
 while (p)
 {
  if (!(*display)(p->elem))
   return ERROR;
  p = p->next;
  if (!p)
   cout << endl;
 }
 return OK;
}

//在带头结点的单链表L的第i个元素之前插入元素e
Status ListInsert(LinkList_Line& L, int i,Word e)
{
 Line h, s;
 if (!(MakeNode(s, e)))
  return ERROR;
 if (1 == i)
 {
  InsFirst(L.head, s);
  L.tail = s;
  L.len++;
  return OK;
 }
 if (!LocatePos(L, i - 1, h))
  return ERROR;
 InsFirst(h, s);
 while (s)
 {
  if (!s->next)
   L.tail = s;
  s = s->next;
 }
 L.len++;
 return OK;
}

//在带头结点的单链表L中删除第i个元素，并用e返回
Status ListDelete(LinkList_Line& L, int i, Word& e)
{
 Line p;
 if (!LocatePos(L, i, p))
  return ERROR;
 e = p->elem;
 Line s = PriorPos(L, p);
 if (!s)
  return ERROR;
 s->next = p->next;
 if (!p->next)
  L.tail = s;
 FreeNode(p);
 L.len--;
 return OK;
}

主程序：

#include"Line_Link.h"
int main(void)
{
 LinkList_Line L;
 InitList(L);
 int i = 1;
 char ch[15];
 cout<< "请输入文本:"<<endl;
 while(1)
 {
  cout<< "请输入第"<<i<<"个单词:";
  cin>> ch;
  if (char_into_string(ch) == "exit")
   break;
  Word s=input(ch);
  ListInsert(L, i, s);
  ++i;
 }
 system("cls");
 ListTraverse(L, display);
 return 0;
}