1.顺序表插入+删除,顺序表去重
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef int datatype;
typedef struct
{
int len;
datatype data[MAXSIZE];
}*Seqlist,seq_list;
/*
* function: 顺序表创建
* @param [ in]
* @param [out]
* @return 成功返回首地址,失败返回NULL
*/
Seqlist create_list()
{
Seqlist L = (Seqlist)malloc(sizeof(seq_list));
if(NULL == L)
return NULL;
memset(L->data,0,sizeof(L->data));
L->len = 0;
return L;
}
/*
* function: 顺序表插入,尾插
* @param [ in]
* @param [out] 顺序表,插入的值
* @return
*/
int insert_rear(Seqlist L,datatype e)
{
if(NULL == L || L->len == MAXSIZE)
return -1;
L->data[L->len] = e;
L->len++;
return 0;
}
/*
* function: 顺序表遍历
* @param [ in]
* @param [out] 顺序表
* @return 无
*/
void output(Seqlist L)
{
if(NULL == L || L->len == 0)
return;
for (int i = 0; i < L->len; i++)
{
printf("%d\t",L->data[i]);
}
puts("");
}
/*
* function: 顺序表删除
* @param [ in]
* @param [out] 顺序表
* @return 成功返回0,失败返回-1
*/
int delete_rear(Seqlist L)
{
if(NULL == L || L->len == 0)
return -1;
L->len--;
return 0;
}
/*
* function: 按下标删除
* @param [ in]
* @param [out] 顺序表,下标
* @return 成功返回0,失败返回-1
*/
int delete_sub(Seqlist L,int sub)
{
if (NULL == L || sub < 0 || sub >= L->len)
{
puts("删除失败");
return -1;
}
for (int i = sub; i < L->len; i++)
{
L->data[i] = L->data[i+1];
}
L->len--;
return 0;
}
/*
* function: 顺序表去重
* @param [ in]
* @param [out] 顺序表
* @return 无
*/
void dedup(Seqlist L)
{
int i,j;
for (i = 0; i < L->len-1; i++)
{
for (j = i+1; j < L->len; j++)
{
if(L->data[i] == L->data[j])
{
delete_sub(L,j);
j--;
}
}
}
}
int main(int argc, const char *argv[])
{
Seqlist L = create_list();
//插入
int n = 0;
datatype e;
printf("请输入n的值:");
scanf("%d",&n);
for (int i = 0; i < n; i++)
{
printf("请输入输入的元素:");
scanf("%d",&e);
insert_rear(L,e);
}
output(L);
//删除
/* delete_rear(L);
delete_rear(L);
puts("删除后顺序表为:");
output(L);
*/
dedup(L);
puts("去重后顺序表为:");
output(L);
return 0;
}
2.链表头插+尾插+头删尾删
#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
typedef struct Node
{
union
{
int len;
datatype data;
};
struct Node *next;
}*Linklist;
Linklist create_link(int flag);
int insert_head(Linklist L,datatype e);
void output(Linklist L);
Linklist insert_rear(Linklist L,datatype e,Linklist rear);
int delete_head(Linklist L);
int delete_rear(Linklist L);
#endif
#include "head.h"
/*
* function: 链表的创建
* @param [ in]
* @param [out] 1为头节点,0为普通
* @return 成功返回头节点地址,失败返回NULL
*/
Linklist create_link(int flag)
{
Linklist L = (Linklist)malloc(sizeof(struct Node));
if(NULL == L)
return NULL;
if(1 == flag)
L->len = 0;
if(0 == flag)
L->data = 0;
L->next = NULL;
}
/*
* function: 链表的头插
* @param [ in]
* @param [out] 链表,插入的元素
* @return 成功返回0,失败返回-1
*/
int insert_head(Linklist L,datatype e)
{
if(NULL == L)
return -1;
Linklist s = create_link(0);
if(NULL == s)
return -1;
s->data = e;
s->next = L->next;
L->next = s;
L->len++;
return 0;
}
/*
* function: 链表的输出
* @param [ in]
* @param [out] 链表
* @return 无
*/
void output(Linklist L)
{
if (NULL == L || L->next == NULL)
{
puts("链表为空");
return;
}
Linklist q = L;
while (q->next!=NULL)
{
q = q->next;
printf("%d\t",q->data);
}
puts("");
}
/*
* function: 链表的尾插
* @param [ in]
* @param [out] 链表,插入的元素,尾节点
* @return 成功返回尾节点地址,失败返回NULL
*/
Linklist insert_rear(Linklist L,datatype e,Linklist rear)
{
if(NULL == L)
return NULL;
Linklist s = create_link(0);
if(NULL == s)
return NULL;
s->data = e;
rear->next = s;
rear = s;
L->len++;
return rear;
}
/*
* function: 链表的头删
* @param [ in]
* @param [out] 链表
* @return 成功返回0,失败返回-1
*/
int delete_head(Linklist L)
{
if (NULL == L || L->next == NULL)
{
puts("链表为空");
return -1;
}
Linklist q = L->next;
L->next = q->next;
free(q);
q = NULL;
L->len--;
return 0;
}
/*
* function: 链表的尾删
* @param [ in]
* @param [out] 链表
* @return 成功返回0,失败返回-1
*/
int delete_rear(Linklist L)
{
if(NULL == L || L->next == NULL)
{
puts("链表为空");
return -1;
}
Linklist q = L;
while (q->next->next!=NULL)
{
q = q->next;
}
free(q->next);
q->next = NULL;
L->len--;
return 0;
}
#include "head.h"
int main(int argc, const char *argv[])
{
Linklist L = create_link(1);
int n = 0;
printf("请输入n的个数:");
scanf("%d",&n);
datatype e = 0;
Linklist rear = L;
#if 0
//头插
for (int i = 0; i < n ; i++)
{
printf("输入的元素为:");
scanf("%d",&e);
insert_head(L,e);
}
output(L);
#endif
#if 1
//尾插
for (int i = 0; i < n ; i++)
{
printf("输入的元素为:");
scanf("%d",&e);
rear = insert_rear(L,e,rear);
}
output(L);
#endif
#if 0
//头删
delete_head(L);
delete_head(L);
output(L);
#endif
#if 1
//尾删
delete_rear(L);
delete_rear(L);
output(L);
#endif
return 0;
}
3.链表逆置、链表排序
/*
* function: 链表逆置
* @param [ in]
* @param [out] 链表
* @return 成功返回0,失败返回-1
*/
Linklist rev_linklsit(Linklist L)
{
if (NULL == L || L->next == NULL)
{
puts("链表为空");
return NULL;
}
Linklist q = L;
Linklist p = L->next;
L->next = NULL;
while (p!=NULL)
{
Linklist t = p;
p = p->next;
t->next = q->next;
q->next = t;
}
return L;
}
/*
* function: 单链表冒泡排序
* @param [ in]
* @param [out] 单链表
* @return
*/
void linklist_bubble(Linklist L)
{
if (NULL == L || L->next == NULL)
{
puts("链表为空");
return;
}
for (Linklist i = L->next; i->next!=NULL ; i = i->next)
{
int count = 0;
for (Linklist j = L->next; j->next!=NULL; j = j->next)
{
if (j->data > j->next->data)
{
datatype t = j->data;
j->data = j->next->data;
j->next->data = t;
count++;
}
}
if(0 == count)
break;
}
}
/*
* function: 单链表简单排序
* @param [ in]
* @param [out] 单链表
* @return
*/
void linklist_select(Linklist L)
{
if (NULL == L || L->next == NULL)
{
puts("链表为空");
return;
}
for (Linklist i = L->next; i->next!=NULL; i = i->next)
{
Linklist min = i;
for (Linklist j = i->next; j!=NULL; j = j->next)
{
if (min->data > j->data)
{
min = j;
}
}
if (min!=i)
{
datatype t = min->data;
min->data = i->data;
i->data = t;
}
}
}
4.双向链表头插+头删+尾插+尾删
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype[20];
typedef struct Node
{
union
{
int len;
datatype data;
};
struct Node *next;
struct Node *prev;
}*Doublelink;
/*
* function: 双向链表的创建
* @param [ in]
* @param [out] 1表示头节点,0表示普通节点
* @return 成功返回节点地址,失败返回NULL
*/
Doublelink create_link(int flag)
{
Doublelink L = (Doublelink)malloc(sizeof(struct Node));
if (NULL == L)
return NULL;
if (1 == flag)
L->len = 0;
else if (0 == flag)
strcpy(L->data,"");
L->next = NULL;
L->prev = NULL;
}
/*
* function: 双向链表头插
* @param [ in]
* @param [out] 双向链表,插入的元素
* @return 成功返回0.失败返回-1
*/
int insert_head(Doublelink L,datatype e)
{
if (NULL == L)
return -1;
Doublelink s = create_link(0);
if (NULL == s)
return -1;
strcpy(s->data,e);
s->next = L->next;
s->prev = L;
if (L->next!=NULL)
L->next->prev = s;
L->next = s;
L->len++;
return 0;
}
/*
* function: 双向链表输出
* @param [ in]
* @param [out] 双向链表
* @return
*/
void output(Doublelink L)
{
if (NULL == L || NULL == L->next)
{
puts("链空");
return;
}
Doublelink p = L;
while(p->next!=NULL)
{
p = p->next;
printf("%s\t",p->data);
}
puts("");
}
/*
* function: 双向链表尾插
* @param [ in]
* @param [out] 双向链表,插入的元素,尾节点
* @return 成功返回0,失败返回-1
*/
Doublelink insert_rear(Doublelink L,datatype e,Doublelink rear)
{
if(NULL == L)
return NULL;
Doublelink s = create_link(0);
if(NULL == s)
return NULL;
strcpy(s->data,e);
s->prev = rear;
rear->next = s;
rear = s;
L->len++;
return rear;
}
/*
* function: 双向链表头删
* @param [ in]
* @param [out] 双向链表
* @return 成功返回0,失败返回-1
*/
int delete_head(Doublelink L)
{
if(NULL == L || L->next == NULL)
{
puts("链表为空");
return -1;
}
Doublelink q = L->next;
L->next = q->next;
if(q->next!=NULL)
q->prev = L;
free(q);
q = NULL;
L->len--;
return 0;
}
/*
* function: 双向链表尾删
* @param [ in]
* @param [out] 双向链表,双向链表尾节点
* @return 成功返回0;失败返回-1
*/
Doublelink delete_rear(Doublelink L,Doublelink rear)
{
if(NULL == L || L->next == NULL)
{
puts("链表为空");
return NULL;
}
Doublelink q = rear;
rear->prev->next = NULL;
rear = rear->prev;
free(q);
return rear;
L->len--;
return 0;
}
int main(int argc, const char *argv[])
{
Doublelink L = create_link(1);
int n = 0;
datatype e;
Doublelink rear = L;
while (rear->next!=NULL)
{
rear = rear->next;
}
printf("请输入个数:");
scanf("%d",&n);
#if 0
//头插
for (int i = 0; i < n; i++)
{
printf("请输入%d个元素:",i+1);
scanf("%s",e);
insert_head(L,e);
}
puts("头插");
output(L);
#endif
#if 1
//尾插
for (int i = 0; i < n; i++)
{
printf("请输入%d个元素:",i+1);
scanf("%s",e);
rear = insert_rear(L,e,rear);
}
puts("尾插");
output(L);
#endif
#if 0
//头删
puts("头删后");
delete_head(L);
delete_head(L);
output(L);
#endif
#if 1
//尾删
puts("尾删后");
rear = delete_rear(L,rear);
rear = delete_rear(L,rear);
output(L);
#endif
return 0;
}
5.循环队列
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 5
typedef int datatype;
typedef struct Node
{
datatype data[MAXSIZE];
int front;
int rear;
}Loopqueue;
/*
* function: 循环队列的创建
* @param [ in]
* @param [out]
* @return 成功返回地址,失败返回NULL
*/
Loopqueue *create_queue()
{
Loopqueue *queue = (Loopqueue *)malloc(sizeof(Loopqueue));
if (NULL == queue)
return NULL;
memset(queue->data,0,sizeof(queue->data));
queue->front = queue->rear = 0;
return queue;
}
/*
* function: 循环队列的入队
* @param [ in]
* @param [out] 队列,值
* @return 成功返回0,失败返回-1
*/
int enqueue(Loopqueue *queue,datatype e)
{
//判满
if (NULL == queue || queue->front == (queue->rear+1)%MAXSIZE)
{
puts("队满");
return -1;
}
queue->data[queue->rear] = e;
queue->rear = (queue->rear+1)%MAXSIZE;
return 0;
}
/*
* function: 循环队列出队
* @param [ in]
* @param [out] 队列
* @return 成功返回出队的值,失败返回-1
*/
datatype dequeue(Loopqueue *queue)
{
if (NULL == queue || queue->front == queue->rear)
{
puts("队空");
return -1;
}
datatype e = queue->data[queue->front];
queue->front = (queue->front+1)%MAXSIZE;
return e;
}
/*
* function: 循环队列输出
* @param [ in]
* @param [out] 队列
* @return 无
*/
void output(Loopqueue *queue)
{
if (NULL == queue || queue->front == queue->rear)
{
puts("队空");
return;
}
for (int i = queue->front; i != queue->rear; i = (i+1)%MAXSIZE)
{
printf("%d\t",queue->data[i]);
}
puts("");
}
int main(int argc, const char *argv[])
{
Loopqueue *queue = create_queue();
datatype e = 0;
char ch;
do
{
printf("请输入元素:");
scanf("%d",&e);
enqueue(queue,e);
printf("是否需要入队?Y/N");
scanf(" %c",&ch);
}while ('Y' == ch || 'y' == ch);
output(queue);
do
{
e = dequeue(queue);
printf("出队的元素是:%d\n",e);
printf("是否需要出队?Y/N");
scanf(" %c",&ch);
}while ('Y' == ch || 'y' == ch);
output(queue);
return 0;
}
6.二叉树创建和遍历
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype;
typedef struct Node
{
datatype data;
struct Node *lchild;
struct Node *rchild;
}*Tree;
/*
* function: 二叉树的创建
* @param [ in]
* @param [out]
* @return 成功返回根节点的地址,失败返回NULL
*/
Tree create_tree()
{
datatype e;
printf("请输入数据元素:");
scanf(" %c",&e);
if ('#' == e)
return NULL;
Tree T = (Tree)malloc(sizeof(struct Node));
if (NULL == T)
return NULL;
T->data = e;
puts("left");
T->lchild = create_tree();
puts("right");
T->rchild = create_tree();
return T;
}
/*
* function: 二叉树的先序遍历
* @param [ in]
* @param [out] 二叉树
* @return 无
*/
void first(Tree T)
{
if (NULL == T)
return;
printf("%c ",T->data);
first(T->lchild);
first(T->rchild);
}
/*
* function: 二叉树的中序遍历
* @param [ in]
* @param [out] 二叉树
* @return 无
*/
void mid(Tree T)
{
if (NULL == T)
return;
mid(T->lchild);
printf("%c ",T->data);
mid(T->rchild);
}
/*
* function: 二叉树的后序遍历
* @param [ in]
* @param [out] 二叉树
* @return 无
*/
void last(Tree T)
{
if (NULL == T)
return;
last(T->lchild);
last(T->rchild);
printf("%c ",T->data);
}
int main(int argc, const char *argv[])
{
Tree T = create_tree();
puts("先序遍历");
first(T);
puts("");
puts("中序遍历");
mid(T);
puts("");
puts("后序遍历");
last(T);
puts("");
return 0;
}
7.插入排序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void insert_sort(int *a,int len)
{
int j = 0;
for (int i = 1; i < len; i++)
{
int t = *(a+i);
for (j = i-1; j >= 0; j--)
{
if (t < *(a+j))
*(a+j+1) = *(a+j);
else
break;
}
*(a+j+1) = t;
}
}
void output(int *a,int len)
{
for (int i = 0; i < len ; i++)
{
printf("%d\t",*(a+i));
}
puts("");
}
int main(int argc, const char *argv[])
{
int a[] = {34,231,34,2,323,4,324,235,7657,56775};
int len = sizeof(a) / sizeof(a[0]);
insert_sort(a,len);
output(a,len);
return 0;
}