//【靜態順序表的練習】
/*
需求：創建一個靜態的順序表存放整數，大小為10，完成以下操作
1，輸入6個整數，打印出順序表中的內容，並顯示表中剩余的空間個數。
2，在順序表中的第3個位置插入元素0，打印輸出順序表中的內容，並顯示表中剩余的空間個數。
3，再試圖插入表中第11個位置整數0，程序提示超出范圍。
4，刪除表中第6個元素，打印出順序表中的內容，並顯示表中剩余的空間個數。
*/
/*
#include<stdio.h>
#define MaxSize 10
//想順序表中插入元素
void insertElem(int Sqlist[],int &len,int i,int x)
{
int t;
if(len==MaxSize || i<1 || i>len+1)
{
printf("插入位置非法！\n");
return;
}
for(t=len-1;t>=i-1;t--)
Sqlist[t+1]=Sqlist[t];
Sqlist[i-1]=x;
len = len+1;
}
//向順序表中刪除元素
void DelElem(int Sqlist[],int &len,int i)
{
int j;
if(i<1 || i>len)
{
printf("This insert is illegal");
return; //非法刪除
}
for(j=i;j<=len-1;j++)
Sqlist[j-1]=Sqlist[j]; //將第i個元素之后的元素前移
len = len-1;
}
//主函數
int main()
{
int Sqlist[MaxSize]; //定義一個靜態順序表
int len,i;
printf("請輸入6個整數（以空格分開）:");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("表中的元素如下：");
for(i=0;i<len;i++)
//輸出順序表中的6個整數
printf("%3d",Sqlist[i]);
//顯示順序表中的剩余空間
printf("\n表中剩余空間為：%d\n",MaxSize-len);
//調用insertElem(int Sqlist[],int &len,int i,int x)函數，向順序表中插入元素
//向順序表中的第3位置插入整數0
printf("在表中的第3個位置插入整數0");
insertElem(Sqlist,len,3,0);
printf("\n");
printf("表中的元素如下：");
for(i=0;i<len;i++)
//輸出順序表中的所有元素
printf("%3d",Sqlist[i]);
//顯示表中剩余空間
printf("\n表中剩余空間為： %d\n",MaxSize-len);
//調用insertElem(int Sqlist[],int &len,int i,int x)函數，在表中的第11位置插入整數0
printf("在表中的第11個位置插入整數0：");
insertElem(Sqlist,len,11,0);
//調用DeElem(int Sqlist[],int &len,int i)函數，刪除順序表中的第6個元素
printf("刪除表中第6個元素");
DelElem(Sqlist,len,6);
printf("表中元素如下：");
for(i=0;i<len;i++)
//輸出順序表中的所有元素
printf("%3d",Sqlist[i]);
printf("\n表中剩余空間為： %d\n",MaxSize-len);
return 0;
}
*/
//【動態順序表的練習】
/*
需求：編寫一個程序，動態的創建一個順序表。要求：順序表的初始長度為10，向順序表中輸入15個整數
並打印出來；再刪除順序表中的第5個元素，打印出刪除后的結果.
*/
/*
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType; //將int定義為ElemType
typedef struct
{
int *elem;
int length;
int listsize;
}Sqlist;
//初始化一個順序表
void initSqlist(Sqlist &L)
{
L.elem = (int *)malloc(MaxSize*sizeof(ElemType));
if(!L.elem)
exit(0);
L.length = 0;
L.listsize = MaxSize;
}
//向順序表中插入元素
void InsertElem(Sqlist &L,int i,ElemType item)
{//向順序表L中第i個位置上插入元素item
ElemType *base,*insertPtr,*p;
if(i<1 || i>L.length+1)
exit(0);
if(L.length>=L.listsize)
{
base = (ElemType *)realloc(L.elem,(L.listsize+10)*sizeof(ElemType));
L.elem = base;
L.listsize+=100;
}
insertPtr = &(L.elem[i-1]); //記下要插入元素位置的地址
for(p = &(L.elem[L.length-1]);p>=insertPtr;p--)
*(p+1) = *p;
*insertPtr = item;
L.length++;
}
//從順序表中刪除元素
void DelElem(Sqlist &L,int i)
{
ElemType *delItem,*q;
if(i<1 || i>L.length)
exit(0);
delItem = &(L.elem[i-1]);
q = L.elem+L.length-1;
for(++delItem;delItem<=q;++delItem)
*(delItem-1) = *delItem;
L.length--;
}
//主函數
int main()
{
Sqlist l;
int i;
//調用initSqlist(Sqlist &L)函數，初始化一個順序表
initSqlist(l);
printf("順序表已創建完畢...");
printf("\n");
printf("向順序表中插入1~15個整數(數字之間用空格分開)\n");
for(i=0;i<15;i++)
InsertElem(l,i+1,i+1);
printf("這個順序表中的元素是：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf("\n");
//調用DelElem(Sqlist &L,int i)函數，刪除第5個元素
DelElem(l,5);
printf("第5個元素已被刪除...");
printf("\n");
printf("元素刪除后，順序表中的元素入下：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf("\n");
return 0;
}
*/
//【數據結構版---線性表-線性表的順序表示和實現（靜態）】
//實現插入元素和刪除元素的功能
/*
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MaxSize 10
typedef int Status; //函數結果狀態類型
typedef int ElemType; //元素類型
//向靜態順序表中插入元素
Status InsertElem(int Sqlist[],int *len,int i,ElemType x)
{
int t;
if(*len==MaxSize || i<1 || i>*len+1)
{
printf("非法插入...");
return OVERFLOW;
}
for(t=*len-1;t>=i-1;t--)
Sqlist[t+1] = Sqlist[t];
Sqlist[i-1] = x;
*len=*len+1;
return OK;
}
//向靜態順序表中刪除元素
Status DelElem(int Sqlist[],int *len,int i)
{
int j;
if(i<1 || i>*len)
{
printf("非法刪除...");
exit(0);
}
for(j=i;j<*len-1;j++)
Sqlist[j-1] = Sqlist[j];
*len = *len - 1;
return OK;
}
//主函數（測試）
int main()
{
int Sqlist[MaxSize]; //定義一個靜態順序表
int len,i;
int e1,e2,x;
printf("請從鍵盤輸入6個整數(數字之間以空格分開):");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("初始靜態順序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n靜態順序表的剩余空間是：%d",MaxSize - len);
printf("\n");
//調用InsertElem(int Sqlist[],int *len,int i,int x)函數，插入元素
printf("輸入你要插入的位置:");
scanf("%d",&e1);
printf("\n");
printf("輸入你要插入的元素:");
scanf("%d",&x);
InsertElem(Sqlist,&len,e1,x);
//輸出當前靜態順序表中的元素，驗證是否正確插入
printf("當前順序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n");
printf("靜態順序表的剩余空間是：%d",MaxSize-len);
printf("\n");
//調用DelElem(int Sqlist[],int *len,int i)函數，刪除指定元素
printf("輸入你要刪除的元素序號:");
scanf("%d",&e2);
DelElem(Sqlist,&len,e2);
//輸出當前靜態順序表中的元素，驗證是否正確刪除
printf("當前順序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n");
printf("靜態順序表的剩余空間是：%d",MaxSize-len);
printf("\n");
return 0;
}
*/
//【數據結構版---線性表-線性表的順序表示和實現（動態）】
/*
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100 //動態順序表存儲空間的初始分配量
#define LISTINCREMENT 10 //動態順序表存儲空間的分配增量
typedef int Status; //函數結果狀態
typedef int ElemType; //元素類型
typedef struct
{
ElemType *elem;
int length;
int listsize;
}Sqlist;
//初始化一個順序表
Status InitList_Sq(Sqlist &L)
{
L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)
exit(OVERFLOW); //存儲分配失敗
L.length = 0; //動態線性表的初始長度為0
L.listsize = LIST_INIT_SIZE; //動態線性表的初始容量
return OK;
}
//向動態線性表中插入元素
Status InsertElem(Sqlist &L,int i,ElemType e)
{
ElemType *newbase,*q,*p;
if(i<1 || i>L.length+1)
return ERROR;
if(L.length >= L.listsize)
{//當前存儲空間已滿，增加分配
newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); //分配失敗
L.elem = newbase;
L.listsize+=LISTINCREMENT;
}
q = &(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1) = *p;
*q = e;
++L.length;
return OK;
}
//順序表的創建
//(老師的作業結果用這個代碼)
//Status Creat_Sq(Sqlist &L)
//{
// ElemType temp;
// printf("請輸入你要插入到動態順序表中的元素(ending 9999):");
// scanf("%d",&temp);
// while(temp!=9999)
// {
// InsertElem(L,L.length+1,temp);
// printf("請輸入你要插入到動態順序表中的元素(ending 9999):");
// scanf("%d",&temp);
// }
// return OK;
//}
Status Creat_Sq(Sqlist &L)
{
ElemType temp,n,i;
printf("請輸入你要插入元素的個數：");
scanf("%d",&n);
printf("\n請輸入你要插入的元素（以空格分開）:");
for(i=0;i<n;i++)
{
scanf("%d",&temp);
InsertElem(L,L.length+1,temp);
}
return OK;
}
//順序表的遍歷
Status Print_Sq(Sqlist L)
{
int i;
for(i=0;i<L.length;i++)
printf("%4d",L.elem[i]);
printf("\n");
return OK;
}
//向動態順序表中刪除元素
Status DelElem(Sqlist &L,int i,ElemType &e)
{
ElemType *p,*q;
if(i<1 || i>L.length)
return ERROR;
p = &(L.elem[i-1]);
e = *p; //把要刪除的元素的值賦給e
q = L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1) = *p;
--L.length;
return OK;
}
//順序表的查找
Status Locate_Sq(Sqlist L,ElemType e)
{
int i,n;
char change;
ElemType *p;
p = L.elem;
for(i=0;i<L.length;i++)
{
if(*p++ == e)
n = i;
}
printf("你要找的%d是第%d個元素\n",L.elem[n],n+1);
return OK;
}
//順序表的排序
void Sort_Sq(Sqlist &L)
{
int i,j;
char change;
ElemType temp;
i = L.elem[L.length-1];
for(change = TRUE;i>=1;i--)
{
change = FALSE;
for(j=0;j<i-1;j++)
{
if(L.elem[j]>L.elem[j+1])
{
temp = L.elem[j];
L.elem[j] = L.elem[j+1];
L.elem[j+1] = temp;
change = TRUE;
}
}
}
}
//主函數
int main()
{
ElemType e,e1,e2,e3,e4;
Sqlist sq;
InitList_Sq(sq);
printf("動態順序表已創建好...\n");
Creat_Sq(sq);
printf("\n");
printf("順序表中的元素有:\n");
Print_Sq(sq);
printf("\n");
printf("請輸入要插入的位置：");
scanf("%d",&e1);
printf("\n請輸入你要插入的元素：");
scanf("%d",&e2);
InsertElem(sq,e1,e2);
printf("插入元素后，順序表中的元素如下:\n");
Print_Sq(sq);
printf("\n");
printf("請輸入你要刪除的元素的位置：");
scanf("%d",&e3);
DelElem(sq,e3,e);
printf("刪除指定元素后，順序表中的元素如下：\n");
Print_Sq(sq);
printf("\n");
printf("請輸入你要查找的元素：");
scanf("%d",&e4);
Locate_Sq(sq,e4);
Sort_Sq(sq);
printf("排序后的結果是：\n");
Print_Sq(sq);
return 0;
}
*/
//【數據結構版--線性表的鏈式表示和實現】
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //infeasible-->不可行的
#define NULL 0
typedef int Status;
typedef int ElemType;
//定義結構體
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//帶表頭結點的單鏈表的插入
Status Listinsert_L(LinkList &L,int i,ElemType e)
{
LinkList p,s;
int j;
p = L;
j = 0;
while(p && j<i-1)
{
p = p->next;
++j;
}
if(!p || j>i-1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); //生產新結點
s->data=e;
s->next=p->next;
p->next=s;
L->data++;
return OK;
}
//【頭插法】逆序輸入n個元素的值，創建一個帶表頭節點的單鏈表
/*
void CreatList_L(LinkList &L,int n)
{
int i;
LNode *p;
L=(LinkList)malloc(sizeof(LNode));
L->data=0; //令表頭中的數據域內的值為0（其值為表中元素的個數）
L->next=NULL; //建立帶表頭節點的單鏈表
printf("Please input data:(輸入8個整數,由大到小輸入)\n");
for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next = L->next;
L->next=p;
L->data++; //遞增表中元素的個數
}
// printf("%d",L->data); //此處L->data的功能是輸出表中元素的個數
}
*/
//尾插法
Status CreatList_L(LinkList &L)
{
ElemType temp;
L=(LinkList)malloc(sizeof(LNode));
if(!L) return ERROR;
L->data=0;
L->next=NULL;
printf("Please Input data (9999) ending\n");
scanf("%d",&temp);
while(temp!=9999)
{
Listinsert_L(L,L->data+1,temp);
scanf("%d",&temp);
}
return OK;
}
//查找單鏈表中第i個元素，若存在，其值賦給e並返回OK,否則返回ERROR
Status GetElem_L(LinkList L,int i,ElemType &e)
{
//L為帶頭結點的單鏈表的頭指針
LNode *p1;
p1=L->next;
int j=1; //初始化，p指向第一個結點，j為計數器
while(p1 && j<i)
{
p1 = p1->next;
++j;
}
if(!p1 || j>i)
return ERROR; //第i個元素不存在
e=p1->data;
return OK;
}
//帶頭結點單鏈表的刪除
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
LNode *p,*q;
int j;
p = L;
j=0;
while(p->next && j<i-1) //注意不能寫成（p && j<i-1）
{
p=p->next;
++j;
}
if(!(p->next) || j>i-1)
return ERROR;
q = p->next;
p->next = q->next;
e = q->data;
//printf("%d",e);
free(q);
L->data--; //使鏈表中的元素個數減一
return OK;
}
//求單鏈表的長度的函數
void Length_L(LinkList L)
{
int num=0;
LinkList p;
p=L->next;
while(p)
{
printf("%3d",p->data);
p=p->next;
num++;
}
printf("\n這個單鏈表的長度為：%d",num);
}
//定義輸出鏈表函數
Status Print_L(LinkList L)
{
LinkList p;
p=L->next;
printf("this list contains %d elements\n",L->data);
while(p)
{
printf("%4d->",p->data);
p=p->next;
}
printf("NULL\n");
return OK;
}
/*已知線性表中的元素以值遞增有序排列,並以單鏈表作存儲結構。
寫一高效算法，刪除表中所有值大於mink且小於maxk的元素（若表中存在這樣的元素）
同時釋放被刪節點空間，並分析算法時間復雜度。
（考慮當這個線性表不是有序排列該怎么辦，那就寫一個單鏈表的排序算法，
若單鏈表的元素無序，則先調用排序算法進行排序，再調用此算法進行刪除）*/
Status Delete_Between(LinkList &L,int mink,int maxk)
{
LNode *p,*q;
p = L;
while(p->next->data<=mink)
p=p->next; //p是最后一個不大於mink的元素
if(p->next) //如果還有比mink更大的元素
{
q=p->next;
while(q->data<maxk)
q=q->next; //q是第一個不小於maxk的元素
p->next=q;
}
return OK;
}
//建立主函數
int main()
{
LinkList L;
int n=8,i,i_1,i_2,e,e_1,e_2,e_3,e_4;
//調用CreatList_L函數，創建一個單鏈表
//printf("Please input the number in the list:\n");
//CreatList_L(L,n); //調用頭插法時用
CreatList_L(L);
printf("\n");
//調用GetElem_L函數，查找單鏈表中的第i個元素,調用Length_L函數，求表長
printf("單鏈表中的數據為：\n");
Print_L(L);
printf("\n");
printf("\n請輸入你要獲取的元素序號:");
scanf("%d",&i);
GetElem_L(L,i,e);
printf("the %dth number is:%d",i,e);
printf("\n");
//調用Listinsert_L函數，實現元素插入功能,然后調用輸出鏈表函數，輸出插入后的鏈表
printf("清輸入插入元素的位置：\n");
scanf("%d",&i_1);
printf("\n請輸入要插入的元素：\n");
scanf("%d",&e_1);
Listinsert_L(L,i_1,e_1);
Print_L(L);
printf("\n");
//調用Delete函數，用來刪除指定的元素,然后再調用Print_L函數輸出刪除元素后的鏈表
printf("請輸入要刪除的位置是：\n");
scanf("%d",&i_2);
ListDelete_L(L,i_2,e_2);
Print_L(L);
printf("\n");
//調用Delete_Between函數，用來刪除指定兩個元素之間的元素,然后調用Print函數，輸出操作后的鏈表
printf("\n刪除a和b之間的元素，請輸入：");
scanf("%d%d",&e_3,&e_4);
Delete_Between(L,e_3,e_4);
Length_L(L);
Print_L(L);
printf("\n");
return 0;
}