线性表-CFANZ编程社区

/*
线性表
*/
/*
如果是对象，就可以通过"."来调用成员变量。
如果是指针的话，就不能通过"."来调用，而只能使用"->"来调用。
*/
#include <iostream>
#include <stdio.h>
#define MaxSize 100
#define ElemType int
#define InitSize 50
//线性表的顺序定义
typedef struct {
  ElemType data[MaxSize];
  int capacity, length;
}SqList;
//初始化表
bool initList(SqList* &L)
{
  L = (SqList*)malloc(InitSize * sizeof(SqList));
  if (L == NULL)return false;
  L->length = 0;
  L->capacity = MaxSize;
  return true;
}
//求表长
/*
  1 2 3 4 5
  cout 5
*/
int length(SqList* L)
{
  return L->length;
}
//获取每个关键词在顺序表中的位置
/*
  1 2 3 4 5
  cin 5
  cout 5
*/
int locateElem(SqList* L, ElemType e)
{
  if (L->length < 1)
    return -1;
  for (int i = 0;i < L->length;i++)
  {
    if (L->data[i] == e)
      return i + 1;
  }
}
//获取表中第i个位置的元素的值
/*
  i : [1,2,...]
*/
bool getElem(SqList* L, int i, ElemType &e)
{
  if (i < 1 || i > L->length)
    return false;
  e = L->data[i - 1];
}
//在表中第i个位置插入e
bool listInsert(SqList* &L, int i, ElemType e)
{
  //将e插入顺序表L中第i个位置
  if (i<1 || i>L->length + 1)
    return false;
  if (L->length >= MaxSize)
    return false;
  for (int j = L->length;j >= i;j--)
  {
    L->data[j] = L->data[j - 1];
  }
  L->data[i - 1] = e;
  L->length++;
  return true;
}
//删除操作，删除表中第i个位置的元素，并用e返回元素的值
/*
  i:[1, n]
*/
bool listDelete(SqList* &L, int i, ElemType &e)
{
  if (i<1 || i>L->length)
    return false;
  if (L->length <= 0)
    return false;
  e = L->data[i - 1];
  for (int j = i - 1;j + 1< L->length;j++)
  {
    L->data[j] = L->data[j + 1];
  }
  L->length--;
  return true;
}
//打印顺序表
void printList(SqList* L)
{
  if (L->length <= 0)
    return;
  for (int i = 0;i < L->length;i++)
  {
    std::cout << L->data[i] << " ";
  }
  std::cout << std::endl;
  return;
}
//判空
bool isEmpty(SqList* L)
{
  if (L->length == 0)
    return true;
  else
    return false;
}

/*
  P18.1
*/
bool solution1(SqList *&L, ElemType &e)
{
  ElemType min = 0, temp;
  if (L->length == 0)
  {
    return false;
  }
  for (int i = 0;i < L->length;i++)
  {
    if (L->data[i] < L->data[min])
      min = i;
  }
  e = L->data[min];
  L->data[locateElem(L, e) - 1] = L->data[L->length - 1];
  L->length--;
}

/*
  P18.3
*/
bool solution3(SqList *&L, ElemType e)
{
  int k1 = 0, k2 = 0;
  if (L->length == 0)
  {
    return false;
  }
  for (int i = 0;i < L->length;i++)
  {
    if (L->data[i] == e)
    {
      k2++;
    }
    else
    {
      L->data[k1] = L->data[k2];
      k2 += 1;
      k1 += 1;
    }
  }
  L->length = k1;
}

/*
  P18.4
*/
bool solution4(SqList *&L, ElemType s, ElemType t)
{
  int i, j;
  if (L->length == 0 || s >= t)
  {
    return false;
  }
  for (i = 0;i < L->length&&L->data[i] <= s;i++);
  //std::cout << i << std::endl;
  for (j = i;j < L->length&&L->data[j] <= t;j++);
  //std::cout << j << std::endl;
  int size = (j - i + 1);
  for (;j < L->length;j++)
  {
    L->data[i - 1] = L->data[j];
    i++;
  }
  L->length -= size;
}

/*
  P18.6
*/
#include <set>
bool solution6(SqList *&L)
{
  int i, j;
  if (L->length == 0)
  {
    return false;
  }
  std::set<int> s;
  for (int i = 0;i < L->length;i++)
  {
    s.insert(L->data[i]);
  }
  std::set<int>::iterator set_iter;
  i = 0;
  for (set_iter =s.begin();set_iter !=s.end();set_iter++)
  {
    L->data[i++] = *set_iter;
  }
  L->length = s.size();
}

/*
  P18.7
*/
SqList* solution7(SqList *L1, SqList* L2)
{
  SqList*L3;
  int i, j, k = 0;
  if (L1->length == 0 || L2->length == 0)
  {
    return false;
  }
  initList(L3);
  for (i = 0, j = 0;i < L1->length && j < L2->length;)
  {
    if (L1->data[i] < L2->data[j])
    {
      L3->data[k++] = L1->data[i];
      i++;
    }
    else
    {
      L3->data[k++] = L2->data[j];
      j++;
    }
  }
  if (L1->length < L2->length)
  {
    while (i < j)
    {
      L3->data[k++] = L2->data[i];
      i++;
    }
  }
  else
  {
    while (i > j)
    {
      L3->data[k++] = L2->data[j];
      j++;
    }
  }
  L3->length = L1->length + L2->length;
  return L3;
}

/*
  =======================================================
  线性表的链式存储
  =======================================================
*/
typedef struct SqLink{
  ElemType data;
  struct SqLink* next;
};
//尾插法
bool initLink(SqLink* &head)
{
  SqLink* p, *q;
  ElemType data;
  head = (SqLink*)malloc(sizeof(SqLink));
  head->next = NULL;
  head->data = 999;
  q = head;
  std::cin >> data;
  while (data != -1) 
  {
    p = (SqLink*)malloc(sizeof(SqLink));
    p->data = data;
    p->next = NULL;
    q->next = p;
    q = p;
    std::cin >> data;
  }
  return true;
}
//打印
void printLink(SqLink* head)
{
  SqLink* p;
  p = head->next;
  while (p != NULL)
  {
    std::cout << p->data << " ";
    p = p->next;
  }
  std::cout << std::endl;
}

/*
  P38.1
*/
void method1(SqLink* &l, ElemType x)
{
  SqLink*p;
  if (l == NULL)
    return;
  if (l->data == x)
  {
    p = l;
    l = l->next;
    free(p);
    method1(l, x);
  }
  else
    method1(l->next, x);
}
/*
  P38.2
*/
bool method2(SqLink* head, ElemType e)
{
  SqLink*p, *q = head, *dnote;
  if (head->next == NULL)return false;
  p = head->next;
  while (p != NULL)
  {
    if (p->data == e)
    {
      dnote = p;
      q->next = p->next;
      p = p->next;
      free(dnote);
    }
    else if (p&&p->data != e)//可以做到删除最后一个节点,以及节点内的所有等于e的节点
    {
      q = p;
      p = p->next;
    }
  }
  return true;
}
/*
  P38.3
*/
void method3(SqLink* head, int x)
{
  if (head->next != NULL)
  {
    x++;
    method3(head->next, x);
  }
  std::cout << head->data << " " << x << std::endl;
  /*
  if (head->next != NULL)
  3 3
  2 3
  1 2
  */
  /*
  if (head != NULL)
  {
    x++;
    if (head->next != NULL)
      method3(head->next, x);
  }
  std::cout << head->data << " " << x << std::endl;
  3 4
  2 3
  1 2
  */
}
/*
  P38.4
*/
void method4(SqLink* head)
{
  SqLink*q = head, *p = head->next;//q指向最小数的前驱
  SqLink*minPre = q, *minp = p;
  while (p != NULL)
  {
    if (p->data < minp->data)
    {
      minp = p;
      minPre = q;
    }
    q = p;
    p = p->next;
  }
  minPre->next = minp->next;
  free(minp);
}
/*
  P38.5(1)
*/
void method5_1(SqLink* head)
{
  SqLink*p, *r;
  p = head->next;
  head->next = NULL;
  while (p)
  {
    r = p->next;
    p->next = head->next;
    head->next = p;
    p = r;
  }
}
/*
  P38.5(2)
*/
void method5_2(SqLink* L)
{
  SqLink*pre, *p = L->next, *r = p->next;
  p->next = NULL;
  while (r)
  {
    pre = p;
    p = r;
    r = r->next;
    p->next = pre;
  }
  L->next = p;
}
/*
  P39.9
*/
void method9(SqLink* head)
{
  int n = 0, temp;
  SqLink*p = head->next, *q = head->next, *min;
  while (p)
  {
    n++;
    p = p->next;
  }
  p = head->next;
  while (p)
  {
    p = q;
    min = q;
    while(p)
    {
      if (p->data < min->data)
        min = p;
      p = p->next;
    }
    temp = q->data, q->data = min->data, min->data = temp;
    q = q->next;
    p = q;
  }
}

//void main()
//{
//  SqLink*head;
//  initLink(head);
//  method9(head);
//  printLink(head);
//}