数据结构DAY7

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;
}