数据结构与算法

由于c++才看了一点，所以基本都用的c语言实现，哈哈哈，以下程序在vs2010上运行通过，否则我怎么敢放上来呢！！！

 /*有一个顺序表L，其元素为整型数据，设计一算法，将L中所有小于表头元素的整数
放在前半部分，大于表头元素的整数放在后半部分，数组下标1开始存储
*/
#include<iostream>
using namespace std;
#define Maxsize 9//千万不能加分号
typedef struct {
public:
        int data[Maxsize];
        int length;
}SqStack;
 void move(SqStack &L)
 {
   int temp;
   int i=1,j=L.length;//这本书上的代码，在数组里面但是这个长度是顺序表的长度，顺序表从1开始，0位置不存储,所以length！=Maxsize
   temp=L.data[i];
   while(i<j)
   {
     while(i<j&&L.data[j]>temp) --j;//i的元素给出了，停止等待放入，j开始动
     if(i<j) 
     {
         L.data[i]=L.data[j];//i位置填充元素，i动
         ++i;
     }
     while(i<j&&L.data[i]<temp) ++i;//i动直到值给了j所在元素
     if(i<j)
     {
         L.data[j]=L.data[i];
         --j;
     }
   }
  L.data[i]=temp;把temp值放入这个位置

 }
 int main()
 {
     SqStack L={{0,2,-1,4,3,5,1,0,7,},8};//花括号只能用于初始化,不能用于赋值
      move(L);
      for(int i=1;i<=L.length;++i)
      cout<<L.data[i]<<endl;
      return 0;
 }
这个题花了好久啊，没学到快排呢！！！

 /*此程序对应数据结构高分笔记上的题目
/*设计算法，从给定的顺序表中删除重复的结点
*/
#include<iostream>
using namespace std;
typedef struct LNode{
    int data;
    struct LNode* next;
}LNode;
/*创建链表程序*/
 void creatlistr(LNode *&C,int a[],int n)//要改变的变量用引用值 ，C是一个空链表，地址？
{
    LNode *s,*r;//s用来指向新申请的结点，r始终指向c的终端结点
    int i;
    C=(LNode *)malloc(sizeof(LNode));//申请头结点空间
    C->next=NULL;
    r=C;
    for(i=1;i<=n;i++)//循环申请n个结点来接受数组a的值
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=a[i-1];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
/*删除链表重复值*/
void deletecf(LNode *L)
{
    int temp;
    LNode *p=L->next,*q;
    temp=p->data;//存入开始结点的值
    while(p->next!=NULL)
    { 

     if(p->next->data==temp)//因为没有写==号使得程序报错，^(*￣(oo)￣)^啊为什么老是犯这种低级错误
     {
          q=p->next; 
          p->next=q->next;
          free(q);
     }
     else
     {
         temp=p->next->data;
         p=p->next;
     }
    }
}|
/*打印链表的值*/
void print(LNode *L)
{
    LNode *p=L->next;
    while(p!=NULL)
    {
      cout<<p->data<<endl;
      p=p->next;
    }

}
int main()
{
    LNode *C;
    int a[8]={1,1,2,2,3,3,4,4};

    creatlistr(C,a,8); 
    print(C);
    deletecf(C);
    print(C);
}

把考研书上的算法拿来程序实现，估计除了我也没谁了 。。。。

 /*设计一个算法删除一个单链表L（有头结点）中的最小值结点*/
#include<iostream>
using namespace std;
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;
typedef struct{
    int data;
    int index;
}Sput;


/*创建链表
*/
void creatlistr(LNode *&C,int a[],int n)
{
    LNode *r,*s;
    C=(LNode*)malloc(sizeof(LNode));
    C->next=NULL;
    r=C;
    for(int i=1;i<=n;i++)
    {
     s=(LNode*)malloc(sizeof(LNode));
     s->next=NULL;
     s->data=a[i];
     r->next=s;
     r=r->next;//这样写比较明确，移动到下面一个
    }
}
/*找到最小值结点
*/
int findmin(LNode *L,Sput &temp)
{
    LNode *p=L->next;
    int i=1;
    temp.data=p->data;
    p=p->next;
    while(p!=NULL)
    {   
        ++i;
        if(p->data<temp.data)
        {
            temp.data=p->data;
            temp.index=i;
        }   
         p=p->next;
    }   
    return temp.index;//返回最小值索引
}
/*删除最小值结点*/
void deletemin(LNode *&L,int i)
{  
   LNode *p=L->next,*q;
   for(int j=1;j<i-1;++j)
   {
     p=p->next;//这样结束循环时正好是i前面一个，哈哈哈哈或
   }
     q=p->next;
     p->next=p->next->next;
     free(q);

}
/*打印*/
void print(LNode *L)
{
  LNode *p=L->next;
  while(p!=NULL)
  {
      cout<<p->data<<endl;
      p=p->next;
  }
}


int main()
{
    LNode *C=NULL;
    int a[8]={0,3,5,6,2,1,9,0};
    int x;
    Sput temp;
    creatlistr(C,a,7);
    print(C);
    x=findmin(C,temp);
    cout<<x<<endl;
    deletemin(C,x);
    print(C);
}

/*设计一算法将已 经有的链表逆序*/
 void reversel(LNode *L)
{
    LNode *p=L->next,*q;//q指向后继节点，考虑终端情况，
    L->next=NULL;//置空主要为了第一个节点
    while(p!=NULL)
    {
        q=p->next;
        p->next=L->next;//第一个节点本来就在这儿，循环的需要
        L->next=p;//第一个循环过后现在只有一个头结点和一个开始结点
        p=q;//移动到q，即使q已经脱了初始链表
    }
}
//最后p的结点为空，循环停止，此时最后一个已经移动过了

这样的顺序比较合理，确定最后一个结点，就是之前的开始结点，然后利用pq向后移动，知道遇见null，说明移动的够了，一个个的向前插入

 void reversel(LNode *L)
{
    LNode *p=L->next,*q;
    q=p->next;
    p->next=NULL;

    p=q;

    while(p!=NULL)
    {
        q=p->next;
        p->next=L->next;
        L->next=p;
        p=q;
    }
}